Berkely DB Java Edition学习笔记

2022-09-17 11:30:13

Berkely DB对于高并发、要求速度快的应用来说是个不错的选择，mysql就是用BDB实现的(mysql的后台) ，mysql快，BDB比mysql还要快N倍。BDB是一种嵌入式的、非关系数据库，它与其他的关系数据库RMDBS不同,它没有提供SQL,而是提供 了自己的访问接口。作为一种嵌入式的数据库，它是进程内模式的，也就是说它和应用程序在同一内存空间运行，所以速度要高很多，与嵌入式的数据库如 Derby、HSQLDB(都是RMDBS的)相比，它效率更高，使用方法也有很大的不同。现在BDB以被Oracle收购。Berkely DB提供的文档Getting Started with　Berkeley DB Java Edition可以说是短小精悍（１１３页），入门相当不错。下面Get Start吧：
Environment：
首先要接触的就是Environment了，使用它来open　database以及做一管理方面的事情.
创建Environment，还需要Environment的一些配置信息EnvironmentConfig。
下面是创建的过程：

Java代码  Berkely DB Java Edition学习笔记
  1. EnvironmentConfig envConfig = new EnvironmentConfig();  
  2. envConfig.setAllowCreate(true);  
  3. myDbEnvironment = new Environment(new File("/export/dbEnv"),  
  4. envConfig);  


其中EnvironmentConfig提供了许多配置参数，常用的有：
envConfig.setAllowCreate()//如果不存在的env的话，是否要创建一个新的
envConfig.setReadOnly()//是否为只读的
envConfig.setTransactional()//是否使用事务
参数都是boolean类型的
除了EnvironmentConfig外，还有EnvironmentMutableConfig，他实际是EnvironmentConfig的父类，使用他来配置在创建完Environment之后可以改变
的属性：
setCachePercent()//设置cache的大小占JVM　memory的百分比
setCacheSize()//设置cache的大小
setTxnNoSync()//事务提交是否将改变的记录写入磁盘
setTxnWriteNoSync()//事务提交是否将log写入磁盘
下面看一下使用EnvironmentMutableConfig的方法:

Java代码  Berkely DB Java Edition学习笔记
  1. Environment myEnv = new Environment(new File("/export/dbEnv"), null);  
  2. EnvironmentMutableConfig envMutableConfig =  
  3. new EnvironmentMutableConfig();  
  4. envMutableConfig.setTxnNoSync(true);  
  5. myEnv.setMutableConfig(envMutableConfig);  


Environment通过close来关闭，释放资源
下面看看Environment在管理方面的一些方法：
可以通过Environment获得EnvironmentStats，他提供了Environment一些状态信息，
例如使用

Java代码  Berkely DB Java Edition学习笔记
  1. long cacheMisses = myEnv.getStats(null).getNCacheMiss();  


我们可以获得cache未命中的次数，据此来调整cache的大小
可以同过Environment.getDatabaseNames()来获得Environment的数据库的名字：

Java代码  Berkely DB Java Edition学习笔记
  1. List myDbNames = myDbEnv.getDatabaseNames();  
  2. for(int i=0; i < myDbNames.size(); i++) {  
  3. System.out.println("Database Name: " + (String)myDbNames.get(i));  
  4. }  


可以通过Environment.removeDatabase()来删除一个数据库：

Java代码  Berkely DB Java Edition学习笔记
  1. String dbName = myDB.getDatabaseName();  
  2. myDB.close();  
  3. myDBEnv.removeDatabase(null,dbName);  


可以使用Environment.renameDatabase()来重新命名一个数据库：

Java代码  Berkely DB Java Edition学习笔记
  1. String dbName = myDB.getDatabaseName();  
  2. String dbNewName = new String(dbName + ".new", "UTF-8");  
  3. myDB.close();  
  4. myDBEnv.renameDatabase(null,dbName,dbNewName);  


可以使用Environment.truncateDatabase()来删除数据库中的所有记录：

Java代码  Berkely DB Java Edition学习笔记
  1. myEnv.truncate(null, // txn handle  
  2. myDatabase.getDatabaseName(), // database name  
  3. true//whether to return the count of deleted records  
  4. );  


