本文将分别介绍Oracle Berkeley DB四大产品线的特点以及应用，希望能对中国市场的新老用户有所启发和帮助。

1. Oracle Berkeley DB数据库产品系列

（图一）

Oracle Berkeley DB 产品家族目前有三大数据库产品，分别是：Berkeley DB，Berkeley DB XML 和 Berkeley DB Java Edition。它们的关系和系统架构可以参照图一。下面我将分别进行介绍。

1.1 Berkeley DB

Berkeley DB 也称 Core（下文都以此简称），是Berkeley DB家族第一个发布的产品。Core的核心代码全部由C语言写成，同时提供其他多种语言的应用程序接口（包括 C++, C#,  Java, Perl, Python, PHP, Tcl, Ruby等等）。Core有以下一些特点（请大家注意，下面列举的大部分特点其实是Berkeley DB家族所有产品的共同特点）：

• 基于Key/Value的存储：对于Core以及Berkeley DB其他产品来说，用户可以任意定义所存储数据的键（key）以及对应的值（value），这样的数据存储方式具有很好的灵活性和多样性。也是由于这个特点，Berkeley DB产品家族被业界归为非关系型（non-relational）数据库。
• 嵌入式数据管理：这里的嵌入式跟大家平时提到的嵌入式有点不一样。这里的嵌入式的意思是指，Core是作为库（library）的形式直接嵌入到用户的应用程序当中，和用户程序运行到同一地址空间，用户选择适当的API进行编程调用。这样“嵌入式”的最大好处就是不需要人为进行管理（即不需要专门的DBA），并可以大大提高程序开发的周期，和降低程序后期的维护成本。
• 体积(footprint)小：由于Core是直接嵌入应用程序当中，所以产品的体积必须越小越好。目前，Core的体积只有1M左右，这意味着，即使对于移动设备（如手机）来说，Core也可以十分轻松嵌入到你的程序中。
• 几乎具备数据库的所有功能和特性：对于这么小体积的数据库，你也许会问，Core会不会丧失很多数据库的特性呢。恰恰相反，在保持小体积的优势下，Berkeley DB几乎具备数据库的所有特性，包括：ACID，事务性（transaction），错误恢复（failure recover），高并发性（high concurrency）等等。
• 高可用性（high availability，简称HA)：高可用性一方面可以提高数据读取性能，另一方面是具备自动错误恢复（automatic failover）功能，使数据存储更加安全可靠。
• 高性能：Core拥有极高的数据存取性能，并且用户可以根据机器的配置进行调优。具体性能测试可以参考文档 Oracle Berkeley DB:Performance Metrics and Benchmarks。

尤其需要指出的是：最新版本的Oracle Berkeley DB（11gR2）的一个引人瞩目的特性就是我们引入了对SQL 92标准的支持（见图一红色圆圈部分）。Oracle Berkeley DB SQL接口完全兼容SQLite原有的编程接口， 从而以往运行在SQLite上的程序和应用都可以无缝的、方便的迁移到Oracle Berkeley DB这个更加强大的存储引擎。并且，Oracle Berkeley DB和SQLite还将进行长期的官方层面的合作，保证了Oracle Berkeley DB的SQL接口和SQLite保持一致，免除了用户的后顾之忧。此外，Berkeley DB SQL接口完美支持很多第三方的SQLite工具，如JDBC，ODBC，FireFox 3及其SQLite Manager 插件等。更多有关DBSQL的技术细节，可以参考本站另外一篇博客《Oracle Berkeley DB 支持SQL啦》。

也许有人会问：何时该选用BDB的Key/Value的选项，何时该选用BDB的SQL接口呢？

• 简单的来理解，BDB的Key/Value的选项是一个本地持久化的“HashTable”，可以存取任何数据类型（声音、视频、图像、Java对象等），通过简单的put/get/delete接口来操作。简单的数据访问方式、不需要太多复杂的统计和分析计算的场合都可以使用。比如，微博客的底层数据管理；如果再和hadoop集成后，还可以做一些复杂的分析功能。

• 当使用场合需要轻量级的数据库、有SQL支持、要求高性能和高并发；或者需要和企业端的Oracle 数据库（如Oracle 11g）进行双向的数据同步时，建议可选用Oracle Berkeley DB的SQL接口。举例来说，手持设备/平台上（如Android，Windows Mobile、iPhone等）。

更多关于Core的信息，可以参考下面相关链接：

• Core下载
• Core相关文档
• Core FAQ （可以在此找到常见问题答案）
• Core官方论坛 （在此论坛提出技术问题，会得到Berkeley DB组资深工程师的回答，当然，提问必须是英文。）
• Core HA官方论坛

1.2 Berkeley DB XML

Berkeley DB XML是基于Core数据存取之上，专门用于存取XML文档的数据库（如图一所示），简而言之，Berkeley DB XML以Core作为存储引擎，在此基础上建立对XML文档进行管理、索引和查询优化模块，并提供相应的XML 标准的API。因为Berkeley DB XML建立在Core之上，所以除了具备Core的大部分特点之外，还有以下针对XML文档的一些特点：

