All entity and persistent objects are saved to and retrieved from an entity store. Entity stores can contain multiple class types. In fact, you typically only need one entity store for a given application.
To use an entity store, you must first open an environment and then provide that environment handle to the EntityStore constructor. When you shutdown your application, first close your entity store and then close your environment.
Entity stores have configurations in the same way that environments have configurations. You can use a StoreConfig object to identify store properties, such as whether is it allowed to create the store if it does not currently exist or if the store is read-only. You also use the StoreConfig to declare whether the store is transactional.
EntityStore objects also provide methods for retrieving information about the store, such as the store's name or a handle to the underlying environment. You can also use the EntityStore to retrieve all the primary and secondary indices related to a given type of entity object contained in the store. See Accessing Indices for more information.
The applications that we are building for our example both must open and close environments and entity stores. One of our applications is writing to the entity store, so this application needs to open the store as read-write. It also wants the store to be transactional, and it wants to be able to create the store if it does not exist.
Our second application only reads from the store. In this case, the store should be opened as read-only.
We perform these activities by creating a single class that is responsible for opening and closing our store and environment. This class is shared by both our applications. To use it, callers need to only provide the path to the environment home directory, and to indicate whether the object is meant to be read-only. The class implementation is as follows:
package persist.gettingStarted; 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; public class MyDbEnv { private Environment myEnv; private EntityStore store; // Our constructor does nothing public MyDbEnv() {} // The setup() method opens the environment and store // for us. public void setup(File envHome, boolean readOnly) throws DatabaseException { EnvironmentConfig myEnvConfig = new EnvironmentConfig(); StoreConfig storeConfig = new StoreConfig(); myEnvConfig.setReadOnly(readOnly); storeConfig.setReadOnly(readOnly); // If the environment is opened for write, then we want to be // able to create the environment and entity store if // they do not exist. myEnvConfig.setAllowCreate(!readOnly); storeConfig.setAllowCreate(!readOnly); // Allow transactions if we are writing to the store. myEnvConfig.setTransactional(!readOnly); storeConfig.setTransactional(!readOnly); // Open the environment and entity store myEnv = new Environment(envHome, myEnvConfig); store = new EntityStore(myEnv, "EntityStore", storeConfig); } // Return a handle to the entity store public EntityStore getEntityStore() { return store; } // Return a handle to the environment public Environment getEnv() { return myEnv; } // Close the store and environment. public void close() { if (store != null) { try { store.close(); } catch(DatabaseException dbe) { System.err.println("Error closing store: " + dbe.toString()); System.exit(-1); } } if (myEnv != null) { try { // Finally, close environment. myEnv.close(); } catch(DatabaseException dbe) { System.err.println("Error closing MyDbEnv: " + dbe.toString()); System.exit(-1); } } } }