Android默认提供的数据库功能是SQLite。Berkeley DBSQL完全兼容SQLite API，可以直接替换SQLite库而无需改动现有的应用程序或服务。依本方法编译得到的Berkeley DBSQL库将完全替换Android的SQLite库(drop-in模式)。在这种模式下，Android平台上所有的应用程序(包括我们自己编译的应用程序)都将链接到Berkeley DBSQL库以获取更高的存储和并发性能。

完整原文：http://download.oracle.com/docs/cd/E17076_02/html/installation/build_android_intro.html

中文介绍：

Android编译过程

本节提供了Berkeley DB Drop-in方式的Android编译指令。

首先要下载并且编译Android源代码树。
第一次编译过程需要花费较长一段时间，不过后面再编译就快多了。可以从这里下载Android的源代码并且按照Android文档完成编译过程。

把Berkeley DB代码目录拷到Android的代码目录里面：

$ cd ${root}/external/sqlite/dist
$ tar zxvf db-xx.tar.gz

这里的${root}指的是Android源代码树的根路径。

通过以下命令将源代码树中默认的Android.mk文件替换成Berkeley DB的版本：

$ cd ${root}/external/sqlite/dist
$ mv Android.mk Android.mk.sqlite
$ cp db-xx/build_android/Android.mk ./

提示：编译之前，可通过这里查看Android平台上的几种调优参数。

重新编译数据库部分，这样Berkeley DB就替换到最终生成的系统镜像了：

$ cd ${root}
$ . build/envsetup.sh
$ make clean-libsqlite
$ mmm -B external/sqlite/dist
$ make snod

以上指令完成后，新的基于Berkeley DB SQL的Android系统镜像即编译完毕。系统会打印出新的镜像所在目录，一般来说这个目录是：${root}/out/target/product/generic。

从SQLite迁移到Berkeley DB

如果你需要使DBSQL能够自动打开并转换现有的SQLite数据库文件，请参照本节的步骤。

首先，我们需要通过以下脚本来为Android平台编译一个静态的SQLite shell, 这个shell对自动转换功能而言是必需的。

#!/bin/bash
# This script shows how to use built-in toolchain to build
# sqlite3 shell, which is required by Berkeley DB SQL
# on-the-fly migration feature.

# Note: these variables should be set per active Android source tree
# We assume $PWD=$ROOT/external/sqlite/dist
ROOT=${PWD}/../../..
TOOLCHAIN=${ROOT}/prebuilt/linux-x86/toolchain/arm-eabi-4.4.0
CC=${TOOLCHAIN}/bin/arm-eabi-gcc
LIB="${ROOT}/out/target/product/generic/obj/lib"
INCLUDE="${ROOT}/ndk/build/platforms/android-8/arch-arm/usr/include"

# CFLAGS should be set per Android.mk.sqlite (the original
# version of SQLite's Android.mk)
CFLAGS="-DHAVE_USLEEP=1 -DSQLITE_THREADSAFE=1 -DNDEBUG=1 \
 -DSQLITE_DEFAULT_JOURNAL_SIZE_LIMIT=1048576 \
 -DSQLITE_ENABLE_MEMORY_MANAGEMENT=1 \
 -DSQLITE_DEFAULT_AUTOVACUUM=1 \
 -DSQLITE_TEMP_STORE=3 -DSQLITE_ENABLE_FTS3 \
 -DSQLITE_ENABLE_FTS3_BACKWARDS -DTHREADSAFE=1"
CFLAGS="${CFLAGS} -I${INCLUDE}"

LDFLAGS="-ldl -nostdlib -Wl,--gc-sections -lc -llog -lgcc \
 -Wl,--no-undefined,-z,nocopyreloc ${LIB}/crtend_android.o \
 ${LIB}/crtbegin_dynamic.o -L${LIB} -Wl,-rpath,${LIB}"

${CC} -DANDROID -DOS_ANDROID --sysroot="${SYSROOT}" -mandroid \
      -fvisibility=hidden -ffunction-sections -fdata-sections \
      -fPIC ${LDFLAGS} ${CFLAGS} \
      sqlite3.c shell.c -o sqlite3orig

提示：你可能需要根据当前环境来修改以上环境变量。

运行以上脚本，成功的话我们就得到了一个静态的sqlite3 shell工具 – sqlite3orig

接下来我们需要修改系统image文件。首先用xyaffs2工具解压镜像文件

$ xyaffs2 ./system.img system

把编译好的sqlite3工具拷进去。

