Berkeley DB Java Edition Research

一、Berkeley DB Java Edition简介

  1. Berkeley DB JE is a general-purpose, transactionally protected, embedded database written in 100% Java (JE makes no JNI calls). As such, it offers the Java developer safe and efficient in-process storage and management of arbitrary data.
  2. Berkeley DB的特点:
    • 数据存储能力很强(Large database support)
    • 支持多线程(Multiple thread and process support)
    • 数据库的记录很简单,只是简单的键值对(Database records)
    • 提供事务支持(Transactions)
    • 提供索引支持(Indexes)
    • 提供内存缓存的支持(In-memory cache)
    • 按照连续的记录文件存储数据(Log files)
    • 后台线程的支持(Background threads)
    • 数据库环境封装了一个或多个数据库(Database environments)
    • 支持数据库的备份和恢复(Backup and restore)
  3. 下载Berkeley DB Java Edition:可以从http://www.sleepycat.com/download/index.shtml 网址下载
  4. 安装Berkeley DB Java Edition:将下载的文件解压后放到JE_HOME下面。
  5. 使用Berkeley DB,应用程序使用时,需要配置je.jar包,要将JE_HOME/lib/je.jar 加到你的应用程序中
  6. Berkeley DB Exception主要有三个异常:DatabaseNotFoundException,DeadlockException,RunRecoveryException

二、Berkeley DB Java Edition的使用及举例说明

