大 会 内 容

感

大会内容

感兴趣的主题将被包括在内，但不局限于此：

l        对象数据库研究

l        对象数据库与关系型技术、映射、 JPA 等的比较。

l        对象数据库在工业、案例研究（能源、生物、移动领域、汽车 … ）

l        对象数据库产品

l        对象数据库与性能

l        对象数据库与查询语言

l        对象数据库体系和模式

l        对象数据库在嵌入式系统中

l        对象数据库在高可用性和可变规模系统中

l        对象数据库的不同编程语言

l        对象数据库和标准（例如 odmg “ 4th generation ”）

l        对象数据库的培训

l        对象数据库实现

如果你能在以上的任何主题有所贡献，或任何其他相关主题，请与我联系。

最后，请参考本网站的 FAQ ，相关新闻在 这里 查阅，官方海报可以在 这里 浏览。

请注意！引用、转贴本文应注明原译者：RosenJiang 以及出处： http://www.blogjava.net/rosen

• 把位置信息登记到db4o（完整的地图持久化，包括缩放级别以及卫星交通视图）
• 浏览书签列表
• 编辑书签
• 从书签中导航到地图上某个位置
• 根据当前GPS所报告的位置居中显示地图

屏幕截图

想看应用程序是如何运作的，你可以观看在YouTube上的MapMe视频、从一个外部服务器下载高分辨率视频(30 Mb)或下面的屏幕截图：

db4o总部（卫星+交通视图）



MapMe主菜单：



建立书签/导航点(navpoint)：



保存的书签/导航点(navpoint)列表：



MapMe是如何运用db4o的

如果你查看源代码（下面有下载），你会发现DB helper类处理了所有的持久化操作（开启、存储、查询、计数数据库），而这一切都不超过80行代码！

这一切都很简单，而且不会丧失性能。让我们来看一些项目中用到的持久化方法。

开启数据库

开启数据库的确简单，并且在必要的时候还能自动生成数据库文件。一旦打开，db4o将锁定数据库文件。

注意，为MapBookmark对象建立的索引字段是“name”，并设置激活和更新级别。

保存书签

在这里我们调用一系列的操作，无论对象是否存在于数据库，对象都会被更新或插入。

在保存到数据库之前，我们设置好所有字段。

根据名字查询书签

我们通过Query by Example(QBE)传入一个原型来取回以名字为条件的书签。

QBE利用反射来检查原型对象的字段。

查询所有书签

这里我们把SODA查询结果拷贝到ArrayList中。但要注意，当使用Native Queries时你不必这样做（在这种情况下将直接返回List<MapBookmark>）。

删除书签

如果你的对象在db4o参考系统中存在，你可以轻松的调用delete()操作从数据库中删除它。

书签计数

要通过查询来进行对象计数，你只要询问查询结果的大小即可。

待完成

• 基于书签的查询功能（通过db4o查询）
• 支持手势识别(gesture recognition)（链接）
• 当前位置提示(Tweet current location)（链接）
• 把跟踪到的GPS位置接收到屏幕上并把GPS路线存储到数据库上（以便今后查看）
• 把位置发送给联系人（短消息、e-mail等）

下载

MapMe.Zip
YouTube上的MapMe视频
高分辨率视频(30 Mb)

请注意！引用、转贴本文应注明原译者：RosenJiang 以及出处：http://www.blogjava.net/rosen

在开源面向对象数据库 db4o 之旅 系列文章的第 1 部分：初识 db4o 中，作者介绍了 db4o 的历史和现状，应用领域，以及和 ORM 等的比较； 在第 2 部分：db4o 查询方式中, 作者介绍了 db4o 的三种不同的查询方式：QBE、SODA 以及 Native Queries，并分别通过这三种不同的途径实现了两个关联对象的查询。

前面我们已经介绍了如何在 db4o 中查询以及添加对象，在本文中我们将会向您介绍在 db4o 中如何对对象进行更新以及删除操作。
 

更新数据

