一个简单的NoSQL内存数据库—Berkeley DB基本操作的例子

   最近，由于云计算的发展，数据库技术也从结构式数据库发展到NoSQL数据库，存储模式从结构化的关系存储到现在如火如荼的key/value存储。其中Berkeley DB就是上述过程中的一个比较有代表性的内存数据库产品，数据库的操作是通过程序来实现的，而不是SQL语句。特别是当今数据不断动态增加的过程中，试图通过数据切割来达到扩充的思路已经行不通了，因为事先不知道客户数据格式，因此服务提供商不可能进行数据切割。而无模式的key/value存储就可以解决这种扩充带来的可扩展性问题，因为key/value的存储模式正好可以使得扩充能够自动完成，不需要事先知道任何的数据格式问题。因此，目前NoSQL数据库基本都基于key/value的存储模式，如amazon的simpleDB，google的BigTable等。本文就详细描述key/value模式的一个比较有代表性的内存数据库Berkeley DB，来介绍如何使用它来操作键值对数据。
       Berkeley DB是一个开源的内存数据库，它提供的是一系列直接访问数据库的函数，而不是像关系数据库那样需要网络通讯、SQL解析等步骤。Berkeley DB是一个高性能的，嵌入数据库编程库，“嵌入”是指它内嵌在程序中，而不是说他只应用在嵌入式系统上。它适合于管理海量的，简单的数据。例如，Google用Berkeley DB HA （High Availability） 来管理他们的帐户信息，Motorola在他的无线产品中用Berkeley DB跟踪移动单元。HP，Microsoft，Sun Microsystems等也都是它的大客户。它不能完全取代关系数据库，但在某些方面，它却有他们望尘莫及的高效性。
       关键字/数据(key/value)是Berkeley DB用来进行数据库管理的基础。前几年，key/value 这个词还是和 hash 表联系在一起的。而现在，程序员看见 key/value这个词时，马上联想到的就是 BigTable、SimpleDB 和云计算。当下，key/value 存储(或者叫 key/value Database、云存储等)是个非常时髦的词汇，越来越多的开发人员(特别是互联网企业)开始关注和尝试 key/value 的存储形式。
       每个 key/value对构成一条记录（数据表中的一行）。而整个数据库实际上就是由许多这样的结构单元所构成的。通过使用这种方式，开发人员在使用Berkeley DB提供的API来访问数据库时，只需提供关键字就能够访问到相应的数据。当然也可以也可以提供 key 和部分value来查询符合条件的相近数据。
       Berkeley DB底层实现机制采用B树，可以看成能够存储大量数据的HashMap。Berkeley DB通过环境对象EnvironmentConfig来对数据库进行管理的，每个EnvironmentConfig对象可以管理多个数据库 。
        下面来介绍Berkeley DB是如何存入key/value键值对数据的。
1、定义一个序列化的java类，后面将把String和该类的映射存放到Berkeley DB中
[java] view plaincopy
package webspider.berkeleydb;  
  
import java.io.Serializable;  
  
/** 
 * 定义一个序列化的java类，放到Berkeley DB中 
 *  
 * @author typ 
 *  
 */  
public class Bean implements Serializable {  
    private static final long serialVersionUID = -6865837107626208563L;  
  
    private Integer id;  
    private String name;  
  
    public Integer getId() {  
        return id;  
    }  
  
    public void setId(Integer id) {  
        this.id = id;  
    }  
  
    public String getName() {  
        return name;  
    }  
  
    public void setName(String name) {  
        this.name = name;  
    }  
  
}  
2、定义Frontier接口类，定义存储和获取键值对（key/value）时候需要实现的功能接口
[java] view plaincopy
package webspider.berkeleydb;  
  
/** 
 * 定义需要实现的功能接口 
 *  
 * @author typ 
 *  
 */  
public interface Frontier {  
    /** 
     * 获得下一条记录 
     *  
     * @return 
     * @throws Exception 
     */  
    public Bean getNext() throws Exception;  
  
    /** 
     * 添加一条记录 
     *  
     * @param bean 
     * @return 
     * @throws Exception 
     */  
    public boolean putNext(Bean bean) throws Exception;  
  
}  
3、定义AbstractFrontier类，来封装Berkeley DB中的操作
[java] view plaincopy
package webspider.berkeleydb;  
  
import java.io.File;  
import com.sleepycat.bind.serial.StoredClassCatalog;  
import com.sleepycat.je.Database;  
import com.sleepycat.je.DatabaseConfig;  
import com.sleepycat.je.Environment;  
import com.sleepycat.je.EnvironmentConfig;  
  
/** 
 * 封装Berkeley DB的操作 
 *  
 * @author typ 
 *  
 */  
public abstract class AbstractFrontier {  
  
    private Environment env;  
    private static final String CLASS_CATALOG = "java_class_catalog";  
    protected StoredClassCatalog javaCatalog;  
    protected Database catalogDatabase;  
    protected Database database;  
  
