嵌入式数据库 java_嵌入式数据库bdb(Berkeley DB Java Edition)

关于Berkeley数据库的介绍，可以参考下面的文章：

使用Berkeley DB的一般步骤如下：

第一，创建数据库环境Environment

创建一个Environment环境，首先需要设置一个配置对象DatabaseConfig，用来配置一个数据库的环境，然后就可以创建Environment环境：

EnvironmentConfig envConfig = new EnvironmentConfig(); // 创建一个EnvironmentConfig配置对象

envConfig.setAllowCreate(true); // 允许创建一个数据库环境

envConfig.setCacheSize(1000000); // 设置数据库缓存大小

try {

Environment env = new Environment(new File("D://"),envConfig); // 使用一个指定路径和一个EnvironmentConfig配置对象创建Environment环境

} catch (DatabaseException e) {

e.printStackTrace();

}

第二，打开数据库Database

首先需要在一个已经存在的Environment环境下考虑打开一个数据库；

打开数据库之前，也要创建一个DatabaseConfig配置对象，用来配置一个Database；

使用Environment环境来打开数据库Database。

在上面步骤中创建了env的基础上，打开数据库具体实现如下：

DatabaseConfig dbConfig = new DatabaseConfig(); // 创建一个DatabaseConfig配置对象

dbConfig.setAllowCreate(true); // 允许创建数据库

try {

Database db = env.openDatabase(null, "MyBDB", dbConfig); // 打开数据库MyBDB

} catch (DatabaseException e) {

e.printStackTrace();

}

第三，操作数据库

Berkeley DB存储的是键值对形式的数据，其实类似于一个Map，无非是向数据库中添加key/value对，或者根据指定的key取出对应的value，这是最基础的。

还可以使用游标来遍历数据库中的记录。

第四，关闭数据库及其环境

关闭的顺序就是：先关闭数据库，然后关闭环境：

try {

if(db != null) {

db.close();

}

if(env != null) {

env.close();

}

} catch (DatabaseException e) {

e.printStackTrace();

}

Berkeley DB实例

下面做了一个例子，实现了MyBerkeleyDB类，用来演示如何使用一个Berkeley DB：

写入数据