第三个参数是否返回删除的记录数，性能有很大不同。false的话会很快
Database:
最重要的一些操作大多都在Database里了，和Environment一样，它也有许多
配置的选项DatabaseConfig,我们先看看选项：
DatabaseConfig.setAllowCreate()//不能存在的话是open操作否创建新的
DatabaseConfig.setBtreeComparator()//设置Btree的比较器
DatabaseConfig.setDuplicateComparator()//设置判断重复的比较器
DatabaseConfig.setSortedDuplicates()//是否允许重复的记录
DatabaseConfig.setExclusiveCreate()//设为true,如果当前数据库已存在，则open失败，也就是说open操作会导致一个新的数据库被创建，默认为false
DatabaseConfig.setReadOnly()//是否是只读的
DatabaseConfig.setTransactional()//是否使用事务
下面我们看看Database的使用流程：

Java代码  Berkely DB Java Edition学习笔记
  1. EnvironmentConfig envConfig = new EnvironmentConfig();  
  2. envConfig.setAllowCreate(true);  
  3. myDbEnvironment = new Environment(new File("/export/dbEnv"), envConfig);  
  4. DatabaseConfig dbConfig = new DatabaseConfig();  
  5. dbConfig.setAllowCreate(true);  
  6. myDatabase = myDbEnvironment.openDatabase(null,  
  7. "sampleDatabase",  
  8. dbConfig);  


我们通过Environment的openDatabase来创建Database对象。使用完了Database使用
close方法来关闭数据库释放资源。
Database Records
Database Record是保存在数据库的内容，包含Key和value两部分，他们都被封装成
DatabaseEntry，DatabaseEntry只能存放字节数组，所以只要能把Key和Value是什么
类型的，只要能转化成字节数组就可以被DatabaseEntry封装。基本类型JE都有对应的Binding,复杂的类型可以使用序列化和自定义binding来实现。
下那面我们看看一个使用方法：

Java代码  Berkely DB Java Edition学习笔记
  1. String aKey = "key";  
  2. String aData = "data";  
  3. try {  
  4. DatabaseEntry theKey = new DatabaseEntry(aKey.getBytes("UTF-8"));  
  5. DatabaseEntry theData = new DatabaseEntry(aData.getBytes("UTF-8"));  
  6. } catch (Exception e) {  
  7. }  


我们不应该依赖机器默认的编码，通常要指定特定的编码方法getBytes("UTF-8");
我们先看看怎么从数据库中读写记录：
通过Database.put()和Database.get()我们可以从数据库中读写记录
put:

Java代码  Berkely DB Java Edition学习笔记
  1. String aKey = "myFirstKey";  
  2. String aData = "myFirstData";  
  3. try {  
  4. DatabaseEntry theKey = new DatabaseEntry(aKey.getBytes("UTF-8"));  
  5. DatabaseEntry theData = new DatabaseEntry(aData.getBytes("UTF-8"));  
  6. myDatabase.put(null, theKey, theData);  
  7. } catch (Exception e) {  
  8. }  


get:

Java代码  Berkely DB Java Edition学习笔记
  1. String aKey = "myFirstKey";  
  2. try {  
  3. DatabaseEntry theKey = new DatabaseEntry(aKey.getBytes("UTF-8"));  
  4. DatabaseEntry theData = new DatabaseEntry();  
  5.   
  6. if (myDatabase.get(null, theKey, theData, LockMode.DEFAULT) ==  
  7. OperationStatus.SUCCESS) {  
  8.   
  9. byte[] retData = theData.getData();  
  10. String foundData = new String(retData, "UTF-8");  
  11. System.out.println("For key: ‘" + aKey + "‘ found data: ‘" +  
  12. foundData + "‘.");  
  13. } else {  
  14.   System.out.println("No record found for key ‘" + aKey + "‘.");  
  15. }  
  16. } catch (Exception e) {  
  17. }  


删除操作:

Java代码  Berkely DB Java Edition学习笔记
  1. String aKey = "myFirstKey";  
  2. DatabaseEntry theKey = new DatabaseEntry(aKey.getBytes("UTF-8"));  
  3. myDatabase.delete(null, theKey);  


