Entity Stores
Prev | Chapter 3. Getting Going with the Direct Persistence Layer | Next

## Entity Stores

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.

### MyDbEnv

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);
                }
            }
        }
    }

Prev | Up | Next
Chapter 3. Getting Going with the Direct Persistence Layer | Home | Accessing Indices