BerkeleyDB数据库，增删改，封装类（带字段压缩功能）

自己写的两个工具类，分享一下，供大家参考。主要是将BerkeleyDB数据库的常用操作封装起来，使用的时候就不用再写重复的代码。

提供两个类，一个是BerkeleyDB的封装类，一个是字节压缩类，两个类放一个工具包即可。

package com.laotoumo.util;

import java.awt.print.Paper;
import java.io.File;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;

import org.apache.log4j.Logger;

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;

/**
* BerkeleyDB 增删改封装类
*
* @author Mo
*
*/
public class BerkeleyDB {

private static final Logger log = Logger.getLogger(BerkeleyDB.class);

private Environment dbEnvironment = null;
private Database database = null;

public Database getDatabase() {
return database;
}

/**
*
* @param dbPath 数据库路径
* @param dbName 数据库名称
* @param readOnly 只读状态
* @throws DatabaseException
*/
public BerkeleyDB(String dbPath, String dbName, boolean readOnly)
throws DatabaseException {

log.debug(dbPath + "\t" + dbName + "\tReadOnly:" + readOnly);

/*数据库文件*/
File envHome = new File(dbPath,dbName);

if (!envHome.exists()) {
envHome.mkdirs();
}

/*打开一个环境，如果不存在则创建一个*/
/*创建一个EnvironmentConfig配置对象*/
EnvironmentConfig envConfig = new EnvironmentConfig();
/*允许创建一个数据库环境*/
envConfig.setAllowCreate(true);
/*设置数据库缓存大小*/
// envConfig.setCacheSize(64 *1024 *1024);
/*使用一个指定路径和一个EnvironmentConfig配置对象创建Environment环境*/
dbEnvironment = new Environment(envHome, envConfig);

/*打开一个数据库，如果数据库不存在则创建一个*/
DatabaseConfig dbConfig = new DatabaseConfig();
if (!readOnly) {
dbConfig.setAllowCreate(true);
dbConfig.setDeferredWrite(true);
}
dbConfig.setReadOnly(readOnly);

/*打开一个数据库，数据库名为dbName,数据库的配置为dbConfig*/
database = dbEnvironment.openDatabase(null, dbName, dbConfig);
//envConfig.setConfigParam("je.env.sharedLatches", "false");
}

/**
*
* @param dbPath 数据库路径
* @param dbName 数据库名称
* @throws DatabaseException
*/
public BerkeleyDB(String dbPath, String dbName) throws DatabaseException {
this(dbPath, dbName, false);
}

/**
* 关闭数据库
*/
public void close(){
try {
if (database != null) {
database.close();
}
if (dbEnvironment != null) {
/*在关闭环境之前清理日志*/
dbEnvironment.cleanLog();
dbEnvironment.close();
}
} catch (DatabaseException e) {
e.printStackTrace();
} finally {
database = null;
dbEnvironment = null;
}
}

/**
* 增删 合并 操作
*
* @param key
* @param value
* @return
*/
public boolean put(DatabaseEntry key, DatabaseEntry value) {
try {
database.put(null, key, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}

public boolean put(Object key, Object value) {
try {
byte[] keys = BytesZip.toBytes((Serializable) key);// 本来就不长不用加密了
byte[] values = BytesZip.gZip(BytesZip
.toBytes((Serializable) value));// Map加密
return put(keys, values);
} catch (Exception e) {
e.printStackTrace();
return false;
}

}

public Object get(Object key) {
try {
return BytesZip.toObject(get(BytesZip.toBytes((Serializable) key)));
} catch (Exception e) {
e.printStackTrace();
return null;
}
}

private boolean put(byte[] key, byte[] value) {
return put(new DatabaseEntry(key), new DatabaseEntry(value));
}

public boolean contains(Object key) {
try {
return contains(BytesZip.toBytes((Serializable) key));
} catch (Exception e) {
e.printStackTrace();
return false;
}
}

private boolean contains(byte[] key) {
try {
DatabaseEntry theKey = new DatabaseEntry(key);
DatabaseEntry theData = new DatabaseEntry();
return (database.get(null, theKey, theData, LockMode.DEFAULT) == OperationStatus.SUCCESS);
} catch (Exception e) {
return false;
}
}

private byte[] get(byte[] key) {
DatabaseEntry theKey = null;
DatabaseEntry theData = null;
try {
theKey = new DatabaseEntry(key);
theData = new DatabaseEntry();
if (database.get(null, theKey, theData, LockMode.DEFAULT) == OperationStatus.SUCCESS) {
byte[] retData = BytesZip.unGZip(theData.getData());// 在此解压缩
theData.setData(null);
return retData;
} else {
return null;
}
} catch (Exception e) {
e.printStackTrace();
return null;
} finally {
theKey = null;
theData = null;
}
}

public boolean remove(Object key) {
try {
DatabaseEntry theKey = obj2Ent(key);
database.delete(null, theKey);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}

public long getCount() {
try {
return database.count();
} catch (DatabaseException e) {
e.printStackTrace();
return 0;
}
}

public void sync() {
database.sync();
}

/**
* 数据库合并
*
* @param fromDb
* @return
* @throws Exception
*/
public boolean merge(BerkeleyDB fromDb) {
Cursor cursor = null;
CursorConfig config = new CursorConfig();
//config.setDirtyRead(true);

/*open cursor*/
cursor = fromDb.getDatabase().openCursor(null, config);
try {
DatabaseEntry foundKey = new DatabaseEntry();
DatabaseEntry foundData = new DatabaseEntry();
while (cursor.getNext(foundKey, foundData, LockMode.DEFAULT) == OperationStatus.SUCCESS) {
this.put(foundKey, foundData);
}
foundKey = null;
foundData = null;
return true;
} catch (DatabaseException de) {
de.printStackTrace();
return true;
} finally {
// Cursors must be closed.
cursor.close();
}
}

private DatabaseEntry obj2Ent(byte[] obj) throws Exception {
if (obj == null) {
return new DatabaseEntry();
} else {
return new DatabaseEntry(obj);
}
}

private DatabaseEntry obj2Ent(Object obj) throws Exception {
if (obj == null) {
return new DatabaseEntry();
} else {
return new DatabaseEntry(BytesZip.toBytes((Serializable) obj));
}
}

public List<Paper> list(int max) throws Exception {
List<Paper> paperList = new ArrayList<Paper>();
int len = 0;
Cursor cursor = null;
CursorConfig config = new CursorConfig();
// config.setDirtyRead(true);
cursor = database.openCursor(null, config); // open cursor
try {
DatabaseEntry foundKey = new DatabaseEntry();
DatabaseEntry foundData = new DatabaseEntry();
while (cursor.getNext(foundKey, foundData, LockMode.DEFAULT) == OperationStatus.SUCCESS) {
Object key = BytesZip.toObject(foundKey.getData());
Object value = BytesZip.toObject(BytesZip.unGZip(foundData
.getData()));
paperList.add((Paper) value);
System.out.println("Key - Data : " + key);// + " - " + value +
// ""
len++;
if (len > max)
break;
}
} catch (DatabaseException de) {
System.err.println("Error accessing database." + de);
} finally {
// Cursors must be closed.
cursor.close();
}
System.out.println(len);
return paperList;
}

}

package com.laotoumo.util;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.Date;
import java.util.zip.GZIPInputStream;
import java.util.zip.GZIPOutputStream;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;
import java.util.zip.ZipOutputStre
4000
am;
import org.apache.tools.bzip2.CBZip2InputStream;
import org.apache.tools.bzip2.CBZip2OutputStream;

import com.jcraft.jzlib.JZlib;
import com.jcraft.jzlib.ZInputStream;
import com.jcraft.jzlib.ZOutputStream;

public class BytesZip {

/**
* 将对象转换成字节数组
*
* @param object
* @return
* @throws IOException
*/
public static byte[] toBytes(Serializable object) throws Exception {
ByteArrayOutputStream byteStream = new ByteArrayOutputStream();
ObjectOutputStream objectStream = new ObjectOutputStream(byteStream);
objectStream.writeObject(object);
objectStream.flush();
objectStream.close();
return byteStream.toByteArray();
}

/**
* 将字节数组转换成对象
*
* @param bytes
* @return
*/
public static Object toObject(byte[] bytes) throws Exception {
if (bytes == null) {
return null;
} else {
ByteArrayInputStream byteStream = new ByteArrayInputStream(bytes);
ObjectInputStream objectStream = new ObjectInputStream(byteStream);
return objectStream.readObject();
}

}

/***
* 压缩GZip
*
* @param data
* @return
*/
public static byte[] gZip(byte[] data) {
byte[] b = null;
try {
ByteArrayOutputStream bos = new ByteArrayOutputStream();
GZIPOutputStream gzip = new GZIPOutputStream(bos);
gzip.write(data);
gzip.finish();
gzip.close();
b = bos.toByteArray();
bos.close();
} catch (Exception ex) {
ex.printStackTrace();
}
return b;
}

/***
* 解压GZip
*
* @param data
* @return
*/
public static byte[] unGZip(byte[] data) {
byte[] b = null;
try {
ByteArrayInputStream bis = new ByteArrayInputStream(data);
GZIPInputStream gzip = new GZIPInputStream(bis);
byte[] buf = new byte[1024];
int num = -1;
ByteArrayOutputStream baos = new ByteArrayOutputStream();
while ((num = gzip.read(buf, 0, buf.length)) != -1) {
baos.write(buf, 0, num);
}
b = baos.toByteArray();
baos.flush();
baos.close();
gzip.close();
bis.close();
} catch (Exception ex) {
ex.printStackTrace();
}
return b;
}

/***
* 压缩Zip
*
* @param data
* @return
*/
public static byte[] zip(byte[] data) {
byte[] b = null;
try {
ByteArrayOutputStream bos = new ByteArrayOutputStream();
ZipOutputStream zip = new ZipOutputStream(bos);
ZipEntry entry = new ZipEntry("zip");
entry.setSize(data.length);
zip.putNextEntry(entry);
zip.write(data);
zip.closeEntry();
zip.close();
b = bos.toByteArray();
bos.close();
} catch (Exception ex) {
ex.printStackTrace();
}
return b;
}

/***
* 解压Zip
*
* @param data
* @return
*/
public static byte[] unZip(byte[] data) {
byte[] b = null;
try {
ByteArrayInputStream bis = new ByteArrayInputStream(data);
ZipInputStream zip = new ZipInputStream(bis);
while (zip.getNextEntry() != null) {
byte[] buf = new byte[1024];
int num = -1;
ByteArrayOutputStream baos = new ByteArrayOutputStream();
while ((num = zip.read(buf, 0, buf.length)) != -1) {
baos.write(buf, 0, num);
}
b = baos.toByteArray();
baos.flush();
baos.close();
}
zip.close();
bis.close();
} catch (Exception ex) {
ex.printStackTrace();
}
return b;
}

/***
* 压缩BZip2
*
* @param data
* @return
*/
public static byte[] bZip2(byte[] data) {
byte[] b = null;
try {
ByteArrayOutputStream bos = new ByteArrayOutputStream();
CBZip2OutputStream bzip2 = new CBZip2OutputStream(bos);
bzip2.write(data);
bzip2.flush();
bzip2.close();
b = bos.toByteArray();
bos.close();
} catch (Exception ex) {
ex.printStackTrace();
}
return b;
}

/***
* 解压BZip2
*
* @param data
* @return
*/
public static byte[] unBZip2(byte[] data) {
byte[] b = null;
try {
ByteArrayInputStream bis = new ByteArrayInputStream(data);
CBZip2InputStream bzip2 = new CBZip2InputStream(bis);
byte[] buf = new byte[1024];
int num = -1;
ByteArrayOutputStream baos = new ByteArrayOutputStream();
while ((num = bzip2.read(buf, 0, buf.length)) != -1) {
baos.write(buf, 0, num);
}
b = baos.toByteArray();
baos.flush();
baos.close();
bzip2.close();
bis.close();
} catch (Exception ex) {
ex.printStackTrace();
}
return b;
}

/**
* 把字节数组转换成16进制字符串
*
* @param bArray
* @return
*/
public static String bytesToHexString(byte[] bArray) {
StringBuffer sb = new StringBuffer(bArray.length);
String sTemp;
for (int i = 0; i < bArray.length; i++) {
sTemp = Integer.toHexString(0xFF & bArray[i]);
if (sTemp.length() < 2)
sb.append(0);
sb.append(sTemp.toUpperCase());
}
return sb.toString();
}

/**
* 压缩数据
*
* @param object
* @return
* @throws IOException
*/
public static byte[] jzlib(byte[] object) {

byte[] data = null;
try {
ByteArrayOutputStream out = new ByteArrayOutputStream();
ZOutputStream zOut = new ZOutputStream(out,
JZlib.Z_DEFAULT_COMPRESSION);
DataOutputStream objOut = new DataOutputStream(zOut);
objOut.write(object);
objOut.flush();
zOut.close();
data = out.toByteArray();
out.close();

} catch (IOException e) {
e.printStackTrace();
}
return data;
}

/**
* 解压被压缩的数据
*
* @param object
* @return
* @throws IOException
*/
public static byte[] unjzlib(byte[] object) {

byte[] data = null;
try {
ByteArrayInputStream in = new ByteArrayInputStream(object);
ZInputStream zIn = new ZInputStream(in);
byte[] buf = new byte[1024];
int num = -1;
ByteArrayOutputStream baos = new ByteArrayOutputStream();
while ((num = zIn.read(buf, 0, buf.length)) != -1) {
baos.write(buf, 0, num);
}
data = baos.toByteArray();
baos.flush();
baos.close();
zIn.close();
in.close();

} catch (IOException e) {
e.printStackTrace();
}
return data;
}

public static void main(String[] args) {

Date a = new Date();
Date b = new Date();
long diff = 0;

String s = "this is a test";

System.out.println("Str:" + bytesToHexString(s.getBytes()));

a = new Date();
byte[] b1 = zip(s.getBytes());
System.out.println("zip:" + bytesToHexString(b1));
byte[] b2 = unZip(b1);
System.out.println("unZip:" + new String(b2));
b = new Date();
diff = (b.getTime() - a.getTime());
System.out.println("时间：\t" + (diff));

a = new Date();
byte[] b3 = bZip2(s.getBytes());
System.out.println("bZip2:" + bytesToHexString(b3));
byte[] b4 = unBZip2(b3);
System.out.println("unBZip2:" + new String(b4));
b = new Date();
diff = (b.getTime() - a.getTime());
System.out.println("时间：\t" + (diff));

a = new Date();

byte[] b5 = gZip(s.getBytes());
System.out.println("bZip2:" + bytesToHexString(b5));
byte[] b6 = unGZip(b5);
System.out.println("unBZip2:" + new String(b6));
b = new Date();
diff = (b.getTime() - a.getTime());
System.out.println("时间：\t" + (diff));

a = new Date();

byte[] b7 = jzlib(s.getBytes());
System.out.println("jzlib:" + bytesToHexString(b7));
byte[] b8 = unjzlib(b7);
System.out.println("unjzlib:" + new String(b8));
b = new Date();
diff = (b.getTime() - a.getTime());
System.out.println("时间：\t" + (diff));

}
}