    /** 
     * 初始化数据库需要的各种变量 
     *  
     * @param homeDirectory 
     * @throws Exception 
     */  
    public AbstractFrontier(String homeDirectory) throws Exception {  
        EnvironmentConfig envConfig = new EnvironmentConfig();  
        // 设置事务处理开启，  
        envConfig.setTransactional(true);  
        // AllowCreate属性表示没有数据库的前提下，可以自动创建数据库  
        envConfig.setAllowCreate(true);  
        // 定义Environment变量，homeDirectory指的是数据库存放路径  
        env = new Environment(new File(homeDirectory), envConfig);  
        // 设置数据库的属性  
        DatabaseConfig dbConfig = new DatabaseConfig();  
        dbConfig.setTransactional(true);  
        dbConfig.setAllowCreate(true);  
        // 通常java对象和java对象之间的映射关系要分开存放，放置到不同的数据库中  
        // 存放java对象的数据库  
        catalogDatabase = env.openDatabase(null, CLASS_CATALOG, dbConfig);  
        javaCatalog = new StoredClassCatalog(catalogDatabase);  
        // 存放key/value映射的数据库  
        database = env.openDatabase(null, "String_JavaBean", dbConfig);  
    }  
  
    /** 
     * 关闭数据库时候，关闭各种链接 
     *  
     * @throws Exception 
     */  
    public void close() throws Exception {  
        database.close();  
        javaCatalog.close();  
        env.close();  
    }  
 
    /** 
     * Berkeley DB的存储键值对操作 
     *  
     * @param key 
     * @param value 
     */  
    protected abstract void put(Object key, Object value);  
  
    /** 
     * Berkeley DB的得到键值对操作 
     *  
     * @param key 
     * @return 
     */  
    protected abstract Object get(Object key);  
  
    /** 
     * Berkeley DB的删除键值对操作 
     *  
     * @param key 
     * @return 
     */  
    protected abstract Object delete(Object key);  
}  
4、设计实现类，实现数据库的插入，查找和删除功能（其实数据库的功能就是直接可以用java程序来实现的，这是Berkeley DB优点的地方，可以直接向操作普通java hash程序一样，操作数据库）
[java] view plaincopy
package webspider.berkeleydb;  
  
import java.util.Map.Entry;  
import java.util.Set;  
import com.sleepycat.bind.EntryBinding;  
import com.sleepycat.bind.serial.SerialBinding;  
import com.sleepycat.collections.StoredMap;  
  
/** 
 * 具体实现类 
 *  
 * @author typ 
 *  
 */  
public class BDBFrontier extends AbstractFrontier implements Frontier {  
    // 建立map，存储key/value键值对  
    private StoredMap pendingUrisDBMap;  
  
    /** 
     * 初始化java对象数据库和对象映射数据库 
     *  
     * @param homeDirectory 
     * @throws Exception 
     */  
    public BDBFrontier(String homeDirectory) throws Exception {  
        super(homeDirectory);  
        // 定义key和value的Entry  
        EntryBinding keyBinding = new SerialBinding(javaCatalog, String.class);  
        EntryBinding valueBinding = new SerialBinding(javaCatalog, Bean.class);  
        // map存放在database中，database存放key/value映射  
        pendingUrisDBMap = new StoredMap(database, keyBinding, valueBinding,  
                true);  
    }  
  
    /* 
     * (non-Javadoc) 
     *  
     * @see webspider.berkeleydb.Frontier#getNext() 
     */  
    public Bean getNext() throws Exception {  
        Bean bean = null;  
        if (!pendingUrisDBMap.isEmpty()) {  
            Set> entrys = pendingUrisDBMap.entrySet();  
            Entry entry = (Entry) pendingUrisDBMap  
                    .entrySet().iterator().next();  
            bean = entry.getValue();  
            delete(entry.getKey());  
        }  
        return bean;  
    }  
  
    /* (non-Javadoc) 
     * @see webspider.berkeleydb.Frontier#putNext(webspider.berkeleydb.Bean) 
     */  
    public boolean putNext(Bean bean) throws Exception {  
        put(bean.getName(), bean);  
        return true;  
    }  
  
    /* 
     * (non-Javadoc) 
     *  
     * @see webspider.berkeleydb.AbstractFrontier#put(java.lang.Object, 
     * java.lang.Object) 
     */  
    protected void put(Object key, Object value) {  
        pendingUrisDBMap.put(key, value);  
    }  
  
    /* 
     * (non-Javadoc) 
     *  
     * @see webspider.berkeleydb.AbstractFrontier#get(java.lang.Object) 
     */  
    protected Object get(Object key) {  
        return pendingUrisDBMap.get(key);  
    }  
  
    /* 
     * (non-Javadoc) 
     *  
     * @see webspider.berkeleydb.AbstractFrontier#delete(java.lang.Object) 
     */  
    protected Object delete(Object key) {  
        return pendingUrisDBMap.remove(key);  
    }  
  
    /** 
     * 测试效果，可以看到在f:\bdb文件夹下面生成了.jdb和.lck等Berkeley DB相关文件，数据存储在.jdb中 
     * 控制台输出刚刚插入的数据bean的Name值LiMing 
     */  
    public static void main(String[] args) {  
        try {  
            BDBFrontier frontier = new BDBFrontier("f:\\bdb");  
            Bean bean = new Bean();  
            bean.setName("LiMing");  
            frontier.putNext(bean);  
            System.out.println(frontier.getNext().getName());  
            frontier.close();  
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
    }  
  
}  
从上述过程看来，Berkeley DB可以很好的实现key/value这种存储方式，而且完全是通过一系列直接访问数据库的函数，而不是像关系数据库那样需要数据库连接、SQL解析等步骤。完全跟java程序中操作HashMap没有太大的区别，比较容易上手。