* 使用基于Key/Value 接口的场合，可以考虑Berkeley DB C版本或者Berkeley DB Java 版的产品。可以参考美国University of Virginia的叫做PRIDE的学术论文：http://www.cs.virginia.edu/~stankovic/psfiles/pride.pdf

* 使用Oracle Berkeley DB SQL产品中的R*Tree功能，具体可以参考：http://www.bdbchina.com/2010/04/bdb11gr2的r-tree功能/

更多反馈，欢迎留言。

这些年来，随着大量数据的产生，数据可视化（data visualization）广泛应用于科研、军事、金融、医疗等等领域。我们的生活也到处可见数据可视化的例子。比如，股票软件上显示的K线图，调查结果的柱状图、曲线图，人口分布的密度图等等等等。

那么，什么是数据可视化呢？根据维基百科的解释：Data visualization is the study of the visual representation of data, meaning “information which has been abstracted in some schematic form, including attributes or variables for the units of information”。简单来说，数据可视化就是用更加直观更加生动易懂的图形图像表现某种特定的数据集合。

这篇文章将简单介绍如何轻松利用BDB Java Edition （JE）和prefuse实现自己的数据可视化应用。

可视化工具和数据库的选择

首先我们选择prefuse作为数据可视化工具。prefuse是一个轻量级的用于可视化任意数据集（visualize the data）的java类库，它提供了多种数据可视化模式，比如柱状图、树图、饼图等等。它的优点是简单易用、可视化功能齐全。

但仅仅有可视化工具是不够的，还需要什么呢？当然还必须有存储数据的数据库。可以打个比方，数据是一栋房子，数据可视化就是我们要给房子做装修，让它更好看，那么数据库就是地基。没有地基，何来房子，更不用说装修了。那么，我们选择什么样的数据库呢。既然prefuse是java类库，而我们JE的特点是纯Java实现，性能高，footprint小等等，那么，JE绝对是一个很好的选择。

好了，现在就让我们看看JE + prefuse的威力吧。

数据集属性的定义

首先，我们选择需要做可视化的数据集。在这里，我给出的例子是可视化某个公司的员工数据，包括他们的基本属性，上下级关系和各自所参与的任务。

1. 员工（Employee）的属性

@Entity
public class Employee {
    @PrimaryKey
    int employeeId;

    @SecondaryKey(relate = MANY_TO_ONE)
    String employeeName;

    @SecondaryKey(relate = MANY_TO_ONE)
    float salary;

    @SecondaryKey(relate = MANY_TO_ONE, relatedEntity=Employee.class,
                 onRelatedEntityDelete=NULLIFY)
    int managerId;

    @SecondaryKey(relate = MANY_TO_ONE, relatedEntity=Department.class,
                 onRelatedEntityDelete=NULLIFY)
    int departmentId;

    @SecondaryKey (relate =MANY_TO_MANY, relatedEntity=ServiceRequest.class,
                 onRelatedEntityDelete=NULLIFY)
    Set<Integer> SRIds = new HashSet<Integer>();

    String address;
    String email;
    String phone;

    /* setter and getter functions. */
}

2. 部门（Department）的属性

@Entity
class Department {
    @PrimaryKey
    int departmentId;

    @SecondaryKey(relate = ONE_TO_ONE)
    String departmentName;

    String location;

    /* setter and getter functions. */
}

3. 任务（ServiceRequest）的属性

@Entity
class ServiceRequest {
	@PrimaryKey
	int SRId;

	String title;
	String content;

/* setter and getter functions. */
}

数据可视化效果

我们选择两种可视化方式：弧形树（radial tree）和节点树（node link tree）。下面看看我们的可视化效果。

利用radial tree来显示整个公司的结构（organization chart)：

上图左边最大的窗口显示的是整个公司的结构图。从图中可以看出公司有四个部门。每一个有颜色小节点代表一名员工，不同部门的员工具有不同的颜色。节点之间的连线表示上下级关系。上图右上角的小窗口显示的是选中的员工的具体信息。右下角的小窗口显示的是JE database 的schema图。从中可以看出我们定义了三个Entity: Employee, Department以及Service Request.

