`

Berkeley DB Java Edition 使用手册

阅读更多

package test;

import com.sleepycat.je.*;

import com.sleepycat.bind.EntryBinding;

import com.sleepycat.bind.tuple.TupleBinding;

import com.sleepycat.bind.serial.StoredClassCatalog;

import com.sleepycat.bind.serial.SerialBinding;

import java.io.File;

public class test {

    public static void main(String[] args) {

   

    }

   

    /**

     * 打开和关闭环境,示例一

     *

     */

    public void eg1(){

        //----打开环境,如果不存在,则创建一个------------

        Environment myDbEnvironment=null;

        try {

            EnvironmentConfig envConfig = new EnvironmentConfig();

            envConfig.setAllowCreate(true); //true不存在就创建,false如果不存在则打开环境失败

            //envConfig.setReadOnly(true); //true 以只读方式打开,如果是多进程应用,每个进程都要设置为true

            //envConfig.setTransactional(true);//true支持事务,false不支持,默认false。可以更改配置文件来设置此参数。

            myDbEnvironment = new Environment(new File(".//"), envConfig);//环境所在路径

            java.util.List myDbNames = myDbEnvironment.getDatabaseNames(); //得到所有的数据库的名字

            for(int i=0; i < myDbNames.size(); i++) {

                System.out.println("Database Name: " + (String)myDbNames.get(i));

            }

        } catch (DatabaseException dbe) {

            // 错误处理

        }

        //----关闭环境----------------

        try {

            if (myDbEnvironment != null) {

            myDbEnvironment.cleanLog(); //在关闭前也最好执行一下cleaner,清理一下日志文件,因为delete操作会浪费一些空间

            myDbEnvironment.close();

            }

        } catch (DatabaseException dbe) {

            // 错误处理

        }

    }

    /**

     * 打开环境示例二

     *

     */

    public void eg2()

    {

        Environment myEnv = null;

        try{

            myEnv=new Environment(new File("/export/dbEnv"), null);

            EnvironmentMutableConfig envMutableConfig = new EnvironmentMutableConfig();

            envMutableConfig.setCachePercent(50);//设置jecache占用jvm 内存的百分比。

            //envMutableConfig.setCacheSize(123456);//设定缓存的大小为123456Bytes

            envMutableConfig.setTxnNoSync(true);//设定事务提交时是否写更改的数据到磁盘,true不写磁盘。

            //envMutableConfig.setTxnWriteNoSync(false);//设定事务在提交时,是否写缓冲的log到磁盘。如果写磁盘会影响性能,不写会影响事务的安全。随机应变。

            myEnv.setMutableConfig(envMutableConfig);

           

           

            EnvironmentStats envStats=myEnv.getStats(null);//调用 Environment.getStats() 返回一个EnvironmentStas对象。调用EnvironmentStats.getNCacheMiss()看命不中数。

            long cacheMisses = envStats.getNCacheMiss(); //这个统计非常重要,尤其针对于长时间运行的应用。 它返回不能够在内存中命中的请求总数,这可以用来参考指定cache的大小。

           

            //myEnv.getMutableConfig();//得到当前的环境配置信息

        }catch(DatabaseException dbe){}

    }

   

    /**

     * 打开database,以及相关操作

     *

     */

    public void eg3(){

        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); //也可能用DatabaseConfig参数来打开,这样就可以设置数据库的属性,比如是否允许在库不存在时创建它,是否只读打开,是否支持事务等。

 

            // Open the database. Create it if it does not already exist.

            DatabaseConfig dbConfig = new DatabaseConfig();

            dbConfig.setAllowCreate(true);

            //transactionnull,不支持事务

            myDatabase = myDbEnvironment.openDatabase(null,"sampleDatabase",dbConfig); //打开库,要提供一个数据库名字作为参数

        } catch (DatabaseException dbe) {

            // Exception handling goes here

        }

       

        //记录

        String aKey = "key";

        String aData = "data";

 

        try {

            DatabaseEntry theKey = new DatabaseEntry(aKey.getBytes("UTF-8"));//最好指定编码方式,因为不指定编码会用系统的默认编码来转换,因为系统的默认编码可能会被人更改。

            DatabaseEntry theData = new DatabaseEntry(aData.getBytes("UTF-8"));

            byte[] myKey = theKey.getData();

            byte[] myData = theData.getData();

           

            //byte数组转换为string的方法

            String key = new String(myKey, "UTF-8");

            String data = new String(myData, "UTF-8");

           

            //getput用在非重复的数据存储,读写库时,注意一个小区别,就是数据库,是否允许重复的记录存在,两个记录公用一个key,这就是重复的记录,我们把重复的记录成为重复集合。或者叫多重。

            //游标用于重复数据存储putget

            //数据记录在内部是用Btree按照特定排序来存储的。一般是用key来排序的,key相同的多重数据是按照data来排序。

           

            //记录Using Database Records

            //记录是由keydata组成,即所熟悉的key->value,二者都被是有DatabaseEntry封装的。

            //这个之前也提过很多次了,DatabaseEntry可以封装原始类型和复杂的对象类型,二者都要被转换为byte array存储,转换可以使用Bind API来完成

           

            //写数据

            myDatabase.put(null, theKey, theData);//如果不是可重复数据库,put将会覆盖原有的记录。

            //myDatabase.putNoOverwrite(null, theKey, theData);//不允许覆盖,不管是否允许数据重复。

           

            //读数据

            //--myDatabase.getSearchBoth(null, theKey, theData, LockMode.DEFAULT);//查找keydata都匹配的记录

            //--查询出来的keydata都是byte数组形式。

            if (myDatabase.get(null, theKey, theData, LockMode.DEFAULT) ==OperationStatus.SUCCESS)

            {

                byte[] retData = theData.getData();

                String foundData = new String(retData, "UTF-8");

                System.out.println("For key: '" + aKey + "' found data: '" +foundData + "'.");

            }

           

            //删除数据

            myDatabase.delete(null, theKey); //删除数据

 

          } catch (Exception e) {}

 

        //关闭数据库

        //如果打开了游标,关闭时JE会发出警告,让你关闭他们先。活动状态的游标在关闭库的过程中会产生意想不到的结果,尤其是其他线程在写库的过程中。确定所有的访问都结束后再关闭库

        try {

            if (myDatabase != null) {

                myDatabase.close();

                myDbEnvironment.renameDatabase(null, "sampleDatabase", "test");//重命名,必须先关闭数据库

                myDbEnvironment.removeDatabase(null, "sampleDatabase");//删除数据库,必须先关闭数据库

                //myDbEnvironment.truncateDatabase(null, myDatabase.getDatabaseName(),true);//删除并回收数据库空间 ,true返回删除的记录的数量,false不返回删除的记录数量值

            }

 

            if (myDbEnvironment != null) {

                myDbEnvironment.close();

            }

        } catch (DatabaseException dbe) {

            // Exception handling goes here

        }

    }

   

    /**

     * Deferred Write Databases 缓冲写库

     *

     * By默认,JE的数据库是持久化,意思就是说不缓存,写库的,这样多个应用都可以使用,把数据库设置成非持久化的,就成为缓冲写库。

     * 缓冲写库本质上说就是内存级数据库,这适用于那些临时的操作。比如把oracle中的数据导入bdb,然后读bdb cache

     * 缓冲写库并不是总是请求磁盘I/O,很重要的一点,缓冲写库会在内存不够用的时候写磁盘。如果内存够大,用缓存写库那是最好不过了。

     * 调用Database.sync()让修改过的cache数据写到磁盘

     * 当重新打开一个缓冲写库的环境时,数据库的状态是和上一次sync时一致的。如果缓冲写库没有同步,就会当成是空库。问号,那么在数据关闭之前一定要syncmaybe yes

     * 程序员很容易就可以把缓冲写库的修改存储到磁盘上,对经常性的修改,增加,及删除等等的操作的应用也很有用处。通过延迟写库,延迟了磁盘IO 这可以提高数据的流量。

     * 注意,当没有调用sync的库关闭时而且环境也关闭的时候,cache的修改会丢失。如果没有关闭环境,所有的cache的修改还是会保留的。

     * 设置库为defered or not,然后用DatabaseConfig的选项打开库。

     */

    public void eg4(){

        Environment myDbEnvironment = null;

        Database myDatabase = null;

        try {

            EnvironmentConfig envConfig = new EnvironmentConfig();

            envConfig.setAllowCreate(true);

            myDbEnvironment = new Environment(new File("/export/dbEnv"), envConfig);

 

            DatabaseConfig dbConfig = new DatabaseConfig();

            dbConfig.setAllowCreate(true); //设置允许创建与否,默认值是false,打开不存在的数据库会报错。true的时候,数据库不存在就创建。

            //dbConfig.setBtreeComparator();//设置B树比较器,用来比较两个记录的key是否相同。

            //dbConfig.setDuplicateComparator();//设置允许key重复的比较器。

            dbConfig.setSortedDuplicates(false);//设置为true,允许key重复,false的话,put一个存在key的记录会产生错误。如果使用了关联了多个索引则一定不能支持重复的记录。

            //dbConfig.setExclusiveCreate(false);//如果true,只能创建,如果存在,则打开失败If true, the database open fails if the database currently exists. That is, the open must result in the creation of a new database. Default is false.

            //dbConfig.setReadOnly(true);//设置是否只读

            //dbConfig.setTransactional(true);//设置是否支持事务

            dbConfig.setDeferredWrite(true);  //true为进行缓冲写库,false则不进行缓冲写库

            myDatabase = myDbEnvironment.openDatabase(null,"sampleDatabase",dbConfig);

           

           

            String dbName = myDatabase.getDatabaseName();//得到数据库的名字

            Environment theEnv = myDatabase.getEnvironment();//得到当前数据库环境

            myDatabase.preload(1024*1024); //预先加载数据到内存,long型参数表示要装载到内存的数据的最大数

 

            //long类型的数据存储方法

           

            try {

                String aKey = "myLong";

                DatabaseEntry theKey = new DatabaseEntry(aKey.getBytes("UTF-8"));

               

               

                Long myLong = new Long(123456789l); 

                DatabaseEntry theData = new DatabaseEntry();

                EntryBinding myBinding = TupleBinding.getPrimitiveBinding(Long.class);

                myBinding.objectToEntry(myLong, theData);

 

                //存储long类型的数据

                myDatabase.put(null, theKey, theData);

               

                OperationStatus retVal = myDatabase.get(null, theKey, theData,LockMode.DEFAULT);String retKey = null;

                if (retVal == OperationStatus.SUCCESS) {

                   //取得long类型的数据

                    Long theLong = (Long) myBinding.entryToObject(theData);

                    retKey = new String(theKey.getData(), "UTF-8");

                    System.out.println("For key: '" + retKey + "' found Long: '" +

                                        theLong + "'.");

                } else {

                    System.out.println("No record found for key '" + retKey + "'.");

                }

   

            } catch (Exception e) {

                // Exception handling goes here

            }

           

            //implements Serializable 的对象的存储

           

            try {

                String aKey = "myLong";

                DatabaseEntry theKey = new DatabaseEntry(aKey.getBytes("UTF-8"));

               

                //写对象

                java.util.Vector data2Store = new java.util.Vector(); //假设他是implements Serializable

                StoredClassCatalog classCatalog = new StoredClassCatalog(myDatabase);

                EntryBinding dataBinding = new SerialBinding(classCatalog, java.util.Vector.class);//指定类型

                DatabaseEntry theData = new DatabaseEntry();

                dataBinding.objectToEntry(data2Store, theData);//绑定数据

                myDatabase.put(null, theKey, theData);

               

                //读对象

                myDatabase.get(null, theKey, theData, LockMode.DEFAULT);

                java.util.Vector retrievedData = (java.util.Vector) dataBinding.entryToObject(theData);

               

            } catch (Exception e) {

                // Exception handling goes here

            }

           

           

            //做一些处理

            myDatabase.sync(); //当写完一定量的数据以后,同步要硬盘中

        } catch (DatabaseException dbe) {

            // Exception handling goes here

        }

       

        //关闭数据库

        try {

            if (myDatabase != null) {

                myDatabase.close();

            }

 

            if (myDbEnvironment != null) {

                myDbEnvironment.close();

            }

        } catch (DatabaseException dbe) {

            // Exception handling goes here

        }

    }

   

    /**

     * Data Persistence 持久化

     * 如果是在内存中修了数据,需要写到磁盘。

     * 怕因为系统错误引发数据丢失,可以使用transaction,每commit一次,修改都会被保存。

     * 只是用来存放应用临时数据的话,就不需要用transaction了。

     * 在每次关闭env的时候会执行,也可以在程序中调用执行。

     */

}

/**

 *<

分享到:
评论

相关推荐

    Berkeley DB Java Edition (JE)

    Berkeley DB Java Edition (JE) 官方7.5.11下载版本。 相关介绍 https://blog.csdn.net/hadues/article/details/80854288

    Berkeley DB Java Edition

    **Berkeley DB Java Edition**,简称BDBJE,是由Oracle公司开发的一款高度可移植的、基于文件系统的数据存储解决方案,特别适用于需要高效、可靠且无服务器的数据管理的应用场景。这款数据库系统采用B+树作为其核心...

    Berkeley DB Java Edition 5.0.73

    **Berkeley DB Java Edition 5.0.73** Berkeley DB Java Edition(简称BDB JE)是一款由Oracle公司开发的高性能、轻量级的NoSQL数据库系统。它以其高效能、可扩展性和可靠性在处理大规模数据存储时受到广泛欢迎,...

    Berkeley DB Java Edition学习报告

    Berkeley DB Java Edition (JE) 是一款开源的嵌入式数据库管理系统,由Sleepycat Software开发,现归Oracle公司所有。这款数据库系统以其键值(K/V)存储模型为特色,适用于需要高性能、可伸缩性及事务处理能力的应用...

    Berkeley DB Java Edition数据结构的研究与应用.pdf

    Berkeley DB Java Edition(JE)是一种为Java程序提供内嵌式、事务保护的数据库引擎,它继承了Berkeley DB家族的优点,包括快速、可靠和具备容错能力的数据管理特性。为了深入理解其数据存储结构,有必要对JE使用的B...

    Berkeley DB Java Edition 4.1.10.zip

    Berkeley DB Java Edition (JE)是一个完全用JAVA写的,它适合于管理海量的,简单的数据。 能够高效率的处理1到1百万条记录,制约JE数据库的往往是硬件系统,而不是JE本身。 多线程支持,JE使用超时的方式来处理...

    Berkeley DB的java版本

    Berkeley DB Java Edition JE 是一个完全用JAVA写的 它适合于管理海量的 简单的数据 能够高效率的处理1到1百万条记录 制约JE数据库的往往是硬件系统 而不是JE本身 多线程支持 JE使用超时的方式来处理线程间的死琐...

    Berkeley DB Java Edition 4.0.92 开发包

    《Berkeley DB Java Edition 4.0.92 开发包详解》 Berkeley DB Java Edition(简称BDB JE)是Oracle公司推出的一款强大的、高度可定制的嵌入式数据库系统,尤其适用于Java应用程序。这款数据库引擎以其轻量级、高...

    Java嵌入式NoSQL数据库之Berkeley DB Java Edition

    **Java嵌入式NoSQL数据库之Berkeley DB Java Edition** Berkeley DB Java Edition(简称BDB JE)是一种高性能、轻量级的嵌入式数据库系统,由Oracle公司开发,广泛应用于需要快速数据存储和检索的应用场景。它并非...

    Berkeley DB Java 版 4.0.92

    Oracle Berkeley DB Java 版是一个开源的、可嵌入的事务存储引擎,是完全用 Java 编写的。与 Oracle Berkeley DB 类似,Oracle Berkeley DB Java 版在应用程序的地址空间中执行,没有客户端/服务器通信的开销,从而...

    Berkeley DB Java Edition初步

    NULL 博文链接:https://xpenxpen.iteye.com/blog/2124921

    berkeley db java

    自己稍微封装了一下,可以当成简单的map来使用。

    BerkeleyDB_java_jar包

    这可能是BerkeleyDB Java Edition的jar文件,表示BerkeleyDB Java版的7.5.11版本。这个文件通常会包含以下组件: 1. **BerkeleyDB引擎**:这是数据库的核心部分,处理数据的读写操作,包括事务处理、并发控制、恢复...

    Berkeley DB Java 版直接持久层基础1

    Berkeley DB Java 版直接持久层基础1是指使用 Berkeley DB Java 版本来实现直接持久层的技术基础。直接持久层是一种数据访问技术,允许Java应用程序直接访问数据库,而不需要通过SQL来访问数据库。Berkeley DB Java ...

    嵌入式Berkeley DB Java版与Derby技术研究.pdf

    《嵌入式Berkeley DB Java版与Derby技术研究》一文主要探讨了两种典型的嵌入式数据库技术——Berkeley DB Java Edition和Apache Derby。嵌入式数据库在资源有限的环境中,如嵌入式系统,因其体积小、功能齐全、可...

    Berkeley DB参考手册PDF版本

    - **20.8 一个新的BerkeleyDB java持久API** - **Java API**:介绍一个新的用于Berkeley DB的Java持久化API。 - **20.9 如何操作BerkeleyDB的Records** - **记录操作**:说明如何在Berkeley DB中插入、更新和删除...

Global site tag (gtag.js) - Google Analytics