• 支持XQuery 1.0 and XPath 2.0。
• 十分灵活的索引功能：Berkeley DB XML支持节点（node），element（元素），attribute（属性）和元数据（meta-data）索引。这样灵活的索引可以极大提高查找性能，特别是针对存取较大的XML文件。
• 支持对XML文档的修改

更多关于Berkeley DB XML的信息，可以参考下面相关链接：

• Berkeley DB XML下载
• Berkeley DB XML相关文档
• Berkeley DB XML FAQ
• Berkeley DB XML官方论坛

1.3 Berkeley DB Java Edition

Berkeley DB Java Edition（以下简称JE）是Berkeley DB产品家族另外一个独立的产品，也就是说，它并不像BDB XML一样基于BDB Core。JE 除了具备上述 Core 的特点（K/V存储、体积小、性能高以及高可用性（HA）等等）之外，还有以下特色：

• 纯java，简单易用：JE 是纯java语言编写的，意味着JE可以无缝运行于任何java环境。用户只需要在应用程序中包含JE的jar文件，便可调用JE的API进行编程，无需任何额外配置工作。
• 更高的并发性，更高的性能：相对于Core，由于JE提供基于“记录”级别（record level，一条记录由Key和Value组成）的锁，所以JE拥有更高的并发性以及更高的读写性能。关于JE的性能测试，可以参考文档：
  • Oracle Berkeley DB Java Edition vs. Apache Derby: A Performance Comparison
  • Oracle Berkeley DB Java Edition High Availability -Large Configuration and Scalability Testing
• Java对象存储：JE 利用直接持久层（Direct Persistence Layer，DPL) 可以十分方便、灵活、快速存取用户定义的任意java对象。可参考文档Direct Persistence Layer for Berkeley DB Java Edition。
• 适用于J2EE：JE 提供对Java Transaction API (JTA), J2EE Connector Architecture (JCA) 和 Java Management Extensions (JMX)的支持。

更多关于JE的信息，可以参考下面相关链接：

• JE下载
• JE相关文档
• JE FAQ
• JE官方论坛

1.4 应用举例

概括而言，你需要一个数据存取的产品，并要满足：

• 性能要求高，相应时间短、占用资源少的场合
• 方便管理，不需要DBA
• 数据访问方式是简单的，任何类型的数据
• 运行于普通硬件平台，随着业务增长可以水平扩展
• 高可用集群和容错备份

可能的应用场景包括：

• 搜索及内容管理
• 缓存及日志模块
• SOA及Web Service的相关模块
• 资源、系统或者仪器管理
• 存储设备
• 网关、网络设备、网络计费系统等
• 消息队列、工作流等系统
• 授权及身份管理
• 仪器、终端和手持设备

举例而言：

1. 某全球知名电子商务公司，选择Core作为中间层的静态数据缓存。当用户浏览产品页面的时候，所有的产品信息、价格、用户评价等等数据都是先从Core进行读取。这样可以大大提高页面的显示时间，从而增进用户购物体验。同时还利用Core来管理购物车和交易结算等。
2. 某全球著名互联网公司，利用Core HA存取数亿用户的账户信息。Core HA的高性能、高并发性和高可用性满足了此互联网公司对用户登录功能的苛刻要求，包括极短的登录请求响应时间，24×7的无间断服务，高达十亿级别的扩展性，以及极高的可靠性。
3. 比如某知名手机公司推出的智能手机选择Berkeley DB SQL作为其底层数据库。某知名POS机厂商也选择 Berkeley DB SQL接口作为新推出的某款POS机的存储引擎。
4. 某全球连锁酒店选择Berkeley DB XML来实现在线预定和销售系统。
5. 某大型跨国企业选择Berkeley DB XML里进行资产和仪器管理。
6. 很多全球型的金融公司的交易系统和底层基础架构的数据存取模块中选择Berkeley DB及Berkeley DB JE。
7. 军方的战场实施动态监控系统选择Berkeley DB JE。
8. 若干全球知名的社交网站中选择Berkeley DB JE构建上千个节点的云计算方案。
9. 某全球知名的网络服务商的视频点播、短信/邮件、视频电话等系统中。

2. Oracle Berkeley DB 11gR2 + Mobile Server

（图二）

Oracle Berkeley DB 11gR2 + Mobile Server 可以提供移动数据同步解决方案。Oracle Mobile Sync Server（以下简称为Mobile Server）是一个提供企业级移动解决方案的中间层（middle-tier infrastructure）。它的一端连接的是客户端数据库，另外一端连接的是Oracle数据库。Mobile Server主要提供以下功能：

1. 应用程序统一部署和配置。比如，应用Mobile Server方案的移动设备都可以自动实现软件的安装、更新和打补丁等等配置，这一过程不需要用户的过多参与。
2. 移动设备统一管理。管理员可以远程收集众多移动设备的信息，同时也可以进行统一的操作与部署。比如，管理员可以远程向丢失的移动设备进行额外加密或者销毁设备中的数据。
3. 移动设备与Oracle数据库的数据双向同步。与Oracle数据库的同步功能可以保持移动设备的完整性和及时性，并且不要求移动设备时刻与Oracle数据库保持连接。