点击任意一个员工节点，将可以显示此员工的上下级结构图，也就是在此公司与之有关系的所有员工的结构图。比如我们点击名字叫Goodstein A. Chavez 的员工，结果如下图所示：

从上图可以看出，此员工有四名直接下属，而他的老板直接向公司的CEO汇报。

除了可以直接点击员工节点（基于员工ID）进行查询，我们还可以通过部门ID（Department ID）经理ID（Manager ID）和具体的任务ID（SR ID）和员工姓名来对员工进行查询。下面是对部门ID和任务ID查询的结果截图。

部门2的员工结构图（DeparmentID = 2）

部门2中，参与了任务3的员工（DeparmentID = 2 and SRId = 3）

值得一提的是，所有这些关系的查询都可以利用在JE里面定义的Entity之间的关系（relation），而不需要我们做额外的查询工作，比如想通过经理ID来查询此经理的直接下属，一句代码便可以实现：

dao.employeeByManagerId.subIndex(Integer.valueOf(searchKey)).entities();

JE+prefuse的优势总结

1. 简单易用：用过JE的朋友都知道，利用JE（特别是JE DPL）能够十分轻松、灵活定义各种数据集模型，其get/put操作也特别简单，而且能够很容易写出特定的查询语句。而prefuse也提供了功能齐全的可视化API。所以，利用JE做数据的存取操作，利用prefuse做数据的可视化操作，其对接是十分直接和简便的。
2. Footprint小：拿上面所举的员工数据可视化应用例子来说，整个应用程序打成可直接运行的jar文件才1.87M，但功能却很齐全（多种可视化效果，多种查询方式）。这样大小的程序，即使安装在一般的移动设备（比如手机）上运行都绰绰有余。
3. 性能高：数据可视化的性能主要体现在做查询和可视化的速度。还是以员工数据可视化为例，插入员工数据有1000条，存储到JE 数据库的大小是729k。之后用户对节点的点击和在输入框的查询，其可视化结果都能迅速得以显示（笔者没有做过具体的时间记录，但相信所需时间都是毫秒级的）。

结束语

从这个例子我们可以看出在数据可视化方面，利用JE作为存储引擎是一个很好的选择。有兴趣的朋友不妨一试。另外，这里有一个十分有趣例子，是利用JE和Google Visualization API来可视化一栋房子的用电情况（ electric usage of Hypatia House），感兴趣的朋友请参考以下链接：http://excitedcuriosity.wordpress.com/2010/02/22/its-electric-ted-data-storage-and-plotting/

One major focus of Berkeley DB has been replication for high availability (HA), the other is support for the Google Android phone platform.
* Read the new “BDB JE on Android” whitepaper
* See a screenshot of JE running on Android storing map coordinates displayed on Google Maps
* Search Oracle.com for Android (google: “site:oracle.com android”) note that most results are about BDB JE

Berkeley DB Java Edition (JE) 4.0.92

Includes the following new features and changes:

* Enhancements have been added for JE High Availability, which supports the use of JE with replication.
* The monitor package has several new event types which help a replicated application track replication group changes. A new example has been added to the replication example group to illustrate the use of RMI in replication write request forwarding.
* New properties have been added to help administer a replication group in the face of major hardware failure.
* A new RMI based example has been added to the set of JE HA Examples.
* See the High Availability Guide for an introduction to the product, and the com.sleepycat.je.rep javadoc for API specifications.
* JE’s MBeans and JConsole plugin have several new methods and capabilities to improve the ability to monitor an application. See the how-to for more information.
* Changes were made to make it easier to control JE’s use of java.util.logging through programmatic means.
* A number of bug fixes were made to work around problems in the Dvalvik libraries used by Android applications.
* A number of general bug fixes, performance improvements, and documentation improvements were made.

