Chinaunix首页 | 论坛 | 博客

linxh

首页　| 　博文目录　| 　关于我

linxh

  • 博客访问： 4489457
  • 博文数量： 192
  • 博客积分： 10014
  • 博客等级： 上将
  • 技术积分： 8232
  • 用 户 组： 普通用户
  • 注册时间： 2006-07-21 00:22
文章分类

全部博文（192）

文章存档

2011年（4）

2009年（14）

2008年（174）

我的朋友
最近访客
推荐博文
相关博文
Berkely DB Java Edition学习笔记一

分类： 数据库开发技术

2008-06-15 12:53:49

 
 
lucene中用到je，查了一些资料，转载至此
 
 
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代码 复制代码
  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代码 复制代码
  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代码 复制代码
  1. long cacheMisses = myEnv.getStats(null).getNCacheMiss();  

我们可以获得cache未命中的次数，据此来调整cache的大小
可以同过Environment.getDatabaseNames()来获得Environment的数据库的名字：
Java代码 复制代码
  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代码 复制代码
  1. String dbName = myDB.getDatabaseName();   
  2. myDB.close();   
  3. myDBEnv.removeDatabase(null,dbName);  

可以使用Environment.renameDatabase()来重新命名一个数据库：
Java代码 复制代码
  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代码 复制代码
  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代码 复制代码
  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代码 复制代码
  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代码 复制代码
  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代码 复制代码
  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代码 复制代码
  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代码 复制代码
  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代码 复制代码
  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代码 复制代码
  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代码 复制代码
  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代码 复制代码
  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. }  
阅读(1666) | 评论(0) | 转发(0) |
0

上一篇：CVSNT在Windows下的安装和使用

下一篇：安装centos

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6