將Berkeley DB基本數據庫操作封裝成類

Berkeley DB是一個嵌入式數據庫，適合于管理海量的、簡單的數據。

鍵值對（key/value）數據存儲方式使Berkeley DB用來進行數據庫管理的基礎，每個key/value構成一條記錄。 Berkeley的數據庫主要就是put和get，前者存入鍵值對，后者根據鍵獲取值。

因為Berkeley DB的數據庫操作有些復雜，所以將其封裝成了一個簡單的類：

package ch01_3;

import java.io.File;  
import java.util.AbstractMap.SimpleEntry;  
import java.util.ArrayList;  
import java.util.Map.Entry;

import com.sleepycat.bind.EntryBinding;  
import com.sleepycat.bind.serial.SerialBinding;  
import com.sleepycat.bind.serial.StoredClassCatalog;  
import com.sleepycat.collections.StoredMap;  
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.Environment;  
import com.sleepycat.je.EnvironmentConfig;  
import com.sleepycat.je.LockMode;  
import com.sleepycat.je.OperationStatus;

/*********************************
 * 使用BerkeleyDB封裝了一些數據庫操作
 * 包括設置緩沖區，設置編碼，設置數據可庫
 * 路徑，存儲鍵值對，根據鍵查找值，關閉數
 * 據庫等操作。
 * @author Administrator
 *********************************/
public class MyBerkeley {

    private Environment environment;    //環境
    private Database    database;       //數據庫
    @SuppressWarnings("unused")
    private String      charset;        //編碼
    private String      path;           //路徑
    private long        chacheSize;     //緩沖區大小

    private StoredMap<Object, Object>   pendingDB = null;   
    private Object keyClass = String.class;         //設置默認的key值類型
    private Object valueClass = Integer.class;      //設置默認的value值類型

    public MyBerkeley(){
        charset = "UTF-8";      //編碼默認使用UTF-8
        chacheSize = 10000;     //緩沖區大小默認為10000
    }

    //設置編碼
    public void setCharset(String charset)
    {
        this.charset = charset;
    }

    //設置路徑
    public void setPath(String path){
        //判斷Path是否存在
        File file = new File(path);
        if(file.mkdir()){
            System.out.println(path+"已創建！"); //不存在則創建一個
        }
        else{
            System.out.println(path+"已存在！"); //存在則說明已存在
        }

        //確定存儲路徑
        this.path = path;
    }

    //設置緩沖區大小
    public boolean setChacheSize(long size){
        if(size<=0 || size >=1000000000)
        {
            return false; //使用默認的大小
        }
        this.chacheSize = size;
        return true;
    }

    //同時設置路徑和緩沖區
    public void setEnvironment(String path , long chacheSize){
        setPath(path);
        setChacheSize(chacheSize);
        //配置環境
        EnvironmentConfig envConfig = new EnvironmentConfig();
        envConfig.setAllowCreate(true);
        envConfig.setCacheSize(this.chacheSize);
        //創建環境
        environment = new Environment(new File(this.path),envConfig);
    }

    //設置存儲類型
    public void setClassType(Object keyClass,Object valueClass)
    {
        this.keyClass = keyClass;
        this.valueClass = valueClass;
    }

    //打開名字是dbName的數據庫
    @SuppressWarnings("unchecked")
    public void open(String dbName)
    {
        DatabaseConfig dbConfig = new DatabaseConfig();
        dbConfig.setAllowCreate(true);
        dbConfig.setSortedDuplicates(false); //不存儲重復關鍵字
        this.database = environment.openDatabase(null, dbName, dbConfig);
        //初始化存儲序列化對象的catalog類
        StoredClassCatalog catalog = new StoredClassCatalog(database);
        //鍵值都使用序列化的方式進行存儲
        EntryBinding<Object> keyBinding = new SerialBinding<Object>(catalog,(Class<Object>) keyClass);
        EntryBinding<Object> valueBinding = new SerialBinding<Object>(catalog,(Class<Object>) valueClass);
        //創建數據存儲的映射視圖
        pendingDB = new StoredMap<Object, Object>(database,keyBinding,valueBinding,true);
    }

    //關閉
    public void close()
    {
        database.close();
        environment.close();
    }

    //存儲
    public void put(Object key,Object value)
    {
        pendingDB.put(key, value);
    }

    //取值
    public Object get(Object key)
    {
        return pendingDB.get(key);
    }

    //按照鍵值刪除數據
    public Object del(Object key)
    {
        return pendingDB.remove(key);
    }

    //獲取數據庫存儲數據的大小
    public int size()
    {
        return pendingDB.size();
    }

    //遍歷數據庫
    public ArrayList<Entry<Object,Object>> getAllItems()
    {
        Cursor cursor = null;//游標
        ArrayList<Entry<Object,Object>> result = new ArrayList<Entry<Object,Object>>();
        CursorConfig cConfig = new CursorConfig();
        if(cursor == null)
            cursor = database.openCursor(null, cConfig);
        DatabaseEntry theKey = new DatabaseEntry();
        DatabaseEntry theValue = new DatabaseEntry();
        //使用Cursor.getPerv方法來遍歷游標獲取數據
        if(cursor.getFirst(theKey, theValue, LockMode.DEFAULT)
                == OperationStatus.SUCCESS)
        {
            Object key = theKey.getData();
            Object value = theValue.getData();
            Entry<Object,Object> entry = new SimpleEntry<Object,Object>(key,value);
            result.add(entry);
            while(cursor.getNext(theKey, theValue, LockMode.DEFAULT)
                    == OperationStatus.SUCCESS)
            {
                key = theKey.getData();
                value = theValue.getData();
                entry = new SimpleEntry<Object,Object>(key,value);
                result.add(entry);
            }
        }
        cursor.close();//關閉游標
        return result;
    }

    public static void main(String[] args) throws Exception {
           MyBerkeley db = new MyBerkeley();
           db.setEnvironment("C:\\BerkeleyDB\\MyDatabase2", 1000000);
           //設置存儲類型（包括鍵和值）
           db.setClassType(String.class, String.class);
           db.open("myDB");//打開數據庫

           //存儲值與取值測試
           /*
           for(int i=10; i>=0; i--) {
                 String key = "Key"+i;
                 String value = ""+i;
                 db.put(key , value);
                 System.out.println("[" + key + ":" + db.get(key) + "]");
           }//*/
           //獲取數據庫鍵值對數量
           System.out.println(db.size());
           //刪除數據測試
           db.del("Key3");
           //遍歷數據庫測試
           ArrayList<Entry<Object,Object>> r = db.getAllItems();
           for(int i=0;i<r.size();i++)
           {
               String key = new String((byte[]) r.get(i).getKey());
               String value = new String((byte[]) r.get(i).getValue(),"UTF-8");
               System.out.println(key+":"+value);
           }
           db.close();
        }
}

來自：http://www.zgljl2012.com/jiang-berkeley-dbji-ben-shu-ju-ku-cao-zuo-feng-zhuang-cheng-lei/