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

char *key_buf, *data_buf;
void *p;
int j;

/* Initialize structs and arrays */
memset(raw_key, 0, KEY_SIZE);
memset(raw_data, 0, DATA_SIZE);
memset(&key, 0, sizeof(DBT));
memset(&data, 0, sizeof(DBT));
tid = NULL;

/* Initialize bulk insertion buffers */
key_buf = malloc(KEY_SIZE * bulk_size * 2);
data_buf = malloc(DATA_SIZE * bulk_size * 2);
memset(key_buf, 0, KEY_SIZE * bulk_size * 2);
memset(data_buf, 0, DATA_SIZE * bulk_size * 2);

/*
* 初始化Bulk buffer.使用批量操作(bulk operations) 也就是
* 批量插入/删除/更新/读取的时候，必须使用用户提供的内存。
* 所以需要设置DBT对象的flags为DB_DBT_USERMEM，并且设置ulen成员而不是size成员。
*/
key.data = key_buf;
key.ulen = KEY_SIZE * bulk_size * 2;
key.flags = DB_DBT_USERMEM;
data.data = data_buf;
data.ulen = DATA_SIZE * bulk_size * 2;
data.flags = DB_DBT_USERMEM;

op_flag = DB_MULTIPLE;/* 这个flag给put/get/del 表示执行批量插入/更新/读取/删除。 */

/*
* 填充一个bulk buffer DBT 对象. 先调用DB_MULTIPLE_WRITE_INIT初始化该
* DBT。必须传入一个工作指针p和data buffer DBT 对象。
*/
DB_MULTIPLE_WRITE_INIT(p, &data);
for (i = 0; i < bulk_size; i++) {
/*
* 调用DB_MULTIPLE_WRITE_NEXT这个宏来向bulk buffer当中插入数据。
* 需要确保bulk buffer足够大，否则会出现内存访问越界错误。
*
* 各参数说明：
* p: 是这个宏内部使用的工作变量，由DB_MULTIPLE_WRITE_INIT初始化，并且必须在此处一直使用。
* data: 是data buffer DBT对象。
* raw_data: 是一个数据项所在的内存地址。你需要把你要装入的数据项传入这个参数。每个数据项
* 可以含有任意长度的字节，长度限制是一个DBT的总长度限制，也就是2的32次方。
* DATA_SIZE: 是本次宏调用的数据项长度。本例当中所有数据项长度相同，只是特例。完全可以
* 使用变长的数据项。
*
* 循环结束后填充完成，这个data buffer当中有bulk_size个data，
*/
DB_MULTIPLE_WRITE_NEXT(p, &data, raw_data, DATA_SIZE);
}

/*
* 批量插入insert_count条key/data pairs, 每一批插入bulk_size条key/data pairs.
* 本例当中我们只准备了一批数据，所以最终插入的数据是重复的，不过这不影响示例本身。
*/
for (i = 0; i < insert_count / bulk_size; ) {
/*
* 填充key buffer。填好后，这个key buffer当中有bulk_size个key，
* 并且第i个key与data buffer 当中的第i个data做为一对key/data pair
* 被插入数据库当中(i = 0, 1, 2, … bulk_size).
*/
DB_MULTIPLE_WRITE_INIT(p, &key);
for (j = i * bulk_size; j < (i + 1) * bulk_size; j++) {
raw_key[0] = insert_load[j];
/* 在循环当中使用DB_MULTIPLE_WRITE_NEXT依次插入每条data到data buffer当中。
* 循环结束后填充完成。*/
DB_MULTIPLE_WRITE_NEXT(p, &key, raw_key, KEY_SIZE);
}

/* 启动事务准备批量插入。 */
if ((ret = envp->txn_begin(envp, NULL, &tid, 0)) != 0) {
envp->err(envp, ret, “[insert] DB_ENV->txn_begin”);
exit(EXIT_FAILURE);
}

/*
* 执行批量插入。key和data DBT 对象分别是key buffer和data buffer,
* 其中必然含有相同书目的key和data items,key buffer当中的第i个
* key item与data buffer当中的第i个data item 作为一个Key/data pair
* 被插入数据库中。(i = 0, 1, 2, … bulk_size).
*/
switch(ret = dbp->put(dbp, tid, &key, &data, op_flag)) {
case 0: /* 批量插入操作成功，提交事务。*/
if ((ret = tid->commit(tid, 0)) != 0) {
envp->err(envp, ret, “[insert] DB_TXN->commit”);
exit(EXIT_FAILURE);
}
break;
case DB_LOCK_DEADLOCK:
/* 如果数据库操作发生死锁，那么必须abort事务。然后，可以选择重新执行该操作。*/
if ((ret = tid->abort(tid)) != 0) {
envp->err(envp, ret, “[insert] DB_TXN->abort”);
exit(EXIT_FAILURE);
}
continue;
default:
envp->err(envp, ret, “[insert] DB->put ([%d]%d)”, i, insert_load[i]);
exit(EXIT_FAILURE);
}

i++;
}