使用BIND APIs来操作基本类型：
我们可以使用JE提供的Bind Apis来操作数字类型和字符串类型：
以Long为例：
存储数据使用Bind Apis一般步骤如下：
1、通过EntryBinding binding =TupleBinding.getPrimitiveBinding(Long.class);
2、通过EntryBinding 把数据放到DatabaseEntry中：
myBinding.objectToEntry(data, dataEntry);
获取数据使用Bind Apis一般步骤如下：
1、通过EntryBinding binding =TupleBinding.getPrimitiveBinding(Long.class);
2、通过EntryBinding将Entry转换成Object Long theLong = (Long) myBinding.entryToObject(theData);
下面代码以测试的形式演示了整个过程：

Java代码  Berkely DB Java Edition学习笔记
  1. package edu.jlu.fuliang;  
  2.   
  3. import java.io.File;  
  4.   
  5. import com.sleepycat.bind.EntryBinding;  
  6. import com.sleepycat.bind.tuple.TupleBinding;  
  7. import com.sleepycat.je.Database;  
  8. import com.sleepycat.je.DatabaseConfig;  
  9. import com.sleepycat.je.DatabaseEntry;  
  10. import com.sleepycat.je.Environment;  
  11. import com.sleepycat.je.EnvironmentConfig;  
  12. import com.sleepycat.je.LockMode;  
  13.   
  14. import junit.framework.TestCase;  
  15.   
  16. public class PrimitiveBindingTest extends TestCase{  
  17.     private Environment env;  
  18.     private Database db;  
  19.     private String key = "akey";  
  20.     private Long data = 1234556633L;  
  21.       
  22.     public void setUp()throws Exception{  
  23.         EnvironmentConfig envConfig = new EnvironmentConfig();  
  24.         envConfig.setAllowCreate(true);  
  25.         env = new Environment(new File("etc/dbEnv"),envConfig);  
  26.         DatabaseConfig dbConfig = new DatabaseConfig();  
  27.         dbConfig.setAllowCreate(true);  
  28.         db = env.openDatabase(null, "myDB", dbConfig);  
  29.         DatabaseEntry keyEntry = new DatabaseEntry(key.getBytes("UTF-8"));  
  30.         DatabaseEntry dataEntry = new DatabaseEntry();  
  31.           
  32.         EntryBinding myBinding = TupleBinding.getPrimitiveBinding(Long.class);  
  33.         myBinding.objectToEntry(data, dataEntry);  
  34.         db.put(null, keyEntry, dataEntry);  
  35.     }  
  36.       
  37.     public void testGet()throws Exception{  
  38.         DatabaseEntry keyEntry = new DatabaseEntry(key.getBytes("UTF-8"));  
  39.         DatabaseEntry dataEntry = new DatabaseEntry();  
  40.         EntryBinding binding = TupleBinding.getPrimitiveBinding(Long.class);  
  41.         db.get(null, keyEntry, dataEntry, LockMode.DEFAULT);  
  42.         Long l = (Long)binding.entryToObject(dataEntry);  
  43.         assertEquals(l,data);  
  44.     }  
  45.     public void tearDown()throws Exception{  
  46.         db.close();  
  47.         env.truncateDatabase(null, "myDB",false);  
  48.         env.close();  
  49.     }  
  50.       
  51. }  


序列化复杂的类型
步骤如下：
1、要存储的对象的类需要实现java.io.Serializable
2、打开两个数据库，一个存放数据，另一个存放类的信息
3、实例化com.sleepycat.bind.serial.StoredClassCatalog对象
4、创建uses com.sleepycat.bind.serial.SerialBinding对象
5、使用SerialBinding把对象放到DatabaseEntry中
下面是使用一个能够完整描述这个过程的例子来说明这个过程：