Software Downloads

* Downloads available today at http://download.oracle.com/berkeley-db/je-4.0.92.zip.

Questions?

Please direct your questions to our OTN forum at http://forums.oracle.com/forums/forum.jspa?forumID=273.

Android平台内置的存储数据库（或者说存储引擎）是SQLite。但由于SQLite其自身的一些缺陷，比如非Java语言、并发读写性能不 佳、技术支持困难等等，所以我们的用户倾向于Berkeley DB。我在这里向大家推荐Berkeley DB Java Edition（简称BDB JE）。我们可以把BDB JE的优势（它除了是存Java语言实现外，还有很高的存储性能和良好的并发性支持、Oracle的开发及技术支持团队等等）充分运用到Android 平台上。众所周知，Android平台是类Java语言的，所以，BDB JE对Android平台的开发者而言是一款利器。

以下将手把手教你将BDB JE快速配置到Android平台上（本文，我们用Android在PC机上的模拟器 (avd) 作为实例平台）。

准备工作

• 如果你的电脑上尚未安装Android SDK。那么首先点击这里下载并且安装 Android SDK。Android的官方主页上有详细的如何安装并且启动Android 模拟器（avd）的文档，这里就不再涉及。必须注意的一点是， 将你所安装的Android目录下（假如是<android-installation -home>）的 “tools” 文件夹路径加入到你电脑的路径（path）中去（相信有一定编程经验的读者一定很熟悉如何添加系统路径了），这样，你就可以直接在命令行上运行 Android的各种命令了。

• 点此下载最新版本的BDB JE。解压缩之后（假如你解压路径为JE_HOME/）可以看到在JE_HOME/lib/ 下有一个“je-android-4.0.71.jar”文件。如果找不到，说明你下载的不是最新版本的BDB JE。请到Oracle BDB JE官方网址进行下载：http://www.oracle.com/technology/products/berkeley-db/je/index.html。

• 在开始下面教程之前，我默认大家已经有一定的Android编程基础，如果没有，请大家到Android的官方主页上阅读相关文档（比如，如 何实现“hello world”）.

选择一：在装有Android 插件的Eclipse 编程环境下进行配置

• 如果你编程的IDE是Eclipse，并且你已经在上面安装了Android编程插件（如何在Eclipse上安装Android插件，请看这里），那么就继续阅读本小节以下步骤。注意，我用的是Eclipse3.4.2（Ganymede）版本， 也许不同的版本配置上有稍微的区别。这里建议Eclipse3.4版本以上。

• 打开Eclipse，确认在Windows->Preference->Android下已经写入Android SDK的路径。进入"File->New->Project->Android->Android Project->Next Project"，在弹出的建立project的面板上选择build target（比如Android2.0），并填写Project name (JEExample)、 application name (JEExample)、package name (com.sleepycat.je) 和 activity name (JEExample)。最后点击Finish。Eclipse将会自动帮你生成一个Android工程。假设你所建立的工程路径是<eclipse-je-android-dir>

• 进入”Project->Properties->Libraries->Add External JARs”，在弹出的窗口中选择JE_HOME/lib/je-android-4.0.71.jar。点击OK，你将可以看到在你建立的工程 （JEExample）下面有Referenced Libraries目录，点击之后可以看到je-android-4.0.71.jar。

• 复制代码（这些代码可在下面的"源代码"小节找到）：
  • 将JEExample.java 复制到<eclipse-je-android-dir>/src/com/sleepycat/je
  • 将main.xml 复制到<eclipse-je-android-dir>/ res/layout/main.xml and
  • 将strings.xml 复制到 <eclipse-je-android-dir>/res/values/strings.xml
• 在Eclipse中，打开main.xml，你可以看到在上一步中复制的代码。点击Run，运行JEExample。在正确运行之前，你还需要在 Android上面建立一个用于存储JE数据的文件夹，具体步骤看“在Android模拟器上运行程序”小节中的第一步。