场景一

我们来设想这样的场景：一位名叫“张三”的人买了车，并上好了牌照（如本系列第二部分之代码），而他基本信息的地址并不详细，只写了“成都市”，在一次主管部门检查此人信息的时候，发现了这个问题，并立即着手修改。

在 db4o 中，我们这样来实现对这个用户信息的修改（清单1）：

清单1. 修改地址

				
package com;

import bo.People;

import com.db4o.Db4o;
import com.db4o.ObjectContainer;
import com.db4o.ObjectSet;
import com.db4o.query.Predicate;

public class DB4OTest{
	
	public static void main(String[] args){
		//打开数据库
		ObjectContainer db = Db4o.openFile("auto.yap");
		try{
			ObjectSet<People> result = db.query(new Predicate<People>() {
			    public boolean match(People people) {
			        return people.getName().equals("张三");
			    }
			});
			People people = result.next();
			//修改地址
			people.setAddress("成都市金牛区xxx号");
			db.set(people);
		}finally{
			//关闭连接
			db.close();
		}
	}
}

修改数据是如此的简单，通过 NQ 查询出 People 对象，接着修改其地址，最后保存即可。现在我们来看看修改是否成功, 打开 ObjectManager ，如图 1 所示，我们可以看到数据库里的用户数据已经更新了。

图1. 修改地址

与本系列文章第二部分不同的是，我们利用 ObjectSet<People> result 来获取返回结果，而不是 List<People> list。查阅 ObjectSet 的 API 我们发现 ObjectSet 实际上继承了 java.util.List 和 java.util.Iterator。为什么要继承两个接口？这是由于 db4o 为了方便开发者而有意这样设计的，db4o 的设计目标就是轻量级，这样的继承方式为 ObjectSet 提供了多种特性，而无需开发者在多个集合接口之间转换。

场景二

让我们考虑下面这个场景:
由于工作原因，“张三”要离开省会去其他城市发展，他的汽车也要在那里使用，为了方便，他还是决定重新更换为本地牌照。

这次我们几乎和场景一采用同样的代码，但结果却不同（清单2）：

清单2. 修改地址和车牌（不成功）

				
package com;

import bo.People;

import com.db4o.Db4o;
import com.db4o.ObjectContainer;
import com.db4o.ObjectSet;
import com.db4o.query.Predicate;

public class DB4OTest{
	
	public static void main(String[] args){
		//打开数据库
		ObjectContainer db = Db4o.openFile("auto.yap");
		try{
			ObjectSet<People> result = db.query(new Predicate<People>() {
			    public boolean match(People people) {
			        return people.getName().equals("张三");
			    }
			});
			People people = result.next();
			//修改地址
			people.setAddress("绵阳市xx区xxx号");
			//修改车牌号
			people.getAutoInfoList().get(0).setLicensePlate("川B00000");
			db.set(people);
		}finally{
			//关闭连接
			db.close();
		}
	}
}

想必应该保存成功了吧，只是多加入了设置车牌的代码。打开 ObjectManager，如图 2 所示。很奇怪，地址保存成功了，而车牌却根本没变化。

图2. 修改地址和车牌（不成功）

其实这也是 db4o 的有意安排。设想一个复杂对象有很多成员，并且这些成员又有自己的成员。当更新该对象，db4o 将不得不更新其所有的关联对象、关联对象的关联对象，等等。这将引起严重的性能惩罚，而且在大部分的情况下是没有必要这样的。

db4o 引入了“更新深度(update depth)”这一概念来控制被更新的对象成员树深度。默认的更新深度是 1，这就意味着只有基本类型和 String 类型的成员变量可以被更新，而修改对象成员将得不到任何反映，例如本例中修改 People 对象的 _autoInfoList 成员。

为了能更新成员对象，ob4o 提供了 cascadeOnUpdate() 方法，该方法必须在每次开启数据库之前设置清单3：

清单3. 修改地址和车牌（成功）

				
package com;

import bo.People;

