开源面向对象数据库 db4o 之旅: 深入db4o

2010/05/14 10:22
阅读数 1.1K

前言

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

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

更新数据

场景一

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

在 db4o 中,我们这样来实现对这个用户信息的修改(清单1):
清单1. 修改地址

  1.                                
  2. package com;
  3.  
  4. import bo.People;
  5.  
  6. import com.db4o.Db4o;
  7. import com.db4o.ObjectContainer;
  8. import com.db4o.ObjectSet;
  9. import com.db4o.query.Predicate;
  10.  
  11. public class DB4OTest {
  12.  
  13.         public static void main ( String [ ] args ) {
  14.                 //打开数据库
  15.                 ObjectContainer db = Db4o. openFile ( "auto.yap" );
  16.                 try {
  17.                         ObjectSet<People> result = db. query ( new Predicate<People> ( ) {
  18.                             public boolean match (People people ) {
  19.                                 return people. getName ( ). equals ( "张三" );
  20.                             }
  21.                         } );
  22.                         People people = result. next ( );
  23.                         //修改地址
  24.                         people. setAddress ( "成都市金牛区xxx号" );
  25.                         db. set (people );
  26.                 } finally {
  27.                         //关闭连接
  28.                         db. close ( );
  29.                 }
  30.         }
  31. }

 

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

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

场景二

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

这次我们几乎和场景一采用同样的代码,但结果却不同(清单2):
清单2. 修改地址和车牌(不成功)

  1.                                
  2. package com;
  3.  
  4. import bo.People;
  5.  
  6. import com.db4o.Db4o;
  7. import com.db4o.ObjectContainer;
  8. import com.db4o.ObjectSet;
  9. import com.db4o.query.Predicate;
  10.  
  11. public class DB4OTest {
  12.  
  13.         public static void main ( String [ ] args ) {
  14.                 //打开数据库
  15.                 ObjectContainer db = Db4o. openFile ( "auto.yap" );
  16.                 try {
  17.                         ObjectSet<People> result = db. query ( new Predicate<People> ( ) {
  18.                             public boolean match (People people ) {
  19.                                 return people. getName ( ). equals ( "张三" );
  20.                             }
  21.                         } );
  22.                         People people = result. next ( );
  23.                         //修改地址
  24.                         people. setAddress ( "绵阳市xx区xxx号" );
  25.                         //修改车牌号
  26.                         people. getAutoInfoList ( ). get ( 0 ). setLicensePlate ( "川B00000" );
  27.                         db. set (people );
  28.                 } finally {
  29.                         //关闭连接
  30.                         db. close ( );
  31.                 }
  32.         }
  33. }

 

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

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

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

为了能更新成员对象,ob4o 提供了 cascadeOnUpdate() 方法,该方法必须在每次开启数据库之前设置清单3
清单3. 修改地址和车牌(成功)

  1.                                
  2. package com;
  3.  
  4. import bo.People;
  5.  
  6. import com.db4o.Db4o;
  7. import com.db4o.ObjectContainer;
  8. import com.db4o.ObjectSet;
  9. import com.db4o.query.Predicate;
  10.  
  11. public class DB4OTest {
  12.  
  13.         public static void main ( String [ ] args ) {
  14.         //级联设置
  15.                 Db4o. configure ( ). objectClass ( "bo.People" )
  16.         . cascadeOnUpdate ( true );
  17.                 //打开数据库
  18.                 ObjectContainer db = Db4o. openFile ( "auto.yap" );
  19.                 try {
  20.                         ObjectSet<People> result = db. query ( new Predicate<People> ( ) {
  21.                             public boolean match (People people ) {
  22.                                 return people. getName ( ). equals ( "张三" );
  23.                             }
  24.                         } );
  25.                         People people = result. next ( );
  26.                         //修改地址
  27.                         people. setAddress ( "绵阳市xx区xxx号" );
  28.                         //修改车牌号
  29.                         people. getAutoInfoList ( ). get ( 0 ). setLicensePlate ( "川B00000" );
  30.                         db. set (people );
  31.                 } finally {
  32.                         //关闭连接
  33.                         db. close ( );
  34.                 }
  35.         }
  36. }

 

这下终于如愿以偿,如图 3 所示。其实 db4o 为开发者想得很周到,关键是如何用好这些特性。
图3. 修改地址和车牌(成功)
图3. 修改地址和车牌(成功)
删除数据

场景三

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

  1.                                
  2. package com;
  3.  
  4. import bo.AutoInfo;
  5.  
  6. import com.db4o.Db4o;
  7. import com.db4o.ObjectContainer;
  8. import com.db4o.ObjectSet;
  9. import com.db4o.query.Predicate;
  10.  
  11. public class DB4OTest {
  12.  
  13.         public static void main ( String [ ] args ) {
  14.                 //打开数据库
  15.                 ObjectContainer db = Db4o. openFile ( "auto.yap" );
  16.                 try {
  17.                         ObjectSet<AutoInfo> result = db. query ( new Predicate<AutoInfo> ( ) {
  18.                             public boolean match (AutoInfo ai ) {
  19.                                 //匹配姓名和车牌号
  20.                                 return ai. getLicensePlate ( ). equals ( "川B00000" )
  21.                                            &amp;&amp; ai. getOwnerNo ( ). getName ( ). equals ( "张三" );
  22.                             }
  23.                         } );
  24.                         AutoInfo ai = result. next ( );
  25.                         //删除车辆信息
  26.                         db. delete (ai );
  27.                 } finally {
  28.                         //关闭连接
  29.                         db. close ( );
  30.                 }
  31.         }
  32. }

 

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

场景四

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

  1.                                
  2. package com;
  3.  
  4. import bo.People;
  5.  
  6. import com.db4o.Db4o;
  7. import com.db4o.ObjectContainer;
  8. import com.db4o.ObjectSet;
  9. import com.db4o.query.Predicate;
  10.  
  11. public class DB4OTest {
  12.  
  13.         public static void main ( String [ ] args ) {
  14.         //级联设置
  15.                 Db4o. configure ( ). objectClass ( "bo.People" )
  16.         . cascadeOnDelete ( true );
  17.                 //打开数据库
  18.                 ObjectContainer db = Db4o. openFile ( "auto.yap" );
  19.                 try {
  20.                         ObjectSet<People> result = db. query ( new Predicate<People> ( ) {
  21.                             public boolean match (People people ) {
  22.                                 //匹配姓名
  23.                                 return people. getName ( ). equals ( "张三" );
  24.                             }
  25.                         } );
  26.                         People people = result. next ( );
  27.                         //删除车主以及关联的车辆信息
  28.                         db. delete (people );
  29.                 } finally {
  30.                         //关闭连接
  31.                         db. close ( );
  32.                 }
  33.         }
  34. }

 

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

结论

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

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

参考资料

学习

获得产品和技术

讨论

作者简介

  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 联系他。
展开阅读全文
加载中

作者的其它热门文章

打赏
0
1 收藏
分享
打赏
0 评论
1 收藏
0
分享
返回顶部
顶部