(void)free(key_buf);
(void)free(data_buf);

return (NULL);
}

/* 批量插入示例函数。*/
void *
run_bulk_delete()
{
int raw_key[NUM_KEY_INT];
DBT key;
DB_ENV *envp;
DB *dbp;
DB_TXN *tid;
int *delete_load;
int delete_count, id, i, ret, op_flag;
double tmp;

char *key_buf;
void *p;
int j;

/* Initialize structs and arrays */
memset(raw_key, 0, KEY_SIZE);
memset(&key, 0, sizeof(DBT));
tid = NULL;

/*
* 初始化批量删除使用的key buffer。由于批量删除不需要data，
* 所以只需要初始化和填充key buffer。我们同样需要使用自己分配的内存。
*/
key_buf = malloc(KEY_SIZE * bulk_size * 2);
memset(key_buf, 0, KEY_SIZE * bulk_size * 2);

/* 初始化key buffer DBT 对象，设置正确的flags和ulen成员。 */
key.data = key_buf;
key.ulen = KEY_SIZE * bulk_size * 2;
key.flags = DB_DBT_USERMEM;
op_flag = DB_MULTIPLE; /* 批量删除同样需要这个flag。*/

/*
* 批量删除所有的数据。每一批删除由key buffer DBT 当中的key
* 指定的bulk_size条key/data pair. 这两个宏的详细用法见上文。
*/
for (i = 0; i < delete_count / bulk_size; ) {
/* 为批量删除初始化并填充一个key buffer DBT 对象。 */
DB_MULTIPLE_WRITE_INIT(p, &key);
for (j = i * bulk_size; j < (i + 1) * bulk_size; j++) {
raw_key[0] = delete_load[j];
DB_MULTIPLE_WRITE_NEXT(p, &key, raw_key, KEY_SIZE);
}
/* 启动事务。*/
if ((ret = envp->txn_begin(envp, NULL, &tid, 0)) != 0) {
envp->err(envp, ret, “[delete] DB_ENV->txn_begin”);
exit(EXIT_FAILURE);
}

/*
* 执行批量删除。key buffer DBT
* 当中的bulk_size条key指定的key/data pairs会被从数据库当中删除。
*/
switch(ret = dbp->del(dbp, tid, &key, op_flag)) {
case 0: /* 批量删除操作成功，提交事务。*/
if ((ret = tid->commit(tid, 0)) != 0) {
envp->err(envp, ret, “[delete] DB_TXN->commit”);
exit(EXIT_FAILURE);
}
break;
case DB_LOCK_DEADLOCK:
/* 如果数据库操作发生死锁，那么必须abort事务。然后，可以选择重新执行该操作。*/
if ((ret = tid->abort(tid)) != 0) {
envp->err(envp, ret, “[delete] DB_TXN->abort”);
exit(EXIT_FAILURE);
}
continue;
default:
envp->err(envp, ret, “[delete] DB->del ([%d]%d)”, i, delete_load[i]);
exit(EXIT_FAILURE);
}
i++;
}

(void)free(key_buf);

return (NULL);
}

• The Berkeley DB Java Edition FAQ has useful tips and should be a first stop when trouble shooting problems.
• You can find product information, datasheets, and whitepapers on the JE home page on OTN.
• All JE release images are on the JE download page.
• The JE documentation page has Javadoc, Getting Started Guides and tutorials.
• Here is the JE License.
• Charles Lamb, a JE developer, blogs about usage tips, announcements, and developer anecdotes.
• There’s a whitepaper called Performing Queries in Oracle Berkeley DB Java Edition. The whitepaper takes common SQL queries and shows how to execute the same logic using the Direct Persistence Layer (DPL). The goal is to give users who are familiar with SQL some help in learning how to use the DPL.
• Chinese language JE blogs are available at www.bdbchina.com
• Application source code examples are included as part of the Berkeley DB JE distribution in the examples directory.

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 .

在这篇博客中，作者简要提到了最新的JE 4.0 发布的新特性 – Replication。简言之就是支持高可用或集群功能，并提供了软件和硬件层面的负载均衡。个人认为，JE 4.0的高可用功能绝对是任务密集型的、要求7×24小时高可用的J2EE应用项目中的利器啊。

最后，欢迎留言。

Oracle Berkeley DB在LinkedIn.com上的新建了一个群，供全球的相关人士（包括工程师、产品经理、客户等）共同讨论Berkeley DB的话题和业界动态。群地址：http://www.linkedin.com/groups?gid=2131985. 欢迎加入！

Oracle Berkeley DB 中国研发团队

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.