import com.db4o.Db4o;
import com.db4o.ObjectContainer;
import com.db4o.ObjectSet;
import com.db4o.query.Predicate;

public class DB4OTest{
	
	public static void main(String[] args){
        //级联设置
		Db4o.configure().objectClass("bo.People")
        .cascadeOnUpdate(true);
		//打开数据库
		ObjectContainer db = Db4o.openFile("auto.yap");
		try{
			ObjectSet<People> result = db.query(new Predicate<People>() {
			    public boolean match(People people) {
			        return people.getName().equals("张三");
			    }
			});
			People people = result.next();
			//修改地址
			people.setAddress("绵阳市xx区xxx号");
			//修改车牌号
			people.getAutoInfoList().get(0).setLicensePlate("川B00000");
			db.set(people);
		}finally{
			//关闭连接
			db.close();
		}
	}
}

这下终于如愿以偿，如图 3 所示。其实 db4o 为开发者想得很周到，关键是如何用好这些特性。

图3. 修改地址和车牌（成功）

删除数据

场景三

“张三”换了工作后，事业发展很快，准备把车卖了换新的，于是他去交管部门办理移交手续，删除关联的车辆信息清单4：

清单4. 删除车辆

				
package com;

import bo.AutoInfo;

import com.db4o.Db4o;
import com.db4o.ObjectContainer;
import com.db4o.ObjectSet;
import com.db4o.query.Predicate;

public class DB4OTest{
	
	public static void main(String[] args){
		//打开数据库
		ObjectContainer db = Db4o.openFile("auto.yap");
		try{
			ObjectSet<AutoInfo> result = db.query(new Predicate<AutoInfo>() {
			    public boolean match(AutoInfo ai) {
			    	//匹配姓名和车牌号
			        return ai.getLicensePlate().equals("川B00000") 
			        	   && ai.getOwnerNo().getName().equals("张三");
			    }
			});
			AutoInfo ai = result.next();
			//删除车辆信息
			db.delete(ai);
		}finally{
			//关闭连接
			db.close();
		}
	}
}

如图 4 所示，所关联的车辆信息已被删除了。

图4. 删除车辆信息

场景四

在场景三的基础上修改一下，设想“张三”由于工作不顺，导致最后维护汽车的开支都困难，他不得不退出有车一族的行列清单5：

清单5. 删除所有信息

				
package com;

import bo.People;

import com.db4o.Db4o;
import com.db4o.ObjectContainer;
import com.db4o.ObjectSet;
import com.db4o.query.Predicate;

public class DB4OTest{
	
	public static void main(String[] args){
        //级联设置
		Db4o.configure().objectClass("bo.People")
        .cascadeOnDelete(true);
		//打开数据库
		ObjectContainer db = Db4o.openFile("auto.yap");
		try{
			ObjectSet<People> result = db.query(new Predicate<People>() {
			    public boolean match(People people) {
			    	//匹配姓名
			        return people.getName().equals("张三");
			    }
			});
			People people = result.next();
			//删除车主以及关联的车辆信息
			db.delete(people);
		}finally{
			//关闭连接
			db.close();
		}
	}
}

用过 Hibernate 的开发者都知道，它的级联删除让人留下了深刻印象，第一次使用的时候都会为之振奋。db4o 也为开发者提供了级联删除，和场景二的级联更新一样， cascadeOnDelete() 是专门为删除准备的，基本概念和 cascadeOnUpdate() 一致。打开 ObjectManager 我们会发现数据库已经清空了，张三的购车经历到此结束。
 

结论

通过本系列文章，db4o 的优势已经体现得淋漓尽致，它的添加、更新、删除是如此的简单，正如 db4o 的口号那样——“仅需一行代码就能存储复杂结构对象，极大的降低了开发时间和成本，提供高效的性能，无需 DBA 干预”。

如本文有不详尽之处，大家可以参考官方的《用户指南》或访问 db4o 官方中文论坛，db4o 中文社区正在火热成长！
 