选择二：在非IDE环境下进行配置

• 如果你不喜欢用IDE（如Eclipse)进行编程，只想通过命令行进行配置，请继续阅读本小节以下步骤。

• 首先建立一个Android 的模拟器（AVD）（如果你还没有在你的电脑上建立过Android 的模拟器）：
  • 在命令行运行 android create avd --target 3 --name my_avd （注意，我在这里建立的是Android1.6的模拟器，你也可以建立Android2.0模拟器）
  • 在你想要建立Android工程的目录下面，运行
    • android create project --path JEExample --package com.sleepycat.je --name JEExample --activity JEExample --target 3

    命令运行之后，将在你所在目录下面建立Android工程，文件夹的名称叫做JEExample，其中会有 JEExample/src/com/sleepycat/je/JEExample.java 文件。


• 将JE_HOME/lib/je-android-4.0.71.jar 文件复制到JEExample/libs

• 将三个文件：JEExample/src/com/sleepycat/je/JEExample.java， JEExample/res/layout/main.xml 和 JEExample/res/values/strings.xml 替换成下面“源代码”小节中对应的三个文件：JEExample.java， main.xml 和 strings.xml。

• 进入<android-installation-home>/platforms/android-1.6/tools， 打开 dx.bat 文件， 将其中一行 “REM set javaOpts=-Xmx256M” 改成 “set javaOpts=-Xmx512M“。注意“REM”要去掉。另外，如果你之前建立的Android模拟器 （AVD）是Android2.0，那么就更改android-2.0/tools下的dx.bat文件。

• 运行Android 模拟器：emulator -avd my_avd

• 用命令行进入JEExample目录，然后运行命令
  • ant install

这个命令将会编译JEExample.java ，然后生成JEExample/bin/JEExample-debug.apk ，并将它安装到你所运行的Android 模拟器中。

在Android模拟器上运行示例程序

