Java嵌入式数据库berkeleyDB(三)

Java嵌入式数据库berkeleyDB(三)

修改了每次存放一个对象，
同时增加了对key的范围搜索和范围删除
参考了同事的部分代码，优化了配置，同时修复了以下问题：
1、取数据没有数据时报nullpoint的错误
2、搜索数据没有关闭transaction的错误

package com.sillycat.plugin.berkeley.impl;

import java.io.File;
import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.List;

import com.sillycat.core.model.User;
import com.sillycat.plugin.commons.utils.StringUtil;
import com.sleepycat.bind.EntryBinding;
import com.sleepycat.bind.serial.SerialBinding;
import com.sleepycat.bind.serial.StoredClassCatalog;
import com.sleepycat.je.Cursor;
import com.sleepycat.je.CursorConfig;
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;
import com.sleepycat.je.Transaction;

public class BerkeleyDBServiceImpl {

// 数据库的默认路径
private static final String DB_ENVIRONMENT_ROOT = "D:/dbRoot";

// 数据库环境
private Environment databaseEnv;

// 数据
private static Database cacheDatabase;

// 类
private static Database classBindingDatabase;

// 数据绑定的环境
private EntryBinding dataBinding;

// 数据库路径
private String databasePath;

/**
* 初始化数据参数
*/
public void init() {
try {
EnvironmentConfig config = new EnvironmentConfig();
config.setAllowCreate(true);// 如果不存在则创建一个
config.setReadOnly(false); // 以只读方式打开，默认为false
config.setTransactional(true); // 事务支持,如果为true，则表示当前环境支持事务处理，默认为false，不支持事务处理
databaseEnv = new Environment(new File(this.getDatabasePath()),
config);
DatabaseConfig dbConfig = new DatabaseConfig();
dbConfig.setAllowCreate(true);
dbConfig.setTransactional(true);
// 初始化缓存数据库
cacheDatabase = databaseEnv.openDatabase(null, "cacheDatabase",
dbConfig);

classBindingDatabase = databaseEnv.openDatabase(null,
"classDatabase", dbConfig);
StoredClassCatalog classCatalog = new StoredClassCatalog(
classBindingDatabase);
dataBinding = new SerialBinding(classCatalog, Object.class);
} catch (DatabaseException e) {
e.printStackTrace();
}
}

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

/**
* 放入对象
*
* @param key
* @param obj
*/
public void putObject(String key, Object obj) {
DatabaseEntry theKey;
try {
DatabaseEntry theData = new DatabaseEntry();
theKey = new DatabaseEntry(key.getBytes("UTF-8"));
dataBinding.objectToEntry(obj, theData);
cacheDatabase.put(null, theKey, theData);
} catch (UnsupportedEncodingException e1) {
e1.printStackTrace();
} catch (DatabaseException e) {
e.printStackTrace();
}
}

/**
* 取出对象
*
* @param key
* @return
* @throws DatabaseException
* @throws UnsupportedEncodingException
*/
public Object getObject(String key) {
DatabaseEntry theKey;
Object retData = null;
try {
theKey = new DatabaseEntry(key.getBytes("UTF-8"));
DatabaseEntry theData = new DatabaseEntry();
cacheDatabase.get(null, theKey, theData, LockMode.DEFAULT);
if (theData.getSize() > 0) {
retData = (Object) dataBinding.entryToObject(theData);
}
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
} catch (DatabaseException e) {
e.printStackTrace();
}
return retData;
}

/**
* 删除数据
*
* @param key
*/
public void delete(String key) {
DatabaseEntry theKey;
try {
theKey = new DatabaseEntry(key.getBytes("UTF-8"));
cacheDatabase.delete(null, theKey);
// 删除数据
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
} catch (DatabaseException e) {
e.printStackTrace();
}
}

/**
*
* 搜索范围内的数据
*
* @param begin
* @param end
* @return
* @throws DatabaseException
* @throws UnsupportedEncodingException
*/
public List searchRange(long begin, long end) {
List list = null;
Cursor cursor = null;
Transaction txn = null;
try {
txn = databaseEnv.beginTransaction(null, null);
CursorConfig config = new CursorConfig();
config.setReadCommitted(true);
cursor = cacheDatabase.openCursor(txn, config);

DatabaseEntry theKey = new DatabaseEntry((begin + "")
.getBytes("UTF-8"));
DatabaseEntry theData = new DatabaseEntry();
OperationStatus retVal = cursor.getSearchKeyRange(theKey, theData,
LockMode.DEFAULT);

// 如果count超过一个，则遍历
if (cursor.count() >= 1) {
list = new ArrayList();
while (retVal == OperationStatus.SUCCESS) {
String keyString = new String(theKey.getData(), "UTF-8");
String dataString = new String(theData.getData(), "UTF-8");
// retVal = cursor.getNextDup(theKey, theData,
// LockMode.DEFAULT);

long timeStamp = Long.parseLong(keyString);
if (timeStamp >= begin && timeStamp < end) {
list.add(dataString);
retVal = cursor.getNext(theKey, theData,
LockMode.DEFAULT);
} else {
break;
}
}
}
} catch (Exception ex) {
ex.printStackTrace();
} finally {
if (cursor != null) {
try {
cursor.close();
} catch (DatabaseException e) {
e.printStackTrace();
}
}
if (txn != null) {
try {
txn.commitNoSync();
} catch (DatabaseException e) {
e.printStackTrace();
}
}
}
return list;
}

/**
* 删除范围的值
*
* @param start
* @param end
*/
public void deleteRange(long start, long end) {
Cursor cursor = null;
Transaction txn = null;
try {
txn = databaseEnv.beginTransaction(null, null);
CursorConfig config = new CursorConfig();
config.setReadCommitted(true);
cursor = cacheDatabase.openCursor(txn, config);

DatabaseEntry theKey = new DatabaseEntry(("" + start)
.getBytes("UTF-8"));
DatabaseEntry theData = new DatabaseEntry();
OperationStatus retVal = cursor.getSearchKeyRange(theKey, theData,
LockMode.DEFAULT);

// 有记录，删除之
if (cursor.count() >= 1) {
while (retVal == OperationStatus.SUCCESS) {
String keyString = new String(theKey.getData(), "UTF-8");
long timeStamp = Long.parseLong(keyString);

if (timeStamp >= start && timeStamp < end) {
cursor.delete();
retVal = cursor.getNext(theKey, theData,
LockMode.DEFAULT);
} else {
break;
}
}
}

} catch (Exception ex) {
ex.printStackTrace();
} finally {
if (cursor != null) {
try {
cursor.close();
} catch (DatabaseException e) {
e.printStackTrace();
}
}
if (txn != null) {
try {
txn.commitNoSync();
} catch (DatabaseException e) {
e.printStackTrace();
}
}
}
}

public String getDatabasePath() {
if (StringUtil.isBlank(this.databasePath)) {
databasePath = DB_ENVIRONMENT_ROOT;
}
return databasePath;
}

public void setDatabasePath(String databasePath) {
this.databasePath = databasePath;
}

public static void main(String[] args) {
BerkeleyDBServiceImpl bService = new BerkeleyDBServiceImpl();
bService.init();

User u1 = new User(Integer.valueOf(1), "luohua");
User u2 = new User(Integer.valueOf(2), "kiko");
User u3 = new User(Integer.valueOf(3), "baby");
bService.putObject(u1.getId().toString(), u1);
bService.putObject(u2.getId().toString(), u2);
bService.putObject(u3.getId().toString(), u3);
User temp1 = (User) bService.getObject(u1.getId().toString());
System.out.println(temp1);

bService.deleteRange(1, 3);

List list = bService.searchRange(1, 5);
System.out.println(list.size());

bService.delete("3");
bService.destroy();
}
}