Java代码  Berkely DB Java Edition学习笔记
  1. package edu.jlu.fuliang;  
  2.   
  3. import java.io.File;  
  4.   
  5. import com.sleepycat.bind.EntryBinding;  
  6. import com.sleepycat.bind.serial.SerialBinding;  
  7. import com.sleepycat.bind.serial.StoredClassCatalog;  
  8. import com.sleepycat.je.Database;  
  9. import com.sleepycat.je.DatabaseConfig;  
  10. import com.sleepycat.je.DatabaseEntry;  
  11. import com.sleepycat.je.DatabaseException;  
  12. import com.sleepycat.je.Environment;  
  13. import com.sleepycat.je.EnvironmentConfig;  
  14. import com.sleepycat.je.LockMode;  
  15.   
  16. import junit.framework.TestCase;  
  17.   
  18. public class SerializableTypeTest extends TestCase{  
  19.     private Person person;  
  20.     private Environment env;  
  21.     private Database db,classDB;  
  22.     private StoredClassCatalog classCatalog;  
  23.       
  24.     public void setUp()throws Exception{  
  25.         person = new Person();  
  26.         person.setAge(12);  
  27.         person.setName("zhansan");  
  28.         person.setSex(‘m‘);  
  29.           
  30.         EnvironmentConfig envConfig = new EnvironmentConfig();  
  31.         envConfig.setAllowCreate(true);  
  32.         env = new Environment(new File("etc/dbEnv"),envConfig);  
  33.         DatabaseConfig dbConfig = new DatabaseConfig();  
  34.         dbConfig.setAllowCreate(true);  
  35.         db = env.openDatabase(null, "myDB", dbConfig);  
  36.         classDB = env.openDatabase(null, "classDB", dbConfig);  
  37.         classCatalog = new StoredClassCatalog(classDB);  
  38.         EntryBinding dataBinding = new SerialBinding(classCatalog,Person.class);  
  39.               
  40.         DatabaseEntry keyEntry = new DatabaseEntry(person.getName().getBytes("UTF-8"));  
  41.         DatabaseEntry dataEntry = new DatabaseEntry();  
  42.         dataBinding.objectToEntry(person, dataEntry);  
  43.         db.put(null, keyEntry, dataEntry);  
  44.     }  
  45.       
  46.     public void testGet()throws Exception{  
  47.         EntryBinding dataBinding = new SerialBinding(classCatalog,Person.class);  
  48.         
  49.         DatabaseEntry keyEntry = new DatabaseEntry(person.getName().getBytes("UTF-8"));  
  50.         DatabaseEntry dataEntry = new DatabaseEntry();  
  51.         db.get(null, keyEntry, dataEntry, LockMode.DEFAULT);  
  52.         Person p = (Person)dataBinding.entryToObject(dataEntry);  
  53.         assertEquals(p.getName(),person.getName());  
  54.         assertEquals(p.getAge(),person.getAge());  
  55.         assertEquals(p.getSex(), person.getSex());  
  56.     }  
  57.       
  58.     public void tearDown()throws Exception{  
  59.         db.close();  
  60.         classDB.close();  
  61.         env.truncateDatabase(null, "myDB", false);  
  62.         env.truncateDatabase(null, "classDB", false);  
  63.         env.close();  
  64.     }  
  65. }  


要存储的对象对应的类

Java代码  Berkely DB Java Edition学习笔记
  1. package edu.jlu.fuliang;  
  2.   
  3. import java.io.Serializable;  
  4.   
  5. public class Person implements Serializable{  
  6.     private String name;  
  7.     private int age;  
  8.     private char sex;  
  9.   
  10.     public int getAge() {  
  11.         return age;  
  12.     }  
  13.   
  14.     public void setAge(int age) {  
  15.         this.age = age;  
  16.     }  
  17.   
  18.     public String getName() {  
  19.         return name;  
  20.     }  
  21.   
  22.     public void setName(String name) {  
  23.         this.name = name;  
  24.     }  
  25.   
  26.     public char getSex() {  
  27.         return sex;  
  28.     }  
  29.   
  30.     public void setSex(char sex) {  
  31.         this.sex = sex;  
  32.     }  
  33. }  


自定义元组绑定：
存储复杂对象自定义元组绑定的步骤：
1、创建要存储的对象，这个对象的类没有必要实现Serializable接口：
2、扩展com.sleepycat.bind.tuple.TupleBinding来实现自定义的Binging
3、创建2步欻关键的自定义binding对象
4、将创建的对象是用自定义个binding放到DatabaseEntry中
5、使用put方法存入数据库
下面的例子说明了这个过程：
自定义Binging：

