经过上篇博文的学习，相信你已经对Berkeley Database Java Edition 对象有了一定的了解，那么现在我们就来试试怎么样把一个对象保存到Berkeley Database 文件数据库中并进行读写。

实战JE 保存和读取一个对象

1.首先我们需要创建一个Java Project,我给它取名叫 BDB_JE_Traning

2.然后我们需要下载JE（Berkeley Database Java Edition的简称）所需要的类库
Berkeley DB Java Edition (JE) Oracle 官网快速下载

注意： 在下载之前你需要用邮箱注册一个Oracle账号

3.点击上面的链接你应该能找到这样的页面

4.创建一个lib文件夹然后将刚下载的jar三个jar包放到这个文件夹下

5.添加项目依赖

选中三个jar 包右键——>Build Path———> Add to Build Path

一切准备完毕后会变成这样

6.我们还需要模拟一个对象，所以创建一个实体类对象User，三个成员变量，用户id,用户名称，用户密码

代码如下所示：

import java.io.Serializable;

import com.sleepycat.persist.model.Entity;
import com.sleepycat.persist.model.PrimaryKey;


@Entity
public class User implements Serializable{

    /**
     *    用户表
     */

    private static final long serialVersionUID = 6919171685887171988L;

    @PrimaryKey
    private long userId;//用户Id 主键

    private String userName;
    private String password;

    public long getUserId() {
        return userId;
    }
    public void setUserId(long userId) {
        this.userId = userId;
    }
    public String getUserName() {
        return userName;
    }
    public void setUserName(String userName) {
        this.userName = userName;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }

    @Override
    public String toString() {
        // TODO Auto-generated method stub
        return super.toString();
    }
}

这个实体类和普通的实体类相差不大，只是多了两个注解。

@Entity 标明这是JE 实体类, 注意包名别引错了

com.sleepycat.persist.model.Entity

@PrimaryKey 标明这个字段是一个主键，和数据库中的主键很类似，值不可重复
包名注意下，具体怎么用接着往下看

com.sleepycat.persist.model.PrimaryKey

7.由于打开和关闭Environment 和EntityStore 和业务无关，因此我们最好封装一个类

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;

/**
 *  Berkeley Database Java Edition 
 *  环境管理器
 * @author fairy
 * **/
public class BDBEnvironmentMangager {
    private Environment myEnvironment;
    private EntityStore myEntityStore;

    //空的构造器
    public BDBEnvironmentMangager() {}

    /**
     * 初始化BDB环境
     * */
    public void setup(File envHome, boolean readOnly)
            throws DatabaseException {

            //创建一个BDB 环境配置对象
            EnvironmentConfig myEnvConfig = new EnvironmentConfig();
            //创建一个数据存储配置对象
            StoreConfig myStoreConfig = new StoreConfig();

            //设置该环境是否为只读,true 为只读，false 为可读写
            myEnvConfig.setReadOnly(readOnly);
          //设置数据存储配置是否为只读,true 为只读，false 为可读写
            myStoreConfig.setReadOnly(readOnly);

            //如果该环境不存在是否重建，true 允许重建，false 不可重建
            myEnvConfig.setAllowCreate(!readOnly);
            //如果该存储配置不存在是否重建，true 允许重建，false 不可重建
            myStoreConfig.setAllowCreate(!readOnly);

            // 打开 environment 和 entity store
            myEnvironment = new Environment(envHome, myEnvConfig);
            myEntityStore = new EntityStore(myEnvironment, "EntityStore", myStoreConfig);

        }

    // Close the store and environment.
    public void close() {
        //判断存储对象是否为空
        if (myEntityStore != null) {
            try {
                //尝试关闭存储对象
                myEntityStore.close();
            } catch(DatabaseException dbe) {
                System.err.println("Error closing store: " +dbe.toString());
               System.exit(-1);
            }
        }
        //判断环境是否为空
        if (myEnvironment != null) {
            try {
                // 关闭环境
                myEnvironment.close();
            } catch(DatabaseException dbe) {
                System.err.println("Error closing MyDbEnv: " + dbe.toString());
               System.exit(-1);
            }
        }
    }

    //Getter and Setter
    public Environment getMyEnvironment() {
        return myEnvironment;
    }

    public void setMyEnvironment(Environment myEnvironment) {
        this.myEnvironment = myEnvironment;
    }

    public EntityStore getMyEntityStore() {
        return myEntityStore;
    }

    public void setMyEntityStore(EntityStore myEntityStore) {
        this.myEntityStore = myEntityStore;
    }
}

注释很详细，不做过多解释，但我们要明白这几点：

• Environment ： 数据库环境对象，一个数据库环境对象下可以存放多个数据库对象
• EnvironmentConfig ：数据库环境配置对象，用来设置数据库的一些属性。
• EntityStore：实体存储对象，读写最基础的存储单元对象
• StoreConfig :数据存储配置对象，来配置EntityStore对象的一些属性。

8.好了一切准备工作完成，我们创建一个主方法来使用它吧。

import java.io.File;

import com.sleepycat.persist.EntityStore;
import com.sleepycat.persist.PrimaryIndex;
import com.xingyun.model.User;
import com.xingyun.util.BDBEnvironmentMangager;

public class MainTest {

    // 配置数据库环境文件路径,
    private final static String BDB_ENV_HOME_FILE_PATH = "bdb_env_home";
    //数据库环境文件
    private final static File BDB_ENV_HOME_File = new File(BDB_ENV_HOME_FILE_PATH);
    public static void main(String[] args) {

        BDBEnvironmentMangager bdbEnvironmentMangager=new BDBEnvironmentMangager();

        //如果数据库环境文件对象不存在
        if(!BDB_ENV_HOME_File.exists()) {
            //创建这个文件路径
            BDB_ENV_HOME_File.mkdirs();
        }

        //数据库环境初始化操作
        bdbEnvironmentMangager.setup(BDB_ENV_HOME_File,false);

        //存放数据
        EntityStore entityStore=bdbEnvironmentMangager.getMyEntityStore();
        //封装对象
        User user=new User();
        user.setUserId(1L);
        user.setUserName("admin");
        user.setPassword("admin");

        //创建对象索引
        PrimaryIndex<Long,User> myUserData=entityStore.getPrimaryIndex(Long.class,User.class);  
        //存放对象
        myUserData.put(user);

        //查询数据
        User myUser=myUserData.get(1L);

        System.out.println(myUser.getUserId());
        System.out.println(myUser.getUserName());
        System.out.println(myUser.getPassword());

        //关闭BDB环境
        bdbEnvironmentMangager.close();
    }
}

代码注释很详细，这就是最简单的用法
运行结果：

源码下载

如果感兴趣，欢迎继续关注下一集集合对象结合数据访问器的读写操作的内容。