根据Berkeley DB的文档介绍,在这里简单的介绍一下用Berkeley DB开发的步骤:

  1. 构建数据库的开发环境
    用Berkeley DB Java Edition开发数据库时,需要构建数据库的开发环境。Berkeley DB主要是在这个环境下工作的,并且处理数据库也是在这个环境下工作的。
    import com.sleepycat.je.Environment;
    import com.sleepycat.je.DatabaseException;
    import com.sleepycat.je.EnvironmentConfig;
    import java.io.File;
    ......
    Environment myDbEnvironment = null;
    try {
    EnvironmentConfig envConfig = new EnvironmentConfig();
    envConfig.setAllowCreate(true);
    /**这里的"/export/dbEnv"就是指定的数据库开发环境的目录*/
    myDbEnvironment = new Environment(new File("/export/dbEnv"), envConfig);
    } catch (DatabaseException dbe) {
    // Exception handling goes here
    }

    在这里对环境的属性可以进行设置,当然也可以通过配置文件je.properties来得到。
    像上例中的"envConfig.setAllowCreate(true);"这个设置就是说,当设置为true时,说明若没有数据库的环境时,可以打开。否则就不能打开。其它的属性,可以查看有关Berkeley DB Java Edition文档。
    程序运行完了,一般要关闭数据库的环境的,这就需要调用myDbEnvironment.close()方法来执行,释放系统资源。
  2. 构建数据库
    数据库的构造是在数据库环境的基础上构建的,这里还需要数据库属性的配置,不同的数据库可以配置不同的属性设置。
    例:
    import com.sleepycat.je.DatabaseException;import com.sleepycat.je.Database;
    import com.sleepycat.je.DatabaseConfig;import com.sleepycat.je.Environment;
    import com.sleepycat.je.EnvironmentConfig;import java.io.File;
    Environment myDbEnvironment = null;
    Database myDatabase = null;
    try {    // Open the environment. Create it if it does not already exist.    
    EnvironmentConfig envConfig = new EnvironmentConfig();   
     envConfig.setAllowCreate(true);    
    myDbEnvironment = new Environment(new File("/export/dbEnv"), envConfig);   
     // Open the database. Create it if it does not already exist.    
    DatabaseConfig dbConfig = new DatabaseConfig();   
     dbConfig.setAllowCreate(true);    
    myDatabase = myDbEnvironment.openDatabase(null,    "sampleDatabase", 
    dbConfig); } catch (DatabaseException dbe) {    // Exception handling goes here}
    

    从 这里的例子可以看出数据库myDatabase需要DatabaseConfig的配置,一般数据库的属性的配置需要它在这里的配置,然后数据库 myDatabase才可以得到。如:myDatabase = myDbEnvironment.openDatabase(null,"sampleDatabase",dbConfig);
    这里的“dbConfig.setAllowCreate(true);”就是设置数据的是否可以创建的属性,这里是可以创建的。有关数据库配置的其它属性,可以查看有关的文档。
    释放数据库资源一般用Database.close()来操作。
  3. 使用数据库的字段
    Berkeley DB中的记录包括两个字段,就是键和值,并且这些键和值都必须是com.sleepycat.je.DatabaseEntry类的实例。
    import com.sleepycat.je.DatabaseEntry;......String aKey = "key";String aData = "data";try {    DatabaseEntry theKey = new DatabaseEntry(aKey.getBytes("UTF-8"));    DatabaseEntry theData = new DatabaseEntry(aData.getBytes("UTF-8"));} catch (Exception e) {    // Exception handling goes here}

    在这里可以看到,我们用的是UTF-8的编码,其实,也可以使用其它的编码。对于存储和得到数据都不会产生任何影响。
    当得到从数据库中得到数据时,因为它都是按照字节存储的,所以,我们取出数据时,需要转换一下。
    import com.sleepycat.je.DatabaseEntry;
    ......
    byte[] myKey = theKey.getData();
    byte[] myData = theData.getData();
    String key = new String(myKey);
    String data = new String(myData);
    ......
    这样就可以按照Java中的String类,来取出数据了。
  4. 对数据库的各种操作具有了数据库对象之后,就可以根据这个数据库对象来执行具体的数据库操作,包括插入,检索,删除的操作。
    在Berkeley DB中默认是不支持重复记录的,若有重复的记录集的话,也可以使用游标来完成操作。
    • 从数据库中插入数据:这里提供了三种方法,put(),putNoOverwrite(),putNoDupData(),它们的主要区别还是在于插入的记录是否有重复,根据重复记录来判断这些操作,多数情况下,使用put()方法来操作插入。
      import com.sleepycat.je.DatabaseEntry;
      import com.sleepycat.je.Database;
      .....
      String aKey = "myFirstKey";
      String aData = "myFirstData";
      try {
      DatabaseEntry theKey = new DatabaseEntry(aKey.getBytes("UTF-8"));
      DatabaseEntry theData = new DatabaseEntry(aData.getBytes("UTF-8"));
      myDatabase.put(null, theKey, theData);
      } catch (Exception e) {
      // Exception handling goes here
      }
    • 从数据库中取得数据,一般使用get()方法得到指定关键字的记录,getSearchBoth()这个方法是根据所匹配的关键字来得到所需要的记录。
      import com.sleepycat.je.DatabaseEntry;import com.sleepycat.je.Database;
      import com.sleepycat.je.LockMode;import com.sleepycat.je.OperationStatus;
      .....// Environment and database opens omitted for clarity.
      // Environment and database may be opened read-only.  
       String aKey = "myFirstKey";try {    // Create a pair of DatabaseEntry objects. theKey    
      // is used to perform the search. theData is used    // to store the data returned by the get() operation.  
        DatabaseEntry theKey = new DatabaseEntry(aKey.getBytes("UTF-8")); 
         DatabaseEntry theData = new DatabaseEntry();        // Perform the get.   
       if (myDatabase.get(null, theKey, theData, LockMode.DEFAULT) ==        OperationStatus.SUCCESS) {   
           // Recreate the data String.      
        byte[] retData = theData.getData();     
         String foundData = new String(retData);        
      System.out.println("For key: '" + aKey + "' found data: '" +                             foundData + "'.");    } else {
       System.out.println("No record found for key '" + aKey + "'.");    } } catch (Exception e) {  
        // Exception handling goes here}
    • 删除数据库中的记录,一般是用Database.delete()方法,若数据库中存在重复的记录,要删除掉具有重复的关键字的记录的话,就会将所有具有该关键字的记录都删除掉了。也就是删除掉了一个记录的集合。
      import com.sleepycat.je.DatabaseEntry;import com.sleepycat.je.Database;
      // Environment and database opens omitted for clarity.
      // Environment and database can NOT be opened read-only.  
      try {    
      String aKey = "myFirstKey";    
      DatabaseEntry theKey = new DatabaseEntry(aKey.getBytes("UTF-8"));        
      // Perform the deletion. All records that use this key are    // deleted.   
       myDatabase.delete(null, theKey); 
      } catch (Exception e) {    // Exception handling goes here}

      这里是根据指定的关键字"myFirstKey",来删除掉指定的记录,若该记录有重复的话,那么就会删掉该关键字的所有的记录集合。
  5. 游标的操作
    游标的各种操作和数据库的各种操作都差不多。方法大体上是一样的。
    • 游标的建立和关闭
      游标也是建立在数据库基础之上的,因此,游标需要得到数据库的对象。
      import com.sleepycat.je.Environment;import com.sleepycat.je.Database;import com.sleepycat.je.DatabaseException;import com.sleepycat.je.Environment;import com.sleepycat.je.CursorConfig;import com.sleepycat.je.Cursor;import java.io.File;......Environment myDbEnvironment = null;Database myDatabase = null;Cursor myCursor = null;try {    myDbEnvironment = new Environment(new File("/export/dbEnv"), null);    myDatabase = myDbEnvironment.openDatabase(null, "myDB", null);    myCursor = myDatabase.openCursor(null, null);} catch (DatabaseException dbe) {    // Exception handling goes here ...}
      从这里可以看到游标是建立在数据库基础之上的。
      游标的关闭直接调用cursor.close()方法就可以了。
    • 用游标插入数据到数据库
      这里也是采用的put(),putNoDupData(),putNoOverwrite()三个方法来实现的,它们的使用方法和数据库的插入方法一样,这几个方法的区别也是在于对重复记录的判断上,具体的区别请看有关的资料。
      import com.sleepycat.je.DatabaseEntry;import com.sleepycat.je.Database;
      import com.sleepycat.je.Cursor;import com.sleepycat.je.OperationStatus; 
      // Create the data to put into the database
      String key1str = "My first string";
      String data1str = "My first data";
      String key2str = "My second string";
      String data2str = "My second data";
      String data3str = "My third data";
      Cursor cursor = null;
      try {   
         // Database and environment open omitted for brevity   
       DatabaseEntry key1 = new DatabaseEntry(key1str.getBytes("UTF-8"));   
       DatabaseEntry data1 = new DatabaseEntry(data1str.getBytes("UTF-8"));   
       DatabaseEntry key2 = new DatabaseEntry(key2str.getBytes("UTF-8"));  
        DatabaseEntry data2 = new DatabaseEntry(data2str.getBytes("UTF-8"));   
       DatabaseEntry data3 = new DatabaseEntry(data3str.getBytes("UTF-8"));   
       // Open a cursor using a database handle    
      cursor = myDatabase.openCursor(null, null);    
      // Assuming an empty database.   
       OperationStatus retVal = cursor.put(key1, data1); // SUCCESS   
       retVal = cursor.put(key2, data2); // SUCCESS   
       retVal = cursor.put(key2, data3); // SUCCESS if dups allowed,                                     
        // KEYEXIST if not.                                                
        } catch (Exception e) {    // Exception handling goes here}
       finally {   // Make sure to close the cursor   cursor.close();}
      在 这个例子中,可以看到一开始的时候,cursor.put(key2, data2)执行后,在数据库中就已经有了key2的记录,后来,要调用了cursor.put(key2, data3)方法后,由于在数据库中已经存在了一个key2的记录,现在又在这个key2基础上添加一个,若允许数据库是重复的,因此这里就替代掉了原来 的data2的数据了,现在是data3了。
    • 用游标来得到数据和检索数据
      使用游标最大的优点还是在于能够很方便的检索记录。用游标得到记录可以用getNext(),getPrev()等方法。
      import com.sleepycat.je.DatabaseEntry;import com.sleepycat.je.Database;import com.sleepycat.je.DatabaseException;import com.sleepycat.je.Cursor;import com.sleepycat.je.OperationStatus; import com.sleepycat.je.LockMode;  .....Cursor cursor = null;try {    ...    // Database and environment open omitted for brevity    ...    // Open the cursor.     cursor = myDatabase.openCursor(null, null);    // Cursors need a pair of DatabaseEntry objects to operate. These hold    // the key and data found at any given position in the database.    DatabaseEntry foundKey = new DatabaseEntry();    DatabaseEntry foundData = new DatabaseEntry();    // To iterate, just call getNext() until the last database record has been     // read. All cursor operations return an OperationStatus, so just read     // until we no longer see OperationStatus.SUCCESS    while (cursor.getNext(foundKey, foundData, LockMode.DEFAULT) ==        OperationStatus.SUCCESS) {        // getData() on the DatabaseEntry objects returns the byte array        // held by that object. We use this to get a String value. If the        // DatabaseEntry held a byte array representation of some other data        // type (such as a complex object) then this operation would look         // considerably different.        String keyString = new String(foundKey.getData());        String dataString = new String(foundData.getData());        System.out.println("Key - Data : " + keyString + " - " + dataString + "");    }} catch (DatabaseException de) {    System.err.println("Error accessing database." + de);} finally {    // Cursors must be closed.    cursor.close();}
      在这里例子实际上就是遍历数据库所有的记录,将它打印出来,也可以使用getPrev()方法,也可以实现遍历数据库的操作。在重复的记录中,用数据库就无法操作,用游标就可以实现对重复记录的访问,也是使用这几个方法。
      检索关键字是使用游标的getSearchKey(),getSearchKeyRange(),getSearchBoth(),getSearchBothRange()方法,这些方法的区别在于匹配的操作,具体的区别请参考有关的资料。
      import com.sleepycat.je.DatabaseEntry;import com.sleepycat.je.Database;import com.sleepycat.je.DatabaseException;import com.sleepycat.je.Cursor;import com.sleepycat.je.OperationStatus; import com.sleepycat.je.LockMode;.....// For this example, hard code the search key and dataString searchKey = "Al";String searchData = "Fa";Cursor cursor = null;try {    ...    // Database and environment open omitted for brevity    ...    // Open the cursor.     cursor = myDatabase.openCursor(null, null);    DatabaseEntry theKey =          new DatabaseEntry(searchKey.getBytes("UTF-8"));    DatabaseEntry theData =          new DatabaseEntry(searchData.getBytes("UTF-8"));    // Open a cursor using a database handle    cursor = myDatabase.openCursor(null, null);    // Perform the search    OperationStatus retVal = cursor.getSearchBothRange(theKey, theData,                                                        LockMode.DEFAULT);    // NOTFOUND is returned if a record cannot be found whose key begins     // with the search key AND whose data begins with the search data.    if (retVal == OperationStatus.NOTFOUND) {        System.out.println(searchKey + "/" + searchData +                            " not matched in database " +                            myDatabase.getDatabaseName());    } else {        // Upon completing a search, the key and data DatabaseEntry         // parameters for getSearchBothRange() are populated with the         // key/data values of the found record.        String foundKey = new String(theKey.getData());        String foundData = new String(theData.getData());        System.out.println("Found record " + foundKey + "/" + foundData +                            "for search key/data: " + searchKey +                            "/" + searchData);    }} catch (Exception e) {    // Exception handling goes here} finally {   // Make sure to close the cursor   cursor.close();}
      这个例子,用的是getSearchBothRange()方法,它主要是用来查询匹配这个关键字和该关键字的数据的所有记录。 Cursor.count()这个方法,是用来统计当前键的出现的总的记录数。
    • 用游标删除数据库中的数据,用cursor.delete()方法,和数据库中的delete()方法用法一样。不在举例说明了。
    • 使用游标来代替当前键的值,用cursor.putCurrent()方法来实现,这在数据库中的操作方法中是很难实现的,用游标的这个方法,可以很方便的实现该操作。
      import com.sleepycat.je.DatabaseEntry;import com.sleepycat.je.Database;
      import com.sleepycat.je.DatabaseEntry;import com.sleepycat.je.Cursor;
      import com.sleepycat.je.OperationStatus;
       import com.sleepycat.je.LockMode;
      Cursor cursor = null;
      try {  
         // Database and environment open omitted for brevity      
        // Create DatabaseEntry objects    
      // searchKey is some String.    
      DatabaseEntry theKey = new DatabaseEntry(searchKey.getBytes("UTF-8"));   
       DatabaseEntry theData = new DatabaseEntry();   
       // Open a cursor using a database handle    
      cursor = myDatabase.openCursor(null, null);   
       // Position the cursor. Ignoring the return value for clarity   
       OperationStatus retVal = cursor.getSearchKey(theKey, theData,  LockMode.DEFAULT);       
       // Replacement data    
      String replaceStr = "My replacement string";   
       DatabaseEntry replacementData =   new DatabaseEntry(replaceStr.getBytes("UTF-8"));   
       cursor.putCurrent(replacementData);} catch (Exception e) {    
      // Exception handling goes here} finally {   // Make sure to close the cursor   cursor.close();}
      这里的操作是用来代替掉指定的关键字的值,但是若有重复记录的话,就无法实现了。
  6. 事务的处理
    Berkeley DB Java Edition提供了全部的事务的ACID的所有属性。(Atomicity,Consistency,Isolation,Durability)。
    在Berkeley DB中使用事务时,可以很方便的配置和使用:
    • 需要在数据库环境中配置事务的操作为可用的,EnvironmentConfig.setTransactional(true),这样就设置好了数据库环境下可以方便的使用事务。
    • 在数据库中也要设置事务为可用的,DatabaseConfig.setTransactional(true),这样数据库就设置好了事务的处理。
    • 接下来就可以在程序中使用事务了,在需要的地方插入transaction.commit(),提交事务。
  7. 数据备份和恢复
    • 数 据的备份分为两种:一种是部分备份,另一种是全部备份。它们的共同点就是拷贝所有的log files(.jdb)文件从数据库的环境目录到所要归档的目录或备份媒体。在这之前,必须要关闭事务,若存在事务,就无法它们的区别就是:部分备份是从 最后一次备份开始到凡是修改过的或新增加的记录都需要备份,而全部备份是将所有的数据库信息,包括内存缓存中的数据都要备份,不过这需要停止写操作。
    • 数据的恢复:简单的说就是将备份的log files文件拷贝到数据库的环境目录下,这里可以是增量备份,也可以是全部的备份,一般都是增量恢复,这些操作必须要关闭JE的应用程序。
  8. 其它
    在 这里只是说一下je.properties文件,这个文件是用来提供配置Berkeley DB的后台以及整体系统运行的参数,有的参数在je.properties文件中可以设置,在程序中也可以设置,但是在这个文件里的参数优先于程序中设置 的参数。这个文件必须放在数据库环境的根目录下,这样系统才能执行该文件中的参数。
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值