Java嵌入式数据库berkeleyDB(一)

最新推荐文章于 2024-08-02 21:58:03 发布

wwk168

最新推荐文章于 2024-08-02 21:58:03 发布

阅读量1k

点赞数

文章标签：数据库嵌入式 java database string null

官方主页
http://www.oracle.com/technology/software/products/berkeley-db/je/index.html

下载地址：
http://download.oracle.com/berkeley-db/je-3.3.62.zip
http://download.oracle.com/berkeley-db/je-3.3.62.tar.gz

解开包后把JE_HOME/lib/je-<version>.jar 中的jar文件添加到你的环境变量中

1、EnvironmentConfig 数据库环境设置

setAllowCreate() ;
如果设置了true则表示当数据库环境不存在时候重新创建一个数据库环境，默认为false.

setReadOnly()
以只读方式打开，默认为false.

setTransactional()
事务支持,如果为true，则表示当前环境支持事务处理，默认为false，不支持事务处理。

setCachePercent()
设置当前环境能够使用的RAM占整个JVM内存的百分比。

setCacheSize()
设置当前环境能够使用的最大RAM。单位BYTE

setTxnNoSync()
当提交事务的时候是否把缓存中的内容同步到磁盘中去。
true 表示不同步，也就是说不写磁盘

setTxnWriteNoSync()
当提交事务的时候，是否把缓冲的log写到磁盘上
true 表示不同步，也就是说不写磁盘

2、数据库属性设置 DatabaseConfig

setAllowCreate()
如果是true的话，则当不存在此数据库的时候创建一个。

setBtreeComparator()
设置用于Btree比较的比较器，通常是用来排序

setDuplicateComparator()
设置用来比较一个key有两个不同值的时候的大小比较器。

setSortedDuplicates()
设置一个key是否允许存储多个值，true代表允许，默认false.

setExclusiveCreate()
以独占的方式打开，也就是说同一个时间只能有一实例打开这个database。

setReadOnly()
以只读方式打开database,默认是false.

setTransactional()
如果设置为true,则支持事务处理，默认是false，不支持事务。

3、数据库管理 Database
Database.getDatabaseName()
取得数据库的名称
如：String dbName = myDatabase.getDatabaseName();

Database.getEnvironment()
取得包含这个database的环境信息
如：Environment theEnv = myDatabase.getEnvironment();

Database.preload()
预先加载指定bytes的数据到RAM中。
如：myDatabase.preload(1048576l); // 1024*1024

Environment.getDatabaseNames()
返回当前环境下的数据库列表
如：
import java.util.List;
List myDbNames = myDbEnv.getDatabaseNames();
for(int i=0; i < myDbNames.size(); i++) {
System.out.println("Database Name: " + (String)myDbNames.get(i));
}

Environment.removeDatabase()
删除当前环境中指定的数据库。

测试代码如下BerkeleyDBService.java:

package com.sillycat.plugin.berkeley;

import java.io.File;
import java.io.UnsupportedEncodingException;

import com.sleepycat.je.Database;
import com.sleepycat.je.DatabaseConfig;
import com.sleepycat.je.DatabaseEntry;
import com.sleepycat.je.DatabaseException;
import com.sleepycat.je.Environment;
import com.sleepycat.je.EnvironmentConfig;
import com.sleepycat.je.LockMode;
import com.sleepycat.je.OperationStatus;