$ cp ${root}/external/sqlite/dist/sqlite3orig system/xbin/sqlite3orig

使用mkyaffs2image工具来重新生成system.img.

$ mkyaffs2image -f $PWD/system system.img

这样，修改好的系统镜像即可自动转换并打开现成的SQLite3数据库文件。需要注意的是：在adb shell模式下，打开sqlite3数据库的命令是sqlite3orig；而打开Berkeley DBSQL数据库的命令是sqlite3。

结束语

以上介绍了DBSQL Android平台上Drop-in模式的编译使用过程。如果你在使用过程中有任何问题，欢迎和我交流！

BDB Blog：http://www.bdbchina.com
BDB微博：http://weibo.com/bdbchina
个人微博：http://weibo.com/2153755234

本文将展示如何在Ubuntu Linux x32平台上使用完整的Android源代码来编译构建我们的全新Android系统镜像，而Android源代码包中包含了交叉编译器，因此我们不需要事先安装NDK。

1. 编译Android代码

从Android官方网站获取一份Android源代码，这份源代码有2~3G之巨。

在Linux平台上，把源代码解压到$HOME/android/android_src

安装java 1.5版本，(1.6不行)，并设置JAVA_HOME和PATH:

$ export JAVA_HOME=/usr/lib/jvm/java-1.5.0-sun
$ export PATH=$JAVA_HOME/bin:$PATH

先把原始的Android代码完全编译成功(这过程可能要花2~3小时)：

$ cd $HOME/android/android_src
$ . build/envsetup.sh
$ make

可看到生成三个镜像：

Install system fs image: out/target/product/generic/system.img
Target ram disk: out/target/product/generic/ramdisk.img
Target userdata fs image: out/target/product/generic/userdata.img

2. 安装Android SDK并测试镜像

安装Android SDK: http://developer.android.com/sdk/installing.html, 安装目录：$HOME/android/android-sdk-linux_86
安装Android SDK组件: http://developer.android.com/sdk/adding-components.html,选择安装SDK Platform Android 2.1 API 7和Google APIs by Google Inc., Android API 7

用我们编译得到的镜像替换系统的默认镜像。如果需要替换Windows环境下的sdk，那么以下目录”android-sdk-linux_86″相应应该改成 “android-sdk-windows”。