在Oracle Berkeley DB 11gR2之前，Mobile Server支持的客户端数据库是Oracle Database Lite Client。往后Oracle Berkeley DB 11gR2 会是Mobile Server客户端数据库的推荐选择，而原来的Oracle Database Lite Client将停止新功能开发。因为Berkeley DB 11gR2安装更加简单，性能更加优越，并且体积更小。Berkeley DB 11gR2 + Mobile Server的总体架构图如图二所示。

Oracle Mobile Server 的应用举例：

1. 某国的海岸卫队的舰船上的数据同步和设备管理。
2. 某大型的博彩机构的手机订单系统。
3. 某国海关的缉私等设备上。
4. 某大型快速消费品公司的自动售货机上。

更多关于Oracle Mobile Sync Server的信息，可以参考下面相关链接：

• Oracle Database Lite 10g
• Oracle Database Lite Mobile Server 10g

这些年来，随着大量数据的产生，数据可视化（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/

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的英文原文。

校园宣讲会初步日程（注意：日期及时间请以51job和校园广告为准）：

• Oct. 19th Shanghai Tongji Univ. (19:00-21:00)
• Oct. 20th Shenzhen HIT Graduate School (19:00-21:00)
• Oct. 21th Guangzhou Southern China Univ. of Tech. (15:00-17:00)
• Oct. 26th Beijing Tsinghua Univ. (19:00-21:00)
• Oct. 27th Wuhan Huazhong Univ. of Science and Tech. (19:00-21:00)
• Oct. 30th Hangzhou Zhejing Univ. (19:00-21:00)
• Nov. 2nd Suzhou Suzhou Univ. (14:00-16:00)
• Nov. 4th Nanjing Southest Univ.(19:00-21:00)
• Nov. 5th Dalian Dalian Univ. of Tech. (19:00-21:00)

更新！！原计划于Nov. 6th的在线测试，因后台录入部分同学的纸质简历而推迟。新的时间安排：HR给的反馈是定在本周（Nov. 9th这周末或者周末以前），请大家留意Email通知并谅解。

注: BDB的招聘行程（此项会持续更新，期待届时与你见面交流）：

• Chao Huang – 校园宣讲，Oct. 19th Shanghai Tongji Univ. (19:00-21:00)
• Eric Wang – 校园宣讲，Oct. 20th Shenzhen HIT Graduate School (19:00-21:00)

今年Oracle会组织在多个城市进行面试，BDB初步决定参加下面4个。各位面试同学的时间地点请以电话通知为准。

• Eric Wang – 面试官，Nov. 17-18，深圳
• Linchun Sun – 面试官，Nov. 19-20，广州
• Chao Huang – 面试官，Nov. 25-27，北京
• Chao Huang – 面试官，Nov. 24-25，上海

此次研讨会包括两大部分，第一部分由Chao Huang就甲骨文公司的数据库产品在嵌入式领域的应用做专题的演讲。Chao Huang分别介绍了Oracle Database，TimesTen，Berkeley DB和Oracle Lite的技术特点，并对每一个产品给予了详细的应用案例分析。最后，Chao Huang通过对每个产品特点的比较和优势的说明，列举了不同产品的应用场景，令客户能结合自身的需求做出正确的选择。

研讨会的第二部分由Ashok Joshi详细介绍Oracle Berkeley DB的技术。在这一部分的演讲中，Ashok Joshi生动地与观众分享了Oracle Berkeley DB家族的三大产品：Berkeley DB Core，Berkeley DB JE 和 Berkeley DB XML，并对其中的关键技术做了简单明了的介绍。结合Berkeley DB的技术特点，Ashok Joshi同样给出了典型的应用案例，包括Amazon，Google等等。这些案例均让客户们更深入更客观地了解了Berkeley DB的技术优势和应用场景。

会后，Ashok Joshi和Chao Huang还耐心回答了香港科大的学生们关于加入Berkeley DB team的诸多问题，包括Berkeley DB team在全球的研发力量，Berkeley DB team在深圳的研发情况，以及一些招聘的流程。在这一过程中，学生们表现出强烈的想加入Berkeley DB team的热情。我们也希望，今年能在港科找到最适合我们Berkeley DB team的优秀人才。

趁着这次研讨会的机会，Ashok Joshi和Chao Huang还抽空拜访了香港科技大学计算机系的几位教授，探讨潜在的合作机会。教授们都对Berkeley DB产生浓厚的兴趣，希望将来能在Berkeley DB上开展一些研究课题，包括数据库方面和信息可视化方面。

这次研讨会取得了较大的成功。一方面，我们很好地向客户和在校的大学生推广了甲骨文嵌入式数据库技术，特别是Berkeley DB产品，另一方面，我们和香港科学技术大学建立了良好的关系。我们期待明年的技术研讨会能吸引更多的客户、教授与学生的参与，期待Berkeley DB能得到更广泛的推广和应用。

如果有进一步的反馈，或需要了解更多，请联系 haomian.wang at oracle dot com 。