嵌入式数据库Berkeley DB Java Edition
Berkeley DB的使用
使用Berkeley DB的一般步骤如下：
第一，创建数据库环境Environment
创建一个Environment环境，首先需要设置一个配置对象DatabaseConfig，用来配置一个数据库的环境，然后就可以创建Environment环境：
EnvironmentConfig envConfig = newEnvironmentConfig(); // 创建一个EnvironmentConfig配置对象
envConfig.setAllowCreate(true); // 允许创建一个数据库环境
envConfig.setCacheSize(1000000); // 设置数据库缓存大小
try {
Environment env = new Environment(newFile("D:\\"),envConfig); // 使用一个指定路径和一个EnvironmentConfig配置对象创建Environment环境
} catch (DatabaseException e){
e.printStackTrace();
}
第二，打开数据库Database
首先需要在一个已经存在的Environment环境下考虑打开一个数据库；
打开数据库之前，也要创建一个DatabaseConfig配置对象，用来配置一个Database；
使用Environment环境来打开数据库Database。
在上面步骤中创建了env的基础上，打开数据库具体实现如下：
DatabaseConfig dbConfig = newDatabaseConfig(); // 创建一个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：
写入数据
package org.shirdrn.berkeleydb;
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]
从BerkeleyDB中取出数据...
[myKey2:myValue2]
从BerkeleyDB中取出数据...
[myKey4:myValue4]
从BerkeleyDB中取出数据...
[myKey6:myValue6]
从BerkeleyDB中取出数据...
[myKey8:myValue8]
从BerkeleyDB中取出数据...
[myKey10:myValue10]
从BerkeleyDB中取出数据...
[myKey12:myValue12]
从BerkeleyDB中取出数据...
[myKey14:myValue14]
从BerkeleyDB中取出数据...
[myKey16:myValue16]
从BerkeleyDB中取出数据...
[myKey18:myValue18]
从Berkeley DB中取出数据...
[myKey20:null]
从BerkeleyDB中取出数据...
[myKey22:null]
从BerkeleyDB中取出数据...
[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, newDatabaseEntry(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]
从BerkeleyDB中取出数据...
[myKey1:myValue1]
从BerkeleyDB中取出数据...
[myKey2:myValue2]
从BerkeleyDB中取出数据...
[myKey3:myValue3]
可以看到，myKey0对应的myValue0为null，已经从数据库中删除了，其实该键值对已经不存在于该数据库中了。
修改数据
其实，就是重新写入存在的一个key及其修改该key对应的value，如下所示：
public boolean update(String key, String value) throwsException {
byte[] updateKey = key.getBytes("UTF-8");
byte[] updateValue = value.getBytes("UTF-8");
OperationStatus status = db.put(null, newDatabaseEntry(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();
}
}
}
运行结果如下所示：
从Berkeley DB中取出数据...
[myKey0:yourValue]
在线Berkeley DB Java Edition API：
http://www.oracle.com/technology/documentation/berkeley-db/je/java/index.html