参考资料

学习

• db4o 官方网站 。
  
  
• 面向对象数据库 db4o 之旅系列 ：查看此系列文章完整列表。
  
  
• ODMG 官方网站 ：了解 ODMG 技术。
  
  
• developerWorks Java 技术专区 ：数百篇关于 Java 编程各个方面的文章。
  

获得产品和技术

• 下载 db4o 免费版 。
  

讨论

• db4o 开发者论坛：讨论 db4o 技术。
  
  
• developerWorks Java 论坛 ：学习 Java 技术。 
   

作者简介

		Rosen Jiang 来自成都，是 db4o 和 OO 的忠实 fans，是 2005 年 db4o 的 dvp 获得者之一。他正在 J2me 应用中使用 db4o，你可以通过 rosener_722@hotmail.com 和他联系。

		Chris 来自香港，热爱开源和 db4o。他创办了中国最火热的 Java 和开源社区 Matrix（http://www.Matrix.org.cn）， 你可以通过 chris@Matrix.org.cn 和他联系。

		张黄瞩，热爱开源软件，熟悉 Java/C/C++ 编程语言，对数据库技术网络技术均感兴趣。你可以通过 zhanghuangzhu@gmail.com 联系他。

在 开源面向对象数据库 db4o 之旅 系列文章的第一部分：初识 db4o 中，作者介绍了 db4o 的历史和现状，应用领域，以及和 ORM 等的比较。在这篇文章中，作者将会介绍 db4o 的安装、启动以及三种不同的查询方式：QBE（Query by Example）、SODA（Simple Object Database Access） 以及 NQ（Native Queries），并分别通过这三种不同的途径实现了两个关联对象的查询。本文还示范了开发中最经常用到的几个典型功能的 db4o 实现。

下载和安装 db4o

db4o 所有最新的版本都可以直接在官方网站上下载，进入 db4o 的下载页面，我们可以看到最新的 for Java 稳定版本是 5.5，包括 JAR、源代码、入门文档、API 等内容的完整的打包文件只有 6 MB，db4o 还有一个对象数据库管理工具 ObjectManager，目前版本是 1.8（请在参考资源中下载）。

接着在 Eclipse 中新建 Java 项目，把 db4o 对象数据库引擎包 db4o-5.5-java5.jar 导入进项目。由于 db4o 支持多种版本的 JDK，除了 for JDK 5.0 的 db4o-5.5-java5.jar 外，还有 for JDK 1.1、1.2-1.4 的 JAR 包，以适应多种环境。与 Hibernate、iBATIS SQL Maps 相比，db4o 更加自然，无需过多地引用第三方支持库。

开启数据库

db4o 怎样进行对象持久化呢？通过浏览目录可以发现，与传统的 RDBMS 一样，db4o 也有自己的数据库文件, 在 db4o 中数据库文件的后缀名是“*.yap”。让我们先来了解一下 db4o 对象数据库引擎的主要包结构：

• com.db4o
  com.db4o 包含了使用 db4o 时最经常用到的功能。两个最重要的接口是 com.db4o.Db4o 和 com.db4o.ObjectContainer。com.db4o.Db4o 工厂是运行 db4o 的起点，这个类中的静态方法可以开启数据库文件、启动服务器或连接一个已经存在的服务器，还可以在开启数据库之前进行 db4o 环境配置。com.db4o.ObjectContainer 接口很重要，开发过程中 99% 的时间都会用到它，ObjectContainer 可在单用户模式下作为数据库实例，也可作为 db4o 服务器的客户端。每个 ObjectContainer 实例都有自己的事务。所有的操作都有事务保证。当打开 ObjectContainer，就已经进入事务了，commit() 或 rollback() 时，下一个事务立即启动。每个 ObjectContainer 实例维护它自己所管理的已存储和已实例化对象，在需要 ObjectContainer 的时候，它会一直保持开启状态，一旦关闭，内存中数据库所引用的对象将被丢弃。