import java.io.File;

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 MyBerkeleyDB {

private Environment env;

private Database db;

public MyBerkeleyDB() {

}

public void setUp(String path, long cacheSize) {

EnvironmentConfig envConfig = new EnvironmentConfig();

envConfig.setAllowCreate(true);

envConfig.setCacheSize(cacheSize);

try {

env = new Environment(new File(path),envConfig);

} catch (DatabaseException e) {

e.printStackTrace();

}

}

public void open(String dbName) {

DatabaseConfig dbConfig = new DatabaseConfig();

dbConfig.setAllowCreate(true);

try {

db = env.openDatabase(null, dbName, dbConfig);

} catch (DatabaseException e) {

e.printStackTrace();

}

}

public void close() {

try {

if(db != null) {

db.close();

}

if(env != null) {

env.close();

}

} catch (DatabaseException e) {

e.printStackTrace();

}

}

public String get(String key) throws Exception {

DatabaseEntry queryKey = new DatabaseEntry();

DatabaseEntry value = new DatabaseEntry();

queryKey.setData(key.getBytes("UTF-8"));

OperationStatus status = db.get(null, queryKey, value,

LockMode.DEFAULT);

if (status == OperationStatus.SUCCESS) {

return new String(value.getData());

}

return null;

}

public boolean put(String key, String value) throws Exception {

byte[] theKey = key.getBytes("UTF-8");

byte[] theValue = value.getBytes("UTF-8");

OperationStatus status = db.put(null, new DatabaseEntry(theKey),

new DatabaseEntry(theValue));

if(status == OperationStatus.SUCCESS) {

return true;

}

return false;

}

public static void main(String[] args) {

MyBerkeleyDB mbdb = new MyBerkeleyDB();

mbdb.setUp("C://bdb", 1000000);

mbdb.open("myDB");

System.out.println("开始向Berkeley DB中存入数据...");

for(int i=0; i<20; i++) {

try {

String key = "myKey"+i;

String value = "myValue"+i;

System.out.println("[" + key + ":" + value + "]");

mbdb.put(key , value);

} catch (Exception e) {

e.printStackTrace();

}

}

mbdb.close();

}

可以看到控制台上打印出：

开始向Berkeley DB中存入数据...

[myKey0:myValue0]

[myKey1:myValue1]

[myKey2:myValue2]

[myKey3:myValue3]

[myKey4:myValue4]

[myKey5:myValue5]

[myKey6:myValue6]

[myKey7:myValue7]

[myKey8:myValue8]

[myKey9:myValue9]

[myKey10:myValue10]

[myKey11:myValue11]

[myKey12:myValue12]

[myKey13:myValue13]

[myKey14:myValue14]

[myKey15:myValue15]

[myKey16:myValue16]

[myKey17:myValue17]

[myKey18:myValue18]

[myKey19:myValue19]

也就是，想数据库中插入了20个键值对。

读取数据

在此基础上，我们可以打开这个数据库，从其中取出想要的键值对，根据key来取出value，修改main方法：public static void main(String[] args) {

MyBerkeleyDB mbdb = new MyBerkeleyDB();

mbdb.setUp("C://bdb", 1000000);

mbdb.open("myDB");

while(true) {

try {

for(int i=0; i<1000; i++) {

System.out.println("从Berkeley DB中取出数据...");

String k = "myKey" + 2*i;

String v = mbdb.get(k);

System.out.println("[" + k + ":" + v +"]");

Thread.sleep(3000);

if(i == 20) {

mbdb.close();

System.exit(0);

}

}

Thread.sleep(300000);

} catch (Exception e) {

e.printStackTrace();

}

}

}

打印出结果如下所示：

从Berkeley DB中取出数据...

[myKey0:myValue0]

从Berkeley DB中取出数据...

[myKey2:myValue2]

从Berkeley DB中取出数据...

[myKey4:myValue4]

从Berkeley DB中取出数据...

[myKey6:myValue6]

从Berkeley DB中取出数据...

[myKey8:myValue8]

从Berkeley DB中取出数据...

[myKey10:myValue10]

从Berkeley DB中取出数据...

[myKey12:myValue12]

从Berkeley DB中取出数据...

[myKey14:myValue14]

从Berkeley DB中取出数据...

[myKey16:myValue16]

从Berkeley DB中取出数据...

[myKey18:myValue18]

从Berkeley DB中取出数据...

[myKey20:null]

从Berkeley DB中取出数据...

[myKey22:null]

从Berkeley DB中取出数据...

[myKey24:null]

可以看到，我们只存储了[myKey0:myValue0]到[myKey19:myValue19]，而打印出结果[myKey20:null]对应的value都为null，说明不存在指定的key。

删除数据

在上面的类中增加如下成员方法public boolean delete(String key) throws Exception {

byte[] theKey = key.getBytes("UTF-8");

OperationStatus status = db.delete(null, new DatabaseEntry(theKey));

if(status == OperationStatus.SUCCESS) {

return true;

}

return false;

}

用来删除指定的key及其对应的额value。

修改主函数，测试：

public static void main(String[] args) {

MyBerkeleyDB mbdb = new MyBerkeleyDB();

mbdb.setUp("C://bdb", 1000000);

mbdb.open("myDB");

try {

mbdb.delete("myKey0"); // 删除myKey0及其对应的myValue0

} catch (Exception e1) {

e1.printStackTrace();

}

while(true) {

try {

for(int i=0; i<20; i++) {

System.out.println("从Berkeley DB中取出数据...");

String k = "myKey" + i;

String v = mbdb.get(k);

System.out.println("[" + k + ":" + v +"]");

Thread.sleep(3000);

}

mbdb.close();

System.exit(0);

Thread.sleep(300000);

} catch (Exception e) {

e.printStackTrace();

}

}

}

运行结

从Berkeley DB中取出数据...

[myKey0:null]

从Berkeley DB中取出数据...

[myKey1:myValue1]

从Berkeley DB中取出数据...

[myKey2:myValue2]

从Berkeley DB中取出数据...

[myKey3:myValue3]

可以看到，myKey0对应的myValue0为null，已经从数据库中删除了，其实该键值对已经不存在于该数据库中了。

修改数据

其实，就是重新写入存在的一个key及其修改该key对应的value，如下所示：

public boolean update(String key, String value) throws Exception {

byte[] updateKey = key.getBytes("UTF-8");

byte[] updateValue = value.getBytes("UTF-8");

OperationStatus status = db.put(null, new DatabaseEntry(updateKey), new DatabaseEntry(updateValue));

if (status == OperationStatus.SUCCESS) {

return true;

}

return false;

}

测试主函数：

public static void main(String[] args) {

MyBerkeleyDB mbdb = new MyBerkeleyDB();

mbdb.setUp("C://bdb", 1000000);

mbdb.open("myDB");

try {

mbdb.update("myKey0", "yourValue"); // 修改数据

} catch (Exception e1) {

e1.printStackTrace();

}

while(true) {

try {

for(int i=0; i<20; i++) {

System.out.println("从Berkeley DB中取出数据...");

String k = "myKey" + i;

String v = mbdb.get(k);

System.out.println("[" + k + ":" + v +"]");

Thread.sleep(3000);

}

mbdb.close();

System.exit(0);

Thread.sleep(300000);

} catch (Exception e) {

e.printStackTrace();

}

}

}

运行