Java嵌入式数据库berkeleyDB(二)

整理之后得类。难道只能放String，那不是比较不爽。

有空再仔细研究研究，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();
   }
}

/**
* 放入数据
*
* @param key
* @param value
*/
public void put(String key, String value) {
   try {
    DatabaseEntry theKey = new DatabaseEntry(key.getBytes("UTF-8"));
    DatabaseEntry theData = new DatabaseEntry(value.getBytes("UTF-8"));
    myDB.put(null, theKey, theData);
   } catch (DatabaseException e) {
    e.printStackTrace();
   } catch (UnsupportedEncodingException e) {
    e.printStackTrace();
   }
}

/**
* 取得数据
*
* @param key
* @return
*/
public String get(String key) {
   String value = "";
   try {
    DatabaseEntry theKey = new DatabaseEntry(key.getBytes("UTF-8"));
    DatabaseEntry theData = new DatabaseEntry(value.getBytes("UTF-8"));
    if (myDB.get(null, theKey, theData, LockMode.DEFAULT) == OperationStatus.SUCCESS) {
     byte[] retData = theData.getData();
     value = new String(retData, "UTF-8");
    }
   } catch (DatabaseException e) {
    e.printStackTrace();
   } catch (UnsupportedEncodingException e) {
    e.printStackTrace();
   }
   return value;
}

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

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

   // 记录
   String aKey = "001";
   String aData = "我是正文内容!!!!!!!";
 
   bService.put(aKey,aData);
   String data = bService.get(aKey);
   System.out.println(data);
 
   bService.remote(aKey);
 
   bService.closeDB();
   bService.closeDBEnvironment();
}
}