• com.db4o.ext
  你也许想知道为什么在 ObjectContainer 中只能看见很少的方法，原因如下：db4o 接口提供了两个途径，分别在 com.db4o 和 com.db4o.ext 包中。这样做首先是为了让开发者能快速上手；其次为了让其他产品能更容易的复制基本的 db4o 接口；开发者从这一点上也能看出 db4o 是相当轻量级的。每个 com.db4o.ObjectContainer 对象也是 com.db4o.ext.ExtObjectContainer 对象。可以转换成 ExtObjectContainer 获得更多高级特性。
• com.db4o.config
  com.db4o.config 包含了所有配置 db4o 所需的类。
• com.db4o.query
  com.db4o.query 包包含了构造“原生查询, NQ（Native Queries）”所需的 Predicate 类。NQ 是 db4o 最主要的查询接口。

db4o 提供两种运行模式，分别是本地模式和服务器模式。本地模式是指直接在程序里打开 db4o 数据库文件进行操作：

ObjectContainer db = Db4o.openFile("auto.yap");

而服务器模式则是客户端通过 IP 地址、端口以及授权口令来访问服务器：

ObjectServer server=Db4o.openServer("auto.yap",1212);
server.grantAccess("admin","123456");

ObjectContainer db=Db4o.openClient("192.168.0.10",1212,"admin","123456");

两种方式都可以得到 ObjectContainer 实例，就目前 Java EE 应用环境来看，服务器模式更有现实意义；而本地模式更适合于嵌入式应用。为了简化演示，本文在下面的例子都将采用本地模式。

在下面的例子里，我们都会用到下面两个对象： People 和 AutoInfo 对象。

People 对象：

				
package bo;

public class People {

	private java.lang.Integer _id;
	private java.lang.String _name;
	private java.lang.String _address;
	private java.util.List<AutoInfo> _autoInfoList;

	public java.lang.Integer getId() {
		return _id;
	}

	public void setId(java.lang.Integer _id) {
		this._id = _id;
	}

	public java.lang.String getName() {
		return _name;
	}

	public void setName(java.lang.String _name) {
		this._name = _name;
	}

	public java.lang.String getAddress() {
		return _address;
	}

	public void setAddress(java.lang.String _address) {
		this._address = _address;
	}

	public java.util.List<AutoInfo> getAutoInfoList() {
		return this._autoInfoList;
	}

	public void addAutoInfo(AutoInfo _autoInfoList) {
		if (null == this._autoInfoList)
			this._autoInfoList = new java.util.ArrayList<AutoInfo>();
		this._autoInfoList.add(_autoInfoList);
	}

}

AutoInfo 对象：

				
package bo;

public class AutoInfo{

	private java.lang.Integer _id;
	private java.lang.String _licensePlate;
	private bo.People _ownerNo;

	public java.lang.Integer getId () {
		return _id;
	}

	public void setId (java.lang.Integer _id) {
		this._id = _id;
	}

	public java.lang.String getLicensePlate () {
		return _licensePlate;
	}

	public void setLicensePlate (java.lang.String _licensePlate) {
		this._licensePlate = _licensePlate;
	}

	public bo.People getOwnerNo () {
		return this._ownerNo;
	}

	public void setOwnerNo (bo.People _ownerNo) {
		this._ownerNo = _ownerNo;
	}

}

利用 set 方法把新对象存入 ObjectContainer，而对 ObjectContainer 中已有对象进行 set 操作则是更新该对象。db4o 保存数据库很简单，下面就是一个段完整的保存对象的代码：

AutoInfo 对象：

				
package com;

import bo.AutoInfo;
import bo.People;

import com.db4o.Db4o;
import com.db4o.ObjectContainer;

public class DB4OTest{
	
