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文件中可以设置，在程序中也可以设置，但是在这个文件里的参数优先于程序中设置 的参数。这个文件必须放在数据库环境的根目录下，这样系统才能执行该文件中的参数。