Java代码  Berkely DB Java Edition学习笔记
  1. package edu.jlu.fuliang;  
  2.   
  3. import com.sleepycat.bind.tuple.TupleBinding;  
  4. import com.sleepycat.bind.tuple.TupleInput;  
  5. import com.sleepycat.bind.tuple.TupleOutput;  
  6.   
  7. public class PersonTupleBinding extends TupleBinding{  
  8.   
  9.     @Override  
  10.     public Object entryToObject(TupleInput ti) {  
  11.         Person person = new Person();  
  12.         person.setName(ti.readString());  
  13.         person.setAge(ti.readInt());  
  14.         person.setSex(ti.readChar());  
  15.         return person;  
  16.     }  
  17.   
  18.     @Override  
  19.     public void objectToEntry(Object obj, TupleOutput output) {  
  20.         Person person = (Person)obj;  
  21.         output.writeString(person.getName());  
  22.         output.writeInt(person.getAge());  
  23.         output.writeChar(person.getSex());  
  24.     }  
  25. }  


put/get的使用过程：

Java代码  Berkely DB Java Edition学习笔记
    1. package edu.jlu.fuliang;  
    2.   
    3. import java.io.File;  
    4. import com.sleepycat.je.Database;  
    5. import com.sleepycat.je.DatabaseConfig;  
    6. import com.sleepycat.je.DatabaseEntry;  
    7. import com.sleepycat.je.DatabaseException;  
    8. import com.sleepycat.je.Environment;  
    9. import com.sleepycat.je.EnvironmentConfig;  
    10. import com.sleepycat.je.LockMode;  
    11.   
    12. import junit.framework.TestCase;  
    13.   
    14. public class CustomTupleBindingTest extends TestCase{  
    15.     private Person person;  
    16.     private Environment env;  
    17.     private Database db;  
    18.       
    19.     public void setUp()throws Exception{  
    20.         person = new Person();  
    21.         person.setAge(12);  
    22.         person.setName("zhansan");  
    23.         person.setSex(‘m‘);  
    24.           
    25.           
    26.         EnvironmentConfig envConfig = new EnvironmentConfig();  
    27.         envConfig.setAllowCreate(true);  
    28.         env = new Environment(new File("etc/dbEnv"),envConfig);  
    29.         DatabaseConfig dbConfig = new DatabaseConfig();  
    30.         dbConfig.setAllowCreate(true);  
    31.         db = env.openDatabase(null, "myDB", dbConfig);  
    32.         PersonTupleBinding binding = new PersonTupleBinding();  
    33.         DatabaseEntry keyEntry = new DatabaseEntry(person.getName().getBytes("UTF-8"));  
    34.         DatabaseEntry dataEntry = new DatabaseEntry();  
    35.         binding.objectToEntry(person, dataEntry);  
    36.         db.put(null, keyEntry, dataEntry);  
    37.           
    38.     }  
    39.       
    40.     public void testGet()throws Exception{  
    41.         PersonTupleBinding binding = new PersonTupleBinding();  
    42.           
    43.         DatabaseEntry keyEntry = new DatabaseEntry(person.getName().getBytes("UTF-8"));  
    44.         DatabaseEntry dataEntry = new DatabaseEntry();  
    45.         db.get(null, keyEntry, dataEntry, LockMode.DEFAULT);  
    46.         Person p = (Person)binding.entryToObject(dataEntry);  
    47.         assertEquals(p.getName(),person.getName());  
    48.         assertEquals(p.getAge(),person.getAge());  
    49.         assertEquals(p.getSex(), person.getSex());  
    50.     }  
    51.     public void tearDown()throws Exception{  
    52.         db.close();  
    53.         env.truncateDatabase(null, "myDB", false);  
    54.         env.close();  
    55.     }  
    56. } 

Berkely DB Java Edition学习笔记,布布扣,bubuko.com

Berkely DB Java Edition学习笔记

上一篇：asp.net连接数据库web.config配置


下一篇：我的MYSQL学习心得（十七） 复制