• 首先，为Android程序建立JE environment 路径，用于存储JE的数据（这一步不可忽略，并且路径名要跟程序一致，否则无法正确运行程序）。具体做法是 ：
  • 在命令行运行adb shell mkdir /data/local/je。或者你首先运行adb shell，然后cd data/local，最后mkdir je。
  • 你也可以删除这个文件夹：rm /data/local/je/*。更多adb shell的命令请参照Android文档。
• 在Android模拟器窗口上点击三角按钮（在Home界面）进入程序列表，在这里你可以看到已经安装上去的 JEExample 程序图标, 点击它，运行JEExample程序。 进入程序之后，在程序界面最上方可以看到  “JEExample”  字样，下面是一个 文字编辑框（TextEdit box）, 还有两个按钮，分别是 “Put Data” 和  “Get Data” 。

• 存数据：
  • 在文字编辑框里输入 key/data 数据对（比如 k1/d1）然后点击 “Put Data” 按钮，这样一条数据（键是k1，值是d1）便存进JE数据库中。

你可以在命令行运行adb shell，进入/data/local/je， 就可以看到JE的存储数据。

• 读数据：
  • 在文字在文字编辑框里输入 你之前存储的键值key（比如k1），然后点击 “Get Data” 按钮，将会弹出“Get Data”的对话框，上面显示你之前存储的数据（比如d1）。

JE示例源代码

• JEExample.java

  
  package com.sleepycat.je;
  
  import android.app.Activity;
  import android.app.AlertDialog;
  import android.content.DialogInterface;
  import android.util.Log;
  import android.os.Bundle;
  import android.view.View;
  import android.widget.Button;
  import android.widget.EditText;
  import android.widget.TextView;
  
  import java.io.File;
  
  import com.sleepycat.je.Database;
  import com.sleepycat.je.DatabaseConfig;
  import com.sleepycat.je.DatabaseEntry;
  import com.sleepycat.je.DatabaseException;
  import com.sleepycat.je.Environment;
  import com.sleepycat.je.EnvironmentConfig;
  import com.sleepycat.je.OperationStatus;
  import com.sleepycat.je.Transaction;
  
  public class JEExample extends Activity {
  
      @Override
      public void onCreate(Bundle icicle) {
          super.onCreate(icicle);
  
          try {
              final File envDir = new File("/data/local/je");
              final EnvironmentConfig envConfig = new EnvironmentConfig();
              envConfig.setTransactional(true);
              envConfig.setAllowCreate(true);
              final Environment env = new Environment(envDir, envConfig);
              final DatabaseConfig dbConfig = new DatabaseConfig();
              dbConfig.setTransactional(true);
              dbConfig.setAllowCreate(true);
              dbConfig.setSortedDuplicates(true);
              final Database db = env.openDatabase(null, "exampledb", dbConfig);
  
              setContentView(R.layout.main);
              final Button button1 = (Button) findViewById(R.id.do_put);
              button1.setOnClickListener(new Button.OnClickListener() {
                  public void onClick(View v) {
  
                      final EditText editText =
                          (EditText) findViewById(R.id.entry);
                      final String keyData = editText.getText().toString();
                      final int idx = keyData.indexOf("/");
                      String key = null;
                      String data = null;
                      String result = null;
                      if (idx < 0) {
                          result = "enter key/data to put";
                      } else {
                          key = keyData.substring(0, idx);
                          data = keyData.substring(idx + 1);
                          result = key + "/" + data;
                          final DatabaseEntry keyEntry =
                              new DatabaseEntry(key.getBytes());
                          final DatabaseEntry dataEntry =
                              new DatabaseEntry(data.getBytes());
  
                          try {
                              final Transaction txn =
                                  env.beginTransaction(null, null);
                              final OperationStatus res =
                                  db.put(txn, keyEntry, dataEntry);
                              if (res != OperationStatus.SUCCESS) {
                                  result = "Error: " + res.toString();
                              }
                              txn.commit();
                          } catch (DatabaseException DE) {
                              result = "Caught exception: " + DE.toString();
                          }
                      }
                      Log.d("JE", "did put of: " + result);
  
                      if (result.contains("Caught exception:")) {
                      	new AlertDialog.Builder(JEExample.this).
                      	    setTitle("Put Data").setMessage(result).
                      	    setPositiveButton("Quit", new DialogInterface.OnClickListener() {
                      		    public void onClick(DialogInterface dialog, int whichButton) {
                      		    }
                      		}).show();
                      } else {
                      	new AlertDialog.Builder(JEExample.this).
                  	        setTitle("Put Data").setMessage("You put the key/data pair: " + result).
                  	        setPositiveButton("Confirm", new DialogInterface.OnClickListener() {
                  		        public void onClick(DialogInterface dialog, int whichButton) {
                  		        }
                  		    }).show();
                      }
                  }
              });
  
              final Button button2 = (Button) findViewById(R.id.do_get);
              button2.setOnClickListener(new Button.OnClickListener() {
                  public void onClick(View v) {
  
                      final EditText editText =
                          (EditText) findViewById(R.id.entry);
                      final String key = editText.getText().toString();
                      final DatabaseEntry keyEntry =
                          new DatabaseEntry(key.getBytes());
                      final DatabaseEntry dataEntry = new DatabaseEntry();
                      String result = null;
                      try {
                          final Transaction txn =
                              env.beginTransaction(null, null);
                          final OperationStatus res =
                              db.get(txn, keyEntry, dataEntry, null);
                          if (res != OperationStatus.SUCCESS) {
                              result = "Error: " + res.toString();
                          } else {
                              result = new String(dataEntry.getData());
                          }
                          txn.commit();
                      } catch (DatabaseException DE) {
                          result = "Caught exception: " + DE.toString();
                      }
                      Log.d("JE", "did get of: " + result);
                      if (result.contains("Caught exception:")) {
                      	new AlertDialog.Builder(JEExample.this).
                  	        setTitle("Get Data").setMessage(result).
                  	        setPositiveButton("Quit", new DialogInterface.OnClickListener() {
                  		        public void onClick(DialogInterface dialog, int whichButton) {
                  		        }
                  		    }).show();
                      } else {
                      	new AlertDialog.Builder(JEExample.this).
                  	        setTitle("Get Data").setMessage("Get result: " + result).
                  	        setPositiveButton("Confirm", new DialogInterface.OnClickListener() {
                  		        public void onClick(DialogInterface dialog, int whichButton) {
                  		        }
                  		    }).show();
                      }
                  }
              });
          } catch (Exception DE) {
              TextView tv = new TextView(this);
              tv.setText("blew chunks " + DE);
              setContentView(tv);
          }
      }
  }
  

• res/layout/main.xml

  
  <?xml version="1.0" encoding="utf-8"?>
  <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
      android:orientation="vertical"
      android:layout_width="fill_parent"
      android:layout_height="fill_parent"
      >
  
    <TextView android:id="@+id/label"
      android:layout_width="fill_parent"
      android:layout_height="wrap_content"
      android:text="JEExample"
      />
  
    <EditText android:id="@+id/entry"
              android:layout_width="fill_parent"
              android:layout_height="wrap_content"
              android:background="@android:drawable/editbox_background"
              android:layout_below="@id/label"
      />
  
    <Button android:id="@+id/do_put"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="@string/button_put"
      />
  
    <Button android:id="@+id/do_get"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="@string/button_get"
      />
  </LinearLayout>
  

• res/values/strings.xml

  
  <?xml version="1.0" encoding="utf-8"?>
  <resources>
      <string name="app_name">JEExample</string>
      <string name="button_put">Put Data</string>
      <string name="button_get">Get Data</string>
  </resources>

结束语

怎么样，是不是很简单就可以将JE配置到Android中了？你也赶紧试试吧。如果在配置或者安装过程中出错，欢迎给我留言。

注：英文好的同学，可以参照JE最新发布包中的<je-home>/docs/HOWTO-Android.html的英文原文。

概览

Berkeley DB Java 版是一套纯Java语言实现的嵌入式数据库。它提供的事务存储引擎不仅显著的减少了对象持久化开销，而且保持了对象-关系映射（ORM）解决方案的灵活性，速度和扩展性。Berkeley DB Java版3.0引入了直接持久层（DPL），旨在提供和与企业 Java Bean 3.0 (EJB3) 持久性相同好处：对象持久化时，不需要将对象转换成关系表。

更多请参见我在OTN上完整的中文翻译：http://www.oracle.com/technology/global/cn/products/berkeley-db/pdf/bdb-je-persistence-api-basics.pdf

英文原文：http://www.oracle.com/database/docs/BDB-JE-DPL-Basics-Whitepaper.pdf

起源

加州大学伯克利分校的BSD 4.3及以前的所有版本包含了专属于AT&T Unix代码，而当时从AT&T获得源码许可证是非常地昂贵。为了不受许可证的支配，当时BSD的开发者Keith Bostic提议，BSD系统中应该有更多的非AT&T部分，以Net/1的协议发布。随后，在1991年，Keith Bostic和Margo Seltzer 以及 Mike Olson一起着手开发了Berkeley DB以替换当时的Unix下经典的数据库引擎ndbm（New Database Manager， http://en.wikipedia.org/wiki/Ndbm）。这之后Berkeley DB迅速流行起来，并促成了Sleepycat Software公司（在2006年2月时，Sleepycat Software被甲骨文收购）。 时间进入到2004年，随着Java语言的大行其道以及其对多线程机制的良好支持，Berkeley DB的开发者们为Java开源社区带来一味大餐，这便是今天的Oracle Berkeley DB Java版(下文简称为 JE)。

JE 介绍

关系数据库是开发人员可用来进行数据存储和分析的最复杂的工具之一。大多数持久化的对象数据并非为特定的SQL的查询分析而存在；它们通常在程序中被检索，然后重构成为具体Java 对象才能使用。我想这就是现在一些主流Java企业应用中用到的Object-Relational Mapping(ORM)的技术。但从Java面向对象编程的角度看，能否直接将要持久化的对象通过诸如IO serialization 的办法直接保存到文件上，并能享有关系数据库系统提供的事务，并发，和高效的好处呢？ 设想一下，去掉了SQL解析和优化的开销，抛开了JDBC以及数据在客户端/服务器通信的巨大开销，应用的速度提升将会有多少？
JE正是居于这一设计思想而孕育出来的，是完全用 Java 设计，运行在应用程序的地址空间中，没有客户端/服务器通信的开销，从而使开发人员能够快速、简单、可靠地存储和检索信息。

主要特性

1. 轻松快速地数据存储
Berkeley DB Java 版可以轻松快速地存储数据，而不会导致像其他数据库中那么多的开销。Berkeley DB Java 版是与您的应用程序运行在同一 JVM 中的单个 JAR 文件，因此不需要远程服务器。本地缓存在内存中保存最活跃的数据以避免了开销较大的磁盘访问，并将 JVM 内存的使用限制到一个可预测的数量。

* 本地、进程间数据存储
* 与模式无关的、应用程序本机数据存储
* 按关键字访问的数据检索和顺据数据检索
* 易于使用的 Java 集合 API
* 用于访问 Java 对象的直接持久层 (DPL)
* DPL 类的模式进化
* 单进程、多线程模型
* 用于高并发性的记录级锁定
* 对辅助索引的支持
* 内存中和/或磁盘上
* 可配置的后台清理器线程重新组织数据并优化磁盘使用

2. 可靠地事务处理能力
Berkeley DB Java 版可靠地存储数据并确保数据完整性。如果系统发生故障，Berkeley DB Java 版将恢复事务数据并根据日志和数据库信息将系统重置为可运行的、一致的状态。

* 完全符合 ACID
* 可选择的隔离级别和持久性保证，可在每事务基础上进行配置
* 使用 Java 事务 API (JTA) 托管的事务
* 使用 J2EE 连接器体系结构 (JCA) 进行 J2EE 应用服务器集成
* 使用 Java 管理扩展 (JMX) 进行审计、监视和管理
* 灾难和例程故障恢复模式
* 基于超时的死锁检测
* 冷热备份、日志文件压缩和完整的数据库转储

3. 易于部署
Berkeley DB Java 版是高度可移植的、非常灵活且易于集成。它从一开始就被设计为一个充分利用 Java 环境的纯 Java 产品。作为单个 Java 存档 (JAR) 文件，它在运行您应用程序的 JVM 中运行。Berkeley DB Java 版旨在通过企业级、纯 Java 的数据存储解决方案为不断增长的大型 Java 社区提供服务。

* 100% 的纯 Java，便于移植且易于开发
* 单个 JAR 文件 – 易于安装，与应用程序运行在相同的 JVM 上
* 需要 Java 1.4.2 或更高的标准版 JVM
* 编程管理
* 无需人为管理
* 针对例行管理功能的 API
* 体积小 820KB
* 可扩展到数以 TB 计的数据，数百万条记录
* 包含源代码、测试套件

性能比较：JE vs Derby

正如一份关于JE和Derby的性能比较的Oracle白皮书(http://www.oracle.com/technology/products/berkeley-db/pdf/je-derby-performance.pdf)展示的那样： 在相同的硬件平台，JE只使用了相当于Derby一半的内存却达到了近乎于数量级的性能提升！

尾记

Oracle Berkeley DB Java 版的体系结构对于读密集型和写密集型的工作负载支持非常高的性能和并发性。有鉴于其良好的伸缩性，和易于部署性，JE成功应用到上至全球型的电子商务网站，下至终端设备。同时，由于其开源和双重licence特性，对于广大Java爱好者和数据库工程人员而言也是不可多得的参考宝典。

—
黄超