	public static void main(String[] args){
		//打开数据库
		ObjectContainer db = Db4o.openFile("auto.yap");
		try{
			//构造 People 对象
			People peo = new People(); 
			peo.setId(1);
			peo.setAddress("成都市");
			peo.setName("张三");
			//构造 AutoInfo 对象
			AutoInfo ai = new AutoInfo();
			ai.setId(1);
			ai.setLicensePlate("川A00000");
			//设置 People 和 AutoInfo 的关系
			ai.setOwnerNo(peo);
			peo.addAutoInfo(ai);
			//保存对象
			db.set(peo);
		}finally{
			//关闭连接
			db.close();
		}
	}
}

当我们运行上述代码，db4o 会自动创建“auto.yap”文件。让我们来看看到底保存成功没有，打开 ObjectManager 工具，图 1 所示。

“File”－>“Open File”－>选择刚才我们保存的“auto.yap”文件（“auto.yap”文件可在项目的根目录下找到），最新的 ObjectManager 1.8 版本为我们提供了“Read Only”方式读取数据库文件，避免 ObjectManager 占用数据库文件所导致的程序异常。

打开之后，图 2 所示，刚才存贮的 People 对象已经在数据库中了，并且还可以很直观的看到 AutoInfo 对象也放入了 ArrayList 中。这种可视化的对象关系有利于我们对数据的理解，是传统 RDBMS 无法比拟的。有些开发者会说 ObjectManager 工具略显简单，这点我想随着 db4o 的不断发展会加入更多的特性。在这个工具中，我们意外的发现了 Java 集合对象的踪影，db4o 把与 ArrayList 有直接关系的所有接口和父类都保存了，这样显得更直观。

在此，我保留了 _id 属性，这是因为通常在 Java EE 环境中，DAO 第一次不是把整个对象都返回到表现层，而是只返回了“标题”、“发布时间”这些信息（并隐式的返回id），接着 DAO 与数据库断开；要查看详情（比如文章内容）就需要进行 findById 操作，这时 DAO 要再次与数据库交互，只有唯一标识符才能正确地找到对象。这种懒加载方式也是很多书籍所推荐的。

回到本文的范例程序中，这个 _id 属性可由人工编码实现的“序列”进行赋值，当然 db4o 也提供了内部标识符 Internal IDs，图 2 中的 id=1669；以及 UUIDs。

查询数据库

和 RDBMS 一样，db4o 也有自己的查询语言，分别是 QBE（Query by Example）、NQ（Native Queries）、SODA（Simple Object Database Access），db4o 更推荐使用 NQ 进行查询。NQ 方式提供了非常强大的查询功能，支持原生语言，也就意味着你可以使用 Java 来判断该对象是否符合条件，这是其他数据库查询语言无法比拟的。在某些情况下， db4o 核心会将 NQ 翻译成 SODA 以获得更高的性能。下面详细介绍一下这三种查询语言。

QBE（Query by Example）

QBE 规范可在这里下载。QBE 最初由 IBM 提出，同时业界也有许多和 QBE 兼容的接口，包括著名的 Paradox。有些系统，比如微软的 Access，它的基于表单的查询也是受到了部分 QBE 思想的启发。在 db4o 中，用户可借用 QBE 快速上手，可以很容易适应 db4o 存取数据的方式。

当利用 QBE 为 db4o 提供模板（example）对象时，db4o 将返回所有和非默认值字段匹配的全部对象。内部是通过反射所有的字段和构造查询表达式（所有非默认值字段结合”AND”表达式）来实现。

例如，利用 QBE 查找到车牌号为“川A00000”的车主姓名，这是一个级联查询。

				
package com;

import java.util.List;

import bo.AutoInfo;

import com.db4o.Db4o;
import com.db4o.ObjectContainer;

public class DB4OTest{
	
	public static void main(String[] args){
		//打开数据库
		ObjectContainer db = Db4o.openFile("auto.yap");
		try{
			//构造模板对象
			AutoInfo ai = new AutoInfo();
			ai.setLicensePlate("川A00000");
			//查询对象
			List<AutoInfo> list = db.get(ai);
	    	for(int x = 0; x < list.size(); x++){
	    		System.out.println("车主姓名："+list.get(x).getOwnerNo().getName());
			}
		}finally{
			//关闭连接
			db.close();
		}
	}
}

