Need JSP reassurance with JDB - Please.

Question

Hi there,
I have recently taken on a JSP project for a client, during which their technical department withdrew the offer of access to their relational database (oracle). A solution was required in order to keep the project alive. I chose to work with the Berkeley Database Java Edition. The site uses AJAX calls to trigger calls to the JDB via JSP pages for a range of operations such as user information, event information, media playlist info etc...
So far things are going very well and the database is performing all of the tasks that I require. However currently its just myself and a couple of other users from my company testing the site. The client expects up to 600 000 users. Potentially this may mean hundreds of writes per second. I am worried about handling the multiple writes in rapid sequence...
I am using the direct persistence layer and am not currently using any concurrency measures as thread safety is a little beyond my Java comfort level - also I'm not sure if they are required for this use. If one JSP page request is writing to the same database as another will the first request lock the database automagically until it is finished?
I know code always helps, so lets take this simplified example - an AJAX function calls an 'updateUserInfo.jsp' page that contains the following code:
<%@ page import="schemas.user.*" %>
<%
response.setContentType("text/html");
response.setHeader("Cache-Control", "no-cache");
String userNumber = request.getParameter("userNumber");
String userName = request.getParameter("userName");
String userEmail = request.getParameter("userEmail");
String userPassword = request.getParameter("userPassword");
UserStorePut usp = new UserStorePut();
usp.run(userNumber, userName, userEmail, userPassword);
response.getWriter().write("success");
%>
The corresponding userStorePut class:
package schemas.user;
import java.io.File;
import com.sleepycat.je.DatabaseException;
import com.sleepycat.je.Environment;
import com.sleepycat.je.EnvironmentConfig;
import com.sleepycat.persist.EntityStore;
import com.sleepycat.persist.StoreConfig;
import schemas.autoint.*;
public class UserStorePut {
     private static File envHome = new File("/usr/local/bea/wlserver_10.3/samples/server/examples/build/mainWebApp/WEB-INF/classes/schemas/JEDB");
private Environment envmnt;
private EntityStore store;
private UserDA sda;
// The setup() method opens the environment and store
// for us.
public void setup()
throws DatabaseException {
EnvironmentConfig envConfig = new EnvironmentConfig();
StoreConfig storeConfig = new StoreConfig();
envConfig.setAllowCreate(true);
storeConfig.setAllowCreate(true);
// Open the environment and entity store
envmnt = new Environment(envHome, envConfig);
store = new EntityStore(envmnt, "EntityStore", storeConfig);
// Close our environment and store.
public void shutdown()
throws DatabaseException {
store.close();
envmnt.close();
// Populate the entity store
public void run(String userNumber, String userName, String userEmail, String userPassword)
throws DatabaseException {
setup();
// Open the data accessor. This is used to store
// persistent objects.
sda = new UserDA(store);
// Instantiate and store some entity classes
UserEntity sec1 = new UserEntity();
sec1.setUserNumber(userNumber);
          sec1.setUserName(userName);
sec1.setEmail(userEmail);
          sec1.setPassword(userPassword);
sda.pIdx.put(sec1);
shutdown();
Thanks in advance if anyone will take the time to help me resolve this concern.
Regards,
Reece.

Answer 1

Hi Reece,
Hundreds of writes per second is an easy requirements for JE to meet, and thousands of writes per second is common. You don't have to synchronize to do writes from multiple threads -- this is documented in the Getting Started guide, and the Transaction guide has information you should take a look at. You should be configuring the store as transactional if you define any secondary indices.
One thing you're doing that will NOT perform well is that you're opening and closing the JE environment and store every time you do a put operation. The environment and store should be opened when your application starts and left open as long as your application is running. The overhead of opening and closing these objects is high, and not intended to be done often.
JSP provides access to the servlet application context, and you should probably store your UserStorePut object there, calling your setup method only once. You should call your shutdown method only once when the application is stopped normally. You may need to talk to people on a JSP forum about how to do this, as our JE team does not have experience in this area. Other users on the forum may be able to help, but a JSP forum is your best bet if you can't figure this out from the JSP docs.
If the application stops abnormally, your data will still be intact when it starts up again, but the initial creation of the Environment object (what is called "recovery") will take longer. Please see the discussion of durability in the Transaction user guide.
There is no way around having to read the Getting Started and Transaction guides if you intend to deploy an application, so I strongly encourage you to do so.
--mark