$ cd $HOME/android/android-sdk-linux_86/platforms/android-2.1
$ cp -r images images.bak
$ cp $HOME/android/android_src/out/target/product/generic/*.img images

创建并运行一个新的设备:

$ cd $HOME/android/android-sdk-linux_86/tools/
$ ./android

(如图)使用图形界面工具创建一个Android 2.1的设备BDBSQL,并点击”start”启动。新的设备第一次启动的时间会非常长，这是正常现象。等到Android界面出现，就说明我们的镜像编译基本没问题了。接下来我们进一步把SQLite库替换为BDB。

3. 编译DBSQL

从http://www.oracle.com/technology/software/products/berkeley-db/index.html下载BDB 11gR2源文件(db-5.0.x.tar.gz)，然后

$ cd $HOME/android/android_src/external/sqlite/dist
$ tar zxvf db-5.0.x.tar.gz
$ cp Android.mk Android.mk.bak
$ cp db-5.0.x/build_android/Android.mk .

编辑Android.mk，默认的BDB Log和Region文件大小总和可达到十几兆，因此我们有必要修改Android.mk来减小它(可能需要为Android.mk去掉只读属性)。修改第一处LOCAL_CFLAGS如下所示(相对于默认配置，我们删除了-DSQLITE_OMIT_TRUNCATE_OPTIMIZATION，新增了-DSQLITE_DEFAULT_CACHE_SIZE=256 -DBDBSQL_MAX_LOCKS=1000 -DBDBSQL_MAX_LOCK_OBJECTS=1000)：

LOCAL_CFLAGS += -Wall -DHAVE_USLEEP=1 \
        -DSQLITE_DEFAULT_JOURNAL_SIZE_LIMIT=1048576 \
        -DSQLITE_THREADSAFE=1 -DNDEBUG=1 -DSQLITE_TEMP_STORE=3 \
        -DSQLITE_OS_UNIX=1 \
        -D_HAVE_SQLITE_CONFIG_H -DSQLITE_THREAD_OVERRIDE_LOCK=-1 \
        -DSQLITE_ENABLE_FTS3 -DSQLITE_ENABLE_FTS3_BACKWARDS -Dfdatasync=fsync \
        -DSQLITE_DEFAULT_CACHE_SIZE=256 \
        -DBDBSQL_MAX_LOCKS=1000 \
        -DBDBSQL_MAX_LOCK_OBJECTS=1000

如果确定不会在多进程间共享数据库，还可以在上述LOCAL_CFLAGS中加入”-DBDBSQL_OMIT_SHARING”，这样日志文件不会被写入文件系统，进一步节省了设备空间。

编译系统镜像中的SQLite部分:

$ cd $HOME/android/android_src
$ . build/envsetup.sh
$ make clean-libsqlite
$ mmm -B external/sqlite/dist
$ make snod

编译好了，再来一次镜像替换：

$ cp $HOME/android/android_src/out/target/product/generic/*.img $HOME/android/android-sdk-linux_86/platforms/android-2.1/images

使用图形界面工具删除先前的设备BDBSQL，重创建一个新的Android 2.1设备BDBSQL,并点击”start”启动。这里一定要创建新的设备，因为启动过的设备，其数据库文件已被SQLite生成，DBSQL无法访问。

4. 使用DBSQL

现在Android里所有应用程序的SQL存储引擎都已被替换为DBSQL了。我们使用”联系人”来试用一下我们的新设备吧，在Setting里面把Locate设置为中文简体，安装一个中文输入法(比如搜狗)，然后打开“联系人”，随便增加一条记录：

在主机上我们可以使用adb shell来查看并操作程序所生成的数据库。请留意sqlite3 shell输出的版本信息是Berkeley DB 11gR，同时shell的提示符是dbsql>，这说明我们已经把SQLite成功替换为DBSQL引擎：

$ adb shell
# cd /data/data/com.android.providers.contacts/databases/
# sqlite3 contacts2.db
Berkeley DB 11g Release 2, library version 11.2.5.0.21: (March 30, 2010)
Enter ".help" for instructions
Enter SQL statements terminated with a ";"
dbsql> .tables
_sync_state                       status_updates
_sync_state_metadata              v1_settings
activities                        view_contacts
agg_exceptions                    view_contacts_restricted
android_metadata                  view_data
calls                             view_data_restricted
contact_entities_view             view_groups
contact_entities_view_restricted  view_raw_contacts
contacts                          view_raw_contacts_restricted
data                              view_v1_contact_methods
groups                            view_v1_extensions
mimetypes                         view_v1_group_membership
name_lookup                       view_v1_groups
nickname_lookup                   view_v1_organizations
packages                          view_v1_people
phone_lookup                      view_v1_phones
raw_contacts                      view_v1_photos
settings
dbsql> select * from contacts;
2|逍遥 李|||0|0|0|0|1|1|0nE08B4A8BFA37D4||0
dbsql> select * from data;
1||4|1|0|0|0|li|li|||||||||||||||||
2||6|2|0|0|0|66666666|1||66666666|||||||||||||||
3||6|2|0|0|0|88888888|2||88888888|||||||||||||||
4||8|2|0|0|0|蜀山|1|||||||||||||||||
5||4|2|0|0|0|逍遥 李|逍遥|李||||||||||||||||
dbsql>

5. 结束语

关于DBSQL库在Android平台上的编译和使用的介绍到这里就结束了。我们用两篇博文分别介绍了side-by-side(并存)和Drop-in(替换)这两种使用方式。在Drop-in模式下，现有的应用程序无修改就可以直接使用DBSQL引擎。

DBSQL在开发过程中始终给予Android平台高度重视，在开发过程中投入了多位资深工程师致力于将DBSQL移植到Android平台上，并将Android列为产品周期测试的主流平台。OARDC的工程师Zengfa.Dou和Stephen.Tang给予了我这个初学者极大帮助。在此一并致谢！

本文介绍在Linux平台上如何编译得到适用于Android的DBSQL库，依本文方法编译得到的BDB库将和Android自带的SQLite库并存，我们称其为side-by-side(并存)模式。在这种模式下，Android平台上已有的应用程序还是基于原始的SQLite库，而我们自己编译的应用程序则链接到DBSQL库以获取更高的存储和并发性能。

1. 安装开发环境

(本文假定读者已具备初步的Android Emulator使用经验)
安装SDK
从http://developer.android.com/sdk/index.html下载Android SDK并解压缩得到$HOME/android/android-sdk-linux_86/目录。

安装NDK
从http://developer.android.com/intl/zh-TW/sdk/ndk/index.html下载Linux版Android NDK(android-ndk-r3-linux-x86.zip)并解压缩得到$HOME/android/android-ndk-1.6_r3/目录。

$ cd android-ndk-1.6_r3
$ build/host-setup.sh

安装NDK Wapper
从开心网共享文件夹下载ndk-wrappers.tgz到$HOME/android

$ tar zxvf ndk-wrappers.tgz

ndk-wrapper需要以下变量，因此我们需要把以下变量增加到$HOME/.bashrc并使之生效：

export PATH=$HOME/android/ndk-wrappers/bin:$PATH
$ export NDK_DIR=$HOME/android/android-ndk-1.6_r3
$ export PATH=$HOME/android/android-sdk-linux_86/tools:$PATH
$ . $HOME/.bashrc

(NDK-Wrapper默认使用arm-eabi-gcc 4.2.1, 如果你想使用ndk里面的arm-eabi-gcc 4.4.0，把scripts/env-utils.sh 和setup.sh里面的4.2.1改为4.4.0)

开始安装ndk-wrapper：

$ cd ndk-wrappers
$ ./setup.sh

修改Ndk-Wrapper
修改ndk-wrappers/bin/arm-linux-gcc:

1. 在LINK_FLAGS中增加"-ldl"
2. 删除-fvisibility=hidden

试验Ndk-Wrapper是否可工作

$ arm-linux-gcc --version
arm-eabi-gcc (GCC) 4.4.0
Copyright (C) 2009 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

2. 编译DBSQL

以下我们使用上面搭建的NDK编译环境来编译适用于Android平台上的DBSQL库。首先从Oracle官网上下载Berkeley DB 11gR2(.tar.gz), 解压并改名为db/

设置CFLAGS

$ export CFLAGS="-DHAVE_USLEEP=1 -DSQLITE_DEFAULT_JOURNAL_SIZE_LIMIT=1048576 \
-DNDEBUG=1 -DSQLITE_TEMP_STORE=3 -DSQLITE_OS_UNIX=1 -D_HAVE_SQLITE_CONFIG_H \
-DSQLITE_THREAD_OVERRIDE_LOCK=-1 -Dfdatasync=fsync -DNO_ANDROID_FUNCS \
-DSQLITE_THREADSAFE=1"

设置为动态编译方式

$ cd db/build_unix
$ ../dist/configure --prefix=$HOME/android/install_db_arm --target=arm-linux \
--host=arm-linux --enable-smallbuild --enable-sql --enable-sql_compat \
--enable-statistics --enable-amalgamation

修改build_unix/db_config.h
每次configure完成后，切记都要编辑build_unix/db_config.h，删除以下两行：

#define HAVE_PREAD 1
#define HAVE_PWRITE 1

开始编译

$ make dbsql

生成的动态库文件为.libs/libdb_sql-5.0.so，Shell文件为.libs/dbsql。

3. 使用DBSQL库

我们使用现成的DBSQL范例来演示如何在自己的程序中使用DBSQL库

编译范例

$ cd  build_unix
$ make ex_sql_query

编译完成后生成范例程序.libs/ex_sql_query /data/bdb

运行范例
启动Android Emulator，上传，并运行DBSQL库和范例

$ adb shell mkdir /data/bdb
$ adb shell mkdir /data/sql/examples/data
$ adb shell mkdir /data/sql
$ adb shell mkdir /data/sql/examples
$ adb shell mkdir /data/sql/examples/data
$ adb push .libs/libdb_sql-5.0.so /data/bdb
$ adb push .libs/ex_sql_query /data/bdb
$ adb push ../sql/examples/data/ /data/sql/examples/data
$ adb shell "cd /data/bdb; export LD_LIBRARY_PATH=/data/bdb; ./ex_sql_query"

现在终端应该已经输出query范例的运行结果了。以下是GUI终端的输出截图：

4. 结束语

至此，关于BDB 11gR2 SQL库的side-by-side编译模式的介绍就结束了。我们可将编译得到的库应用到自己的程序中去。side-by-side模式的优点不改动Android系统底层库和镜像，使用简单。缺点是只能用C/JNI方式调用，无法用Android自带的SQL接口直接调用。而与此对应的是Drop-in模式，Drop-in模式可将Android系统的SQLite层整个替换为BDB 11gR2 SQL，应用程序无修改就可以直接使用，是一种更为强大彻底的应用模式。我们将在后续文章中介绍Drop-in模式的编译方式。

See the details at Charles Lamb’s blog at http://blogs.oracle.com/charlesLamb/2010/02/berkeley_db_java_edition_andro.html .

原文地址： http://www.oracle.com/technology/products/berkeley-db/pdf/bdb-je-android.pdf .

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