但是 QBE 也有明显的限制：db4o 必须反射模板（example）对象的所有成员；无法执行更进一步的查询表达式（例如 AND、OR、NOT 等等）；不能约束 0（整型）、””（空字符串）或者 null（对象），因为这些都被认为是不受约束的。要绕过这些限制，db4o 提供了 NQ（Native Queries）。

SODA（Simple Object Database Access）

SODA ，简单对象数据库访问，请查看官方站点，其中一位主要维护者是 Carl Rosenberger，Carl 正是 db4o 首席架构师。

SODA 就是一种与数据库通讯的对象 API。最终的目标是实现类型安全、对象复用、最小的字符串使用、与编程语言无关等特性。SODA 是 db4o 最底层的查询 API，目前 SODA 中使用字符串来定义字段，这样将不能实现类型安全也无法在编译时检查代码，而且写起来较麻烦，当然要达到设计目标这个阶段是必须的。大部分情况下 NQ（Native Queries）是很好的查询接口，不过遇到动态生成查询的时候 SODA 就大有作为了。

通过 SODA 查找到车牌号为“川A00000”的车主姓名：

				
package com;

import java.util.List;

import bo.AutoInfo;

import com.db4o.Db4o;
import com.db4o.ObjectContainer;
import com.db4o.query.Query;

public class DB4OTest{
	
	public static void main(String[] args){
		//打开数据库
		ObjectContainer db = Db4o.openFile("auto.yap");
		try{
			//构造查询对象
			Query query=db.query();
			//设置被约束实例
			query.constrain(AutoInfo.class);
			//设置被约束实例的字段和约束条件
			query.descend("_licensePlate").constrain("川A00000");
			//查询对象
			List<AutoInfo> list = query.execute();
	    	for(int x = 0; x < list.size(); x++){
	    		System.out.println("车主姓名："+list.get(x).getOwnerNo().getName());
			}
		}finally{
			//关闭连接
			db.close();
		}
	}
}

通过 API，发现 Query 实例增加了 sortBy 按字段排序方法和 orderAscending正序、orderDescending 倒序排列方法，SODA 比 QBE 更进了一步。

NQ（Native Queries）

精彩总是在最后出场，NQ 才是 db4o 查询方式中最精彩的地方！有没有想过用你熟悉的的编程语言进行数据库查询呢？要是这样，你的查询代码将是 100% 的类型安全、100% 的编译时检查以及 100% 的可重构，很奇妙吧？NQ 可以做到这些。

有两篇论文专门讲解了 NQ 的基本概念和设计思路，分别是 《Cook/Rosenberger，持久对象原生数据库查询语言》 和 《Cook/Rai，Safe Query Objects: Statically Typed Objects as Remotely Executable Queries》。作为结果集的一部分，NQ 表达式必须返回 true 值来标记特定实例。如果可能的话 db4o 将尝试优化 NQ 表达式，并依赖索引来运行表达式。

通过 NQ 查找到车牌号为“川A00000”的车主姓名：

				
package com;

import java.util.List;

import bo.AutoInfo;

import com.db4o.Db4o;
import com.db4o.ObjectContainer;
import com.db4o.query.Predicate;

public class DB4OTest{
	
	public static void main(String[] args){
		//打开数据库
		ObjectContainer db = Db4o.openFile("auto.yap");
		try{
			List <AutoInfo> list = db.query(new Predicate<AutoInfo>() {
				public boolean match(AutoInfo ai) {
			    	//这样才是类型安全的
			        return ai.getLicensePlate().equals("川A00000");
			    }
			});
	    	for(int x = 0; x < list.size(); x++){
	    		System.out.println(list.get(x).getOwnerNo().getName());
			}
		}finally{
			//关闭连接
			db.close();
		}
	}
}