public class BerkeleyDBService {

private static final String DB_ENVIRONMENT_ROOT = "D:/dbRoot";

private Environment myDBEnvironment = null;

private static Database myDB = null;

/**
* 打开database环境
*
* @return
*/
public void createDBEnvironment() {
   if (myDBEnvironment != null) {
    return;
   }
   try {
    EnvironmentConfig config = new EnvironmentConfig();
    config.setAllowCreate(true);// 如果不存在则创建一个
    config.setReadOnly(false); // 以只读方式打开，默认为false
    config.setTransactional(true); // 事务支持,如果为true，则表示当前环境支持事务处理，默认为false，不支持事务处理
    myDBEnvironment = new Environment(new File(DB_ENVIRONMENT_ROOT),
      config);
   } catch (DatabaseException e) {
    e.printStackTrace();
   }
}

/**
* RAM cache命中率
*
* @return
*/
public long getRAMStatus() {
   long status = 0;
   try {
    // 来监视RAM cache命中率
    status = myDBEnvironment.getStats(null).getNCacheMiss();
   } catch (DatabaseException e) {
    e.printStackTrace();
   }
   return status;
}

/**
* 关闭database环境
*/
public void closeDBEnvironment() {
   try {
    if (myDBEnvironment != null) {
     myDBEnvironment.cleanLog(); // 在关闭环境前清理下日志
     myDBEnvironment.close();
    }
   } catch (DatabaseException e) {
    e.printStackTrace();
   }
}

/**
* 创建一个数据库
*/
public void createDB() {
   // 打开一个数据库，数据库名为
   // sampleDatabase,数据库的配置为dbConfig
   if (myDB != null) {
    return;
   }
   DatabaseConfig dbConfig = new DatabaseConfig();
   dbConfig.setAllowCreate(true);
   try {
    myDB = myDBEnvironment.openDatabase(null, "sampleDatabase",
      dbConfig);
   } catch (DatabaseException e) {
    e.printStackTrace();
   }
}

/**
* 关闭数据库
*/
public void closeDB() {
   try {
    if (myDB != null) {
     myDB.close();
    }
   } catch (DatabaseException e) {
    e.printStackTrace();
   }
}

public static void main(String[] args) {
   BerkeleyDBService bService = new BerkeleyDBService();
   bService.createDBEnvironment();
   bService.createDB();

   // 记录
   String aKey = "001";
   String aData = "我是正文内容";

   // 最好指定编码方式，因为不指定编码会用系统的默认编码来转换，
   // 因为系统的默认编码可能会被人更改。
   try {
    DatabaseEntry theKey = new DatabaseEntry(aKey.getBytes("UTF-8"));
    DatabaseEntry theData = new DatabaseEntry(aData.getBytes("UTF-8"));

    //byte[] myKey = theKey.getData();
    //byte[] myData = theData.getData();
    // 从byte数组转换为string的方法
    //String key = new String(myKey, "UTF-8");
    //String data = new String(myData, "UTF-8");

    // get和put用在非重复的数据存储，读写库时，注意一个小区别，就是数据库，是否允许重复的记录存在，两个记录公用一个key，
    // 这就是重复的记录，我们把重复的记录成为重复集合。或者叫多重。
    // 游标用于重复数据存储put和get。
    // 数据记录在内部是用Btree按照特定排序来存储的。一般是用key来排序的，key相同的多重数据是按照data来排序。
    // 记录Using Database Records
    // 记录是由key和data组成，即所熟悉的key->value，二者都被是有DatabaseEntry封装的。
    // 这个之前也提过很多次了，DatabaseEntry可以封装原始类型和复杂的对象类型，二者都要被转换为byte
    // array存储，转换可以使用Bind API来完成
    // 写数据
    myDB.put(null, theKey, theData);
    // 如果不是可重复数据库，put将会覆盖原有的记录。
    // myDatabase.putNoOverwrite(null, theKey, theData);//不允许覆盖，不管是否允许数据重复。
    // 读数据
    // --myDatabase.getSearchBoth(null, theKey, theData, LockMode.DEFAULT);//查找key和data都匹配的记录
    // --查询出来的key和data都是byte数组形式。
    if (myDB.get(null, theKey, theData, LockMode.DEFAULT) == OperationStatus.SUCCESS) {
     byte[] retData = theData.getData();
     String foundData = new String(retData, "UTF-8");
     System.out.println("For key: '" + aKey + "' found data: '"
       + foundData + "'.");
    }
    // 删除数据
    myDB.delete(null, theKey); // 删除数据