必须指出 NQ 的一个的问题是：在内部，db4o 设法把 NQ 转换成 SODA。但并不是所有的查询表达式都可以成功转换。有些查询表达式的流向图（flowgraph）非常难于分析。这种情况下，db4o 将不得不实例化一些持久对象来真实地运行 NQ 表达式。

正在开发中的 NQ 查询优化器就可以化解这个障碍，它将分析 NQ 表达式的每个部分，以确保最少量的实例化对象，以此提高性能。当然，优化器的不是灵丹妙药，关键还需要自己多优化代码。

开发 Java EE 项目经常会用到分页，怎样用 NQ 实现呢？向数据库写入六条记录：

				
package com;

import java.util.List;

import bo.AutoInfo;

import com.db4o.Db4o;
import com.db4o.ObjectContainer;
import com.db4o.query.Predicate;

public class DB4OTest{
	
	public static void main(String[] args){
		//打开数据库
		ObjectContainer db = Db4o.openFile("auto.yap");
		try{
			List<AutoInfo> list = db.query(new Predicate<AutoInfo>() {
				public boolean match(AutoInfo ai) {
			        return true;
			    }
			});
			//记录总数
			Integer count = list.size();
			//每页两条，分三页
	    	for(int x = 0; x < 3; x++){
	    		System.out.println("第"+x+"页："+list.get(x*2).getLicensePlate());
	    		System.out.println("第"+x+"页："+list.get(x*2+1).getLicensePlate());
			}
		}finally{
			//关闭连接
			db.close();
		}
	}
}

我们发现，在进行 NQ 查询时并没有加入任何条件（无条件返回 true），是不是相当于遍历了整个数据库？db4o 的设计者早就想到了这个问题，当 db.query() 执行完毕返回 list 实例的时候，db4o 只是与数据库同步取出内部 IDs 而已，并没有把所有的 AutoInfo 对象全部取出，只有在 list.get(x*2).getLicensePlate() 之后才会去根据 IDs 取出记录。所以不必担心性能问题。

结论

db4o 为开发者提供了多种查询方式，这些方式都很灵活。要引起大家注意的是：灵活在带来便利的同时也对开发者自身素质提出了更高的要求，（比如排序，既可以用 SODA 也可以用 Java 集合对象实现）在开发过程中一定要形成某种统一的开发模式，这样 db4o 才能最高效能地为我所用。

参考资料

• “面向对象数据库 db4o 之旅，第 1 部分：初识 db4o”：（developerWorks Java ，2006 年 10月）：介绍了 db4o 的历史和现状，应用领域，以及和 ORM 等的比较。
  
• db4o 开发者论坛：讨论 db4o 技术。
  
• db4o 中国开发者论坛：讨论 db4o 技术的中文论坛。
  
• ODMG 官方网站：了解 ODMG 技术。
  
• SODA 官方网站：了解简单对象数据库访问技术。
  
• Java 技术专区：这里有数百篇有关 Java 编程各方面的文章。
  
• developerWorks Java 论坛：学习 Java 技术

• db4o 官方网站：db4o 最新信息以及 db4o 下载。
  
• 下载 db4o 对象数据库管理工具 ObjectManager 1.8 for Windows。

作者简介

  Rosen Jiang 来自成都，是 db4o 和 OO 的忠实 fans，是 2005 年 db4o 的 dvp 获得者之一。他正在 J2me 应用中使用 db4o，你可以通过 rosener_722@hotmail.com 和他联系。

  Chris 来自香港，热爱开源和 db4o。他创办了中国最火热的 Java 和开源社区 Matrix（http://www.Matrix.org.cn）， 你可以通过 chris@Matrix.org.cn 和他联系。
 
  张黄瞩，热爱开源软件，熟悉 Java/C/C++ 编程语言，对数据库技术网络技术均感兴趣。你可以通过 zhanghuangzhu@gmail.com 联系他。

IBM DeveloperWorks(IBM DW) 版权所有！引用、转贴本文应注明本文来自 IBM DW。