<hibernate-mapping>
  <class name="Product" 
        discriminator-value="0"  lazy="false">
    <id name="id" type="long"/>       
    <discriminator 
        formula="(select pr.SubProductAllowable 
                from ProductRelease pr 
                where pr.productReleaseID=
                        productReleaseID)"
        type="integer" />
    <subclass  name="NestedProduct"  
        discriminator-value="1"/>
  </class>
</hibernate-mapping>

    如果 formula 表达式评估结果为 0 时－－也就是不允许次品出厂－－那么对象将是 Product 类。如果结果是 1，那么对象将是 NestedProduct。在表 1 和 2 中，表 Product 的第一条记录（ProductID=10000001），已初始化的类将是 NestedProduct，因为它参考一条 SubProductAllowable=1 的 ProductRelease 记录。表 Product 的第二条记录（ProductID=20000001），已初始化的类将是 Product，因为它参考一条 SubProductAllowable=0 的 ProductRelease 记录。
   

S/N	ProductReleaseID	SubProductAllowable	...
1	11	1	¡­
2	601	0	¡­

        表 1. ProductRelease 表中的记录
   

S/N	ProductID	ProductReleaseID	...
1	10000001	11	¡­
2	20000001	601	...

        表 2. Product 表中的记录
   
    Property
   
    在 property 元素中的 formula 允许对象属性包含特定引伸值，比如对结果进行 sum、average、max 等等。

<property name="averagePrice" formula="(select avg(pc.price) from PriceCatalogue pc, SelectedItems si where si.priceRefID=pc.priceID)"/>

    此外，formula 也能协助从基于当前记录的特定值向其它表检索数据。例如：

<property name="currencyName" formula="(select cur.name from currency cur where cur.id= currencyID)"/>

    这将由助于从 currency 表检索 currency name。正如你所看到的，这样直接映射可消除许多转换编码。
   
    map-key
   
    formula 允许 map-key 持有任何可能的值。下列范例（图 3），我们想让 Role_roleID 成为对象模型的 map-key（图 4）。

                    
                          图 3. 用户角色数据 schema

  
                            图 4. 用户角色对象模型
   
    在前面的数据 schema 中，User 和 Role 由 User_has_Role 通过 many-to-many 关系关联调用。为了获取某个 User 所有的指派角色，我们进行如下映射：

<hibernate-mapping>
  <class name="User">
    <id name="userID"/>
    <map name="roles"  
        table="UserRole"/>
      <key column="User_userID"/>
      <map-key 
        formula="Role_RoleID" 
        type="string"/>
      <many-to-many 
        column="Role_RoleID"
        class="Role"/>
    </map>
  </class>
  <class name="Role">
    <id name="roleID"/>
  </class>
</hibernate-mapping>

    Role_RoleID 通常用于连接 many-to-many 元素的栏位值。Hibernate 通常不允许 Role_RoleID 出现在 map-key 和 many-to-many 的栏位属性中。但是有了 formula，Role_RoleID 也能用于 map-key。
   
    element、map-key-many-to-many 以及其他
   
    element 和 property 类似，能从任何有效的 formula 表达式赋予评估值。
   
    map-key-many-to-many 中 formula 的用法类似于 map-key。但是，map-key-many-to-many 通常用于三重关系，map key 是一个被自己参考的对象，而不是被参考的属性。
   
    那么，到底哪些情况下 formula 不支持呢？有些数据库（例如 Oracle 7）就不支持嵌入式 select 语句（也就是说一条 select SQL 内嵌在另外一条 select SQL 语句中），这种情况 formula 就不支持评估结果。因此，你应该首先检查嵌入式 select SQL 语句是否被支持。
   
    一旦 Hibernate 的映射拿 formula 表达式作为 select SQL 选取的一部分，请确认数据库 SQL 方言是否允许使用 formula，尽管这样将降低代码轻便性。
   
范畴 2：formula 用于连接

    many-to-one
   
    另一个普遍的场景是真实世界的数据模型是所有者关系映射，这意味着映射是不同于 one-to-one、one-to-many 以及 many-to-many 关系的，formula 是提供所有者关系管理元素中的一个。图 5 展示了某公司可有多个联系人，但是其中只有一个为默认联系人的范例。一个公司有多个联系人是典型的 one-to-many 关系。但是，为了标识默认联系人，ContactPerson 表使用了 defaultFlag 参数（1 是 yes, 0是 no）。

               
                        图 5. 用户角色数据 schema

             
                           图 6. 用户角色对象模型
   
    为了说明对象模型（图 6）中默认联系人关系，我们使用如下映射文件：

<hibernate-mapping>
  <class name="Company" table="Company">
    <id name="id" />
    <many-to-one 
      name="defaultContactPerson" 
      property-ref="defaultContactPerson">
        <column name="id"/>
        <formula>1</formula>
        </many-to-one>
  </class>
  <class name="Person" >
    <id name="id" />
    <properties name="defaultContactPerson">
        <property name="companyID" />
        <property name="defaultFlag" />
    </properties>
  </class>
</hibernate-mapping>

    如上，我们把 companyID 和 defaultFlag 组织到名为 defaultContactPerson 的 properties 元素中，做为 Person 表的 unique key。Company 类中的 many-to-one 元素连接 Person 表的 defaultContactPerson properties 元素。输出的 SQL 像这样：
   
    select c.id, p.id from Company c, Person p where p.companyID=c.id and p.defaultFlag=1
   
    one-to-one
   
    Hibernate 中，one-to-one 主要用于两张表共享同一主键的情况。对于外键关联，我们通常使用 many-to-one 来代替。但是，有了 formula，one-to-one 可以通过外键连接表。上面的 many-to-one 范例可以通过 one-to-one 来映射：

<hibernate-mapping>
  <class name="Company" table="Company" >
    <id name="id" />
    <one-to-one name="defaultContactPerson" 
        property-ref="defaultContactPerson" >
    <formula>id</formula>
    <formula>1</formula>
    </one-to-one>
  </class>
  <class name="Person" >
    <id name="id" />
    <properties name="defaultContactPerson">
      <property name="companyID" />
      <property name="defaultFlag" />
    </properties>
   </class>
</hibernate-mapping>

    many-to-many
   
    formula 用于当 many-to-many 元素为关系表和实体表连接的特殊关系，尽管通常没有必要这样用。
   
总结

    文章范例展示了大部分 formula 的适用情景。当需要 formula 评估值时，formula 表达式将出现在 产生的 SQL 语句的 select 部分。当 formula 用于连接时，它出现在产生的 SQL 语句的 where 部分。此外，formula 表达式可用于任何 SQL 方言，只要目标数据库支持。最后，formula 可协助完成从数据模型到对象模型的无代码细粒度映射。


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

。说说变化吧，iBATIS 产品系列中，iBATIS SQL Maps 更名为 iBATIS Data Mapper 分为 for .NET 和 for Java 两个版本；iBATIS DAO 的名称未变，在原有 for Java 的基础上增加了 for .NET 版本；当然最后还包括官方的 iBATIS PetStore 范例。
              
    目前 iBATIS Data Mapper for Java（以下简称:iBATIS Data Mapper）的版本为 2.1.5。当前以及未来的 iBATIS Data Mapper 将加入以下新特征。
   
   

CREATE TABLE USER_PROPERTY (           USER_ID BIGINT NOT NULL,     FIRST_NAME VARCHAR(100) DEFAULT '',     LAST_NAME VARCHAR(100),     BIRTH_DATE TIMESTAMP(8),     PRIMARY KEY (USER_ID) );

VO如下：

package org.mystuff.db; // WARNING: This is an autogenerated file public class UserProperty {     // Constructors     public UserProperty() {     }     public UserProperty(long _userId) {         this.userId = _userId;     }     // Fields     private String firstName;     public String getFirstName() {         return firstName;     }     public void setFirstName(String _firstName) {         this.firstName = _firstName;     }     private java.util.Date birthDate;     public java.util.Date getBirthDate() {         return birthDate;     }     public void setBirthDate(java.util.Date _birthDate) {         this.birthDate = _birthDate;     }     private String lastName;     public String getLastName() {         return lastName;     }     public void setLastName(String _lastName) {         this.lastName = _lastName;     }     private long userId;     public long getUserId() {         return userId;     }     public void setUserId(long _userId) {         this.userId = _userId;     } }

映射文件如下：

<?xml version='1.0'?> <!DOCTYPE sqlMap PUBLIC "-//iBATIS.com//DTD SQL Map 2.0//EN" "http://www.ibatis.com/dtd/sql-map-2.dtd"> <!-- WARNING: This is an autogenerated file --> <sqlMap name="UserProperty"> <cacheModel id="userproperty-cache" type="MEMORY"> <flushInterval hours="24"/> <flushOnExecute statement="insertUserProperty"/> <flushOnExecute statement="updateUserProperty"/> <flushOnExecute statement="deleteUserProperty"/> <property name="reference-type" value="WEAK" /> </cacheModel> <resultMap class="org.mystuff.db.UserProperty" id="userproperty-result" > <result property="firstName" column="FIRST_NAME" /> <result property="birthDate" column="BIRTH_DATE" /> <result property="lastName" column="LAST_NAME" /> <result property="userId" column="USER_ID" /> </resultMap> <select id="getUserProperty" resultClass="org.mystuff.db.UserProperty" parameterClass="org.mystuff.db.UserProperty" resultMap="userproperty-result" > <![CDATA[ select * from USER_PROPERTY where USER_ID = #userId# ]]> </select> <update id="updateUserProperty" parameterClass="org.mystuff.db.UserProperty"> <![CDATA[ update USER_PROPERTY set FIRST_NAME = #firstName# , BIRTH_DATE = #birthDate# , LAST_NAME = #lastName# where USER_ID = #userId# ]]> </update> <insert id="insertUserProperty" parameterClass="org.mystuff.db.UserProperty"> <![CDATA[ insert into USER_PROPERTY(FIRST_NAME, BIRTH_DATE, LAST_NAME, USER_ID) values(#firstName#, #birthDate#, #lastName#, #userId#) ]]> </insert> <delete id="deleteUserProperty" parameterClass="org.mystuff.db.UserProperty"> <![CDATA[ delete from USER_PROPERTY where USER_ID = #userId# ]]> </delete> </sqlMap>

    Jasmine IDE iBATIS GUI（http://jasmineide.sourceforge.net）。在构建映射文件、VO、DAO 类（不是 iBATIS 的 DAO，而是一个调用 sqlclient 方法的 java 类）方面这是最好的了，通过点击几下鼠标就可生成。这个工具允许你建立一个项目并设置 DB 连接连同所有通常用到的配置文件。（首先你需要设置自己的 DB 连接，确定你的驱动程序和所有 jar 都在系统类路径中）
             
   

    我想，随着时间的推移，会有更多的开发者加入为 iBATIS 添砖加瓦的行列。
   
    重要改进议题
       
    http://wiki.apache.org/ibatis/Improved_Dynamic_SQL_Whiteboard 这里正在讨论关于改进动态 SQL 的白板，让 iBATIS Data Mapper 在动态 SQL 方面更强大。另外，当开发某个有着大量查询和大量数据的系统时，通常也会对这些数据的子集进行开发。“记录长时间运行的查询”功能将加快开发进度，能帮助开发者或 DBA 了解哪个查询慢或尚未优化，找出潜在瓶颈。为了引入这种新特性，也许会修改 sqlmap 配置文件（比如默认临界值），也会在 mapped statement 中增加新属性（用来覆盖默认临界值）。


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

来看看新需求：

张三后来做生意，自己经营得很好，打算再买辆车跑运输。对于第二次买车，车辆管理系统的 PEOPLE 表原本已经记录了他的基本信息，遂不对 PEOPLE 表操作。只向 AUTO_INFO 表 insert 一条车辆记录即可。

新需求所用到的技术要点都在《 iBATIS SQL Maps（二） 》和《 iBATIS SQL Maps（三） 》中出现过了。请看映射文件：

简单地组合一下以前出现过的映射文件，就能满足新需求。相应程序代码如下：

程序代码也是简单组合一下而已，想想 Hibernate 又是怎么写的呢？相信有 JDBC 经验的程序员应该更喜欢 iBATIS SQL Maps ！

斗转星移、峰回路转， 张三在经历过生意红火之后，接下来的一年内生意场上连连告负，不得不把自己的摊子收缩一下。这第一件事要把跑运输的车卖掉，就是 那辆牌照为 “ A00002” 的 。

相应映射文件只需小小修改：

添加了一个 delete 类型的 Mapped Statement 。同样，也无需再解释了。相应程序代码：

到这里， iBATIS SQL Maps 之旅也就结束了。是的，很有意犹未尽的感觉，还没按照 one-to-many 方式删除张三和他所有的车辆呢。

这个工作就留给你来完成吧！

    我不想比较 Hibernate 和 iBATIS SQL Maps 孰优孰劣，因为这种比较实在无聊！从我开始写第一行 Delphi 代码开始，就充斥着“ VC 好？还是 Delphi 好？”这样的比较！如果你尚未涉足过 JDBC ，我想 Hibernate 会更适合你 … …


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

    resultMap 是 iBATIS SQL Maps 框架中重要组件之一， 你也许还记得 resultClass 吧？两者概念基本一致。 resultMap 则是可定制 Mapped Statement 返回对象的。可定制表现在：比如我有一张数据表包含 10 个字段，但我的 POJO 只定义了 5 个属性，这时，只要取出我关心的字段就行。和 Hibernate 类似， resultMap 的 result 元素定义了 POJO 属性到数据表字段的映射。

需要说明的是 result 元素 select 属性，该属性类似于加载了一个子查询，并自动载入，如果这个子查询包含多条结果，就自动把结果装载进 List 类型。该 result 元素 对应 People 中的属性为 ” autoInfoList” ，而由 Hibernate 生成的 People 却是 Set 类型 ” autoInfoSet” ，这两种类型无法直接互转，所以我修改了 POJO 属性。

select id="getPeople" resultMap="get-people-result" parameterClass="bo.People"

此为 select 类型 Mapped Statement 。传入 People 实例，返回为自己定制、包含 ” autoInfoList” 的 People 实例。传入 People 类型参数是为了便于多字段匹配查询，今天也许我只需利用 People.id 单字段匹配就能得到结果，但下次的新需求也许是 People.address 和 People.name 联合匹配！

相应程序代码：

sqlMap.queryForObject(String arg0, Object arg1)

此方法类似 Hibernate 的 session.load(…) ，传入 Mapped Statement id ，再传入包含主键的对象实例。除我上面列举的 sqlMap. queryForObject(String arg0, Object arg1) 外，还有重载方法 ：

下面我会讲到如何以集合类持有多个 People 对象实例。

在车辆管理应用中，需要把人员一一列出，选中某个再显示详细内容。类似于这样的需求， iBATIS SQL Maps 引入 sqlMap.queryForList(String arg0, Object arg1) 来满足。

       还记得我们的映射文件怎么写的？对了，传入主键值再查询！

但是，新需求不要任何条件，直接列出人员啊！难道还要再添加新的 Mapped Statement 来满足？动态 Mapped Statement 能满足在不改变映射文件的前提下提供有参数和无差数查询：

dynamic prepend="where"

select 类型 Mapped Statement 的本质并无改变，只是通过 dynamic 元素定义了动态 where 子句。 dynamic 元素属性 prepend=”where” 在一元判定元素 isNotNull 返回 ”true” 时有效。 isNotNull 元素属性 property="id" 用于判定 People.id 是否为 null ，假如未传入包含主键值的 People 实例， dynamic 元素将会无效，反之则亦然，这样就达到了在不改变映射文件的前提下实现动态 SQL 的目的。关于一元判定元素和二元判定元素的详细资料请查阅官方文档，如能恰当利用这些判定元素，动态 SQL 将会更灵活。

相应程序代码：

传入 Mapped Statement id ，再传入未包含主键的对象实例，也可以干脆传 null 进去。重载方法 sqlMap .queryForList(String arg0, Object arg1, int arg2, int arg3) 用于分页 ， arg2 、 arg3 分别代表页码和每页个数。

好了，使用动态 Mapped Statement ，再试试 queryForObject(String arg0, Object arg1) 吧！



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

为什么选择 iBATIS ？  

    也许各位看官已在各种不同的技术资料上了解到它的优势。但是对于我来说，选择它的理由只有一个 ——“ 利用原有资源 ” 。 Hibernate 的却优秀，但是用来整合原有系统，它却很难胜任。例如，以前在进行数据建模时使用了复合主键、跨越多表产生的几十甚至上百行的查询语句、利用原有存储过程 … … 当面临这一系列问题时 Hibernate 就显得力不从心了，要想使用 Hibernate 就只能改造原有系统！

当我面临系统整合问题时（整合的要求很简单：只需要保留原有系统查询部分）， iBATIS 进入了我的视线。原有系统中除 SQL 语句需要小小的修改外，数据表、查询结果都不需要改变！也不用像 Hibernate 那样映射出众多的配置文件、 POJO ，一下子清爽了很多。 BTW ： Hibernate 这种做法没有错！只是我只需要查询功能，仅仅是取我所好而已，避免了杀鸡用牛刀。

目前，系统整合已经结束，花了一个月时间。如果使用 Hibernate ，恐怕我现在还在为怎么设计数据表、怎样下 HQL 而和同事争论。

开始另一次 O/R Mapping 之旅

    上次 O/R Mapping 之旅的 BO 、数据表还可以重用，只是把数据库迁移到了 MySQL 。打开 Eclipse ，新建一个 Resin 项目。把 ibatis-sqlmap-2.jar 和 ibatis-common-2.jar 拷贝到 lib 目录下，再导入项目。和 Hibernate 自动配置、自动映射相比， iBATIS 的一切都是手工完成的。    

    在 src 下建立配置文件 SqlMapConfig.xml ，数据库链接、连接池、 SqlMap 映射文件 … … 这些都要靠它了。官方参考手册对怎样进行设置有很详细的描述，我只对要用到的地方进行粗略说明。

JDBC ：通过传统 JDBC 来管理事务。

JTA ：使用一个 JTA 全局事务，使 iBATIS 的事务包括在更大的事务范围内（跨数据库 Session 的），这个更大的事务范围可能包括了其他的数据库和事务资源。这个配置需要一个 UserTransaction 属性，以便从 JNDI 获得一个 UserTransaction 。  

EXTERNAL ：调用 iBATIS 以外的其他事务管理器来管理事务。

    DBCP: 基于 Apache DBCP 连接池 API 实现的 DataSource ，当无容器提供 DataSource 服务时，可以使用该选项，对应 iBATIS 实现类为 com.ibatis.sqlmap.engine.datasource.DbcpDataSourceFactory 。

JNDI ：使用 J2EE 容器提供的 DataSource 实现， DataSource 将通过指定的 JNDI Name 从容器中获取。对应 iBATIS 实现类为 com.ibatis.sqlmap.engine.datasource.JndiDataSourceFactory 。

     注意！ 每种 dataSource 元素的 property 都有不同的地方，不能光把 type 名字改了了事。

你也许已发现，我只定义了单个映射文件。不错，和 Hibernate 的一个表一个映射文件不同， iBATIS 的映射文件个数可以人为控制，颗粒度自己掌握。

                                        

    以下为 iBATIS SQL Maps 工作流程，对于理解概念很有帮助。大意是 1、你可以把 JavaBean、Map 类型、原始变量（或者它们的Wrapper Class）、XML 数据作为传入对象；2、通过配置文件载入映射文件；3、利用框架翻译成 JDBC 来访问数据库；4、执行结果可以是 JavaBean、Map 类型、原始变量的 Wrapper Class、XML 数据。

                              


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

把“ai.setOwnerNo(people)”注解了试试，由于 AutoInfo 没有主动维护关系，导致 AUTO_INFO 表中 OWNER_NO 字段为“Null”。自然 AutoInfo 与 Poople 就不存在任何联系了。

人类的求知欲很强烈！
为什么非要用 AutoInfo 作为主控方？People 作主控方不行？好吧，为 People.hbm.xml 删除inverse=”true”，再运行以上程序，其实也能保存，只是多了一条SQL：“update auto_info set OWNER_NO=? where AUTO_ID=?”，这就是 AutoInfo 被动地修改和 People 的联系。多执行一次 SQL 意味着多了一些开销，这是对性能不利的！

《我的 O/R Mapping 之旅(三)》，有一段对张三第二次买车的程序和描述：

AutoInfo ai = new AutoInfo();  People people = new People();  public void DoTest() {   try {       Configuration cfg = new Configuration().configure();       SessionFactory sessions = cfg.buildSessionFactory();       Session session = sessions.openSession();       Transaction tx = session.beginTransaction();       people =        (People) session         .find(          "from People where OWNER_ID=1")         .get(0);       ai.setLicensePlate("A00002");       ai.setOwnerNo(people);       people.getAutoInfoSet().add(ai);       session.save(people);       tx.commit();       session.close();   } catch (Exception e) {       System.out.println(e);   } }

《我的 O/R Mapping 之旅(四)》，删除 PEOPLE 表及其关联的 AUTO_INFO 表时，程序是没有错，不过有更简单的办法来删除：

try {    Configuration cfg = new Configuration().configure();    SessionFactory sessions = cfg.buildSessionFactory();    Session session = sessions.openSession();    Transaction tx = session.beginTransaction();    session.delete("from People where OWNER_ID=1");    tx.commit();    session.close();   } catch (Exception e) {    System.out.println(e);   }

Hibernate 中，要完成一次操作，可以有多种实现方式，哪种最好，就要靠自己定夺了。



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

市场是无情的，机遇和危机无处不在。张三在经历过生意红火之后，接下来的一年内生意场上连连告负，不得不把自己的摊子收缩一下。这第一件事要把跑运输的车卖掉，就是 那辆牌照为“ A00002”的 。

package com.dao; import java.util.*; import net.sf.hibernate.*; import net.sf.hibernate.cfg.*; import bo.*; public class Test {  AutoInfo ai;  People people;  public void DoTest() {   try {    Configuration cfg = new Configuration().configure();    SessionFactory sessions = cfg.buildSessionFactory();    Session session = sessions.openSession();    Transaction tx = session.beginTransaction();    ai =     (AutoInfo) session.find(      "from AutoInfo where LICENSE_PLATE='A00002'").get(      0);    people = ai.getOwnerNo();    people.getAutoInfoSet().remove(ai);    session.delete(ai);    tx.commit();    session.close();   } catch (Exception e) {    System.out.println(e);   }  } }

为什么要从 People 对象中移除某个 AutoInfo 对象？

    问得好！传统 JDBC 程序可以直接删除以“ A00002 ”为条件查询出的记录，这样没有问题。但如果在 Hibernate 中用同样的方式直接删除，会引起不小的麻烦：

net.sf.hibernate.ObjectDeletedException: deleted object would be re-saved by cascade (remove deleted object from associations): 2, of class: bo.AutoInfo

    造成无法删除的原因是 PEOPLE 和 AUTO_INFO 表存在着一对多（ one-to-many ）关系，想要从 AUTO_INFO 删除一条记录，就必须用 people.getAutoInfoSet().remove(ai) 方法为 People 移除以“ A00002 ”为条件查询出的 AutoInfo 对象，才能真正删除该 AutoInfo 对象。

    从张三的失落中回过头来，这次 Hibernate 之旅也即将结束了。最后要体验的是删除 PEOPLE 表及其关联的 AUTO_INFO 表。

package com.dao; import java.util.*; import net.sf.hibernate.*; import net.sf.hibernate.cfg.*; import bo.*; public class Test {  People people;  public void DoTest() {   try {    Configuration cfg = new Configuration().configure();    SessionFactory sessions = cfg.buildSessionFactory();    Session session = sessions.openSession();    Transaction tx = session.beginTransaction();    people =     (People) session.load(People.class,new Integer(1));    session.delete(people);    tx.commit();    session.close();   } catch (Exception e) {    System.out.println(e);   }  } }

    Hibernate 的优势又一次体现出来。我们只需把一对多（ one-to-many ）关系中“ one ”这方删除，与之相关联的所有其他记录会一并删除。

    最后，通过这次旅程，也算把 Hibernate 的特性体验了一把。作为一种 O/R Mapping 实现，它是很优秀的，希望我们都可以用好它。



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

    要让 Hibernate 跑起来，还要了解其中几个关键对象：

        net.sf.hibernate.cfg.Configuration 的实例负责管理 Hibernate 配置信息，比如数据库连接、数据库 dialect，还有最重要的映射文件初始化工作。

        程序为了得到 Session 实例，必须先要得到它的工厂 net.sf.hibernate.SessionFactory，SessionFactory 的实例由 Configuration 构造。

    net.sf.hibernate.Session 是一切数据库操作的基础，和 JDBC 的 Connection 意义一样，Session 实例由 SessionFactory 获得。

    net.sf.hibernate.Transaction 的实例由 Session 获得。Hibernate 不具备事务管理能力，Hibernate 将其委托给底层的 JDBC 或者 JTA，以实现事务管理和调度功能。在本文中使用 JDBC 事务管理。

把以上的知识串起来吧：

Configuration cfg = new Configuration().configure(); SessionFactory sessions = cfg.buildSessionFactory(); Session session = sessions.openSession(); Transaction tx = session.beginTransaction();

 
程序第一幕马上出场。

有位叫张三的人，他买了辆车。由于是第一次买车，进入车辆管理系统后要对AUTO_INFO 和 PEOPLE 表都进行 insert 操作。

形成的一对多（one-to-many）关系保存如下：

package com.dao; import java.util.*; import net.sf.hibernate.*; import net.sf.hibernate.cfg.*; import bo.*; public class Test {  List list;  AutoInfo ai=new AutoInfo();     People people=new People();  public void DoTest() {   try {    Configuration cfg = new Configuration().configure();    SessionFactory sessions = cfg.buildSessionFactory();    Session session = sessions.openSession();    Transaction tx = session.beginTransaction();        people.setAddress("中国");    people.setName("张三");    people.addToAutoInfoSet(ai);    ai.setLicensePlate("A00001");    ai.setOwnerNo(people);    session.save(people);    tx.commit();    session.close();   } catch (Exception e) {    System.out.println(e);   }  } }

    分别设置好 AutoInfo、People 对象属性后，调用 Session.save() 方法保存，然后事务提交，最后关闭 Session。好了，看看数据库吧，一切都已保存好了。

程序第二幕出场。

张三后来做生意，自己经营得很好，打算再买辆车跑运输。对于第二次买车，车辆管理系统的 PEOPLE 表原本已经记录了他的基本信息，遂不对 PEOPLE 表操作。只向 AUTO_INFO表 insert 一条车辆记录即可。

形成的一对多（one-to-many）关系保存如下：

package com.dao; import java.util.*; import net.sf.hibernate.*; import net.sf.hibernate.cfg.*; import bo.*; public class Test {  List list;  AutoInfo ai = new AutoInfo();  People people = new People();  public void DoTest() {   try {    Configuration cfg = new Configuration().configure();    SessionFactory sessions = cfg.buildSessionFactory();    Session session = sessions.openSession();    Transaction tx = session.beginTransaction();    people =     (People) session      .find(       "from People where OWNER_ID=1")      .get(0);    ai.setLicensePlate("A00002");    ai.setOwnerNo(people);    people.getAutoInfoSet().add(ai);    session.save(people);    tx.commit();    session.close();   } catch (Exception e) {    System.out.println(e);   }  } }

    session.find() 方法返回一个 List 接口的实例，里面封装着 PO，其中的 “from People where OWNER_ID=1” 就是大名鼎鼎的 HQL(Hibernate Query Language) 了，是不是很像 SQL 呢？PEOPLE 表和 AUTO_INFO 表存在一对多关系，也就需要 People 对象来持有多个 AutoInfo 对象（以 Set 接口的实例封装，参看People类源代码），再通过 people.getAutoInfoSet().add(ai) 为 AUTO_INFO 表添加一条新纪录。好了，执行完以后，再检查数据库吧。

这段代码

people = (People) session.find("from People where OWNER_ID=1").get(0);

可以和

people =(People) session.load(People.class,new Integer(1));

互换。在本例中 List 接口实例 size() 为 1，即其中只有一个 PO；而 session.load() 是根据持久对象和主键来返回相应 PO，也只是单个。所以这两种方式返回的都是相同 PO。采用哪种方式由你决定。

到这里，也许你会有这样的想法：“应该可以直接向 AUTO_INFO 表插入记录，不通过 People 对象中转，像写 SQL 一样 Easy。” 错了！以前直接写 SQL 是可以办到的，不过现在我们用的可是 Hibernate ，一切都要以对象行事，看见 ai.setOwnerNo(people) 了吗？传入参数是个 People 对象实例，不是简单的字段喔。

程序第三幕出场。

呵呵，这个第三幕是最简单的了，第一种一对多（one-to-many）的查询：

package com.dao; import java.util.*; import net.sf.hibernate.*; import net.sf.hibernate.cfg.*; import bo.*; public class Test {  List list;  AutoInfo ai = new AutoInfo();  People people = new People();  public void DoTest() {   try {    Configuration cfg = new Configuration().configure();    SessionFactory sessions = cfg.buildSessionFactory();    Session session = sessions.openSession();    List list =     session.find(      "select ai from AutoInfo as ai where ai.OwnerNo.Id=1");    for (int i = 0; i < list.size(); i++) {     ai=(AutoInfo)list.get(i);     System.out.println(ai.getLicensePlate());     people=ai.getOwnerNo();     System.out.println(people.getName());     System.out.println(people.getAddress());    }    session.close();   } catch (Exception e) {    System.out.println(e);   }  } }

  
    到了年底，查查张三一共有多少辆车。”select ai from AutoInfo as ai where ai.OwnerNo.Id=1”，这句 HQL 要找的是 AutoInfo 对象，而传统 SQL 这么写：“select p.name,p.address,ai.license_plate from people p,auto_info ai where p.owner_id=1”。由于 AUTO_INFO 表是“many”表，而 PEOPLE 表是“one”表，我的做法是以“many”表为基础返回它的多个 PO，其中再持有“one”表的信息。“ai.OwnerNo.Id=1”就是说通过主键参数为“1”的 PEOPLE 表记录来取出相应 AUTO_INFO 表记录。

对于一对多（one-to-many）关系，还有第二种查询方式：

package com.dao; import java.util.*; import net.sf.hibernate.*; import net.sf.hibernate.cfg.*; import bo.*; public class Test {  AutoInfo ai = new AutoInfo();  People people = new People();  public void DoTest() {   try {    Configuration cfg = new Configuration().configure();    SessionFactory sessions = cfg.buildSessionFactory();    Session session = sessions.openSession();    people = (People) session.load(People.class, new Integer(1));    Iterator iterator = people.getAutoInfoSet().iterator();    System.out.println(people.getName());    System.out.println(people.getAddress());    while (iterator.hasNext()) {     ai = (AutoInfo) iterator.next();     System.out.println(ai.getLicensePlate());    }    session.close();   } catch (Exception e) {    System.out.println(e);   }  } }

    people = (People) session.load(People.class, new Integer(1)) 取出单个 People 对象，其中持有以 Set 封装的若干 AutoInfo 对象实例，Iterator iterator = people.getAutoInfoSet().iterator() 把 Set 立即转化为 Iterator ，最后用 while (iterator.hasNext()) 循环取出其中的车牌号码。

    第一种一对多（one-to-many）的查询实际上我把它转换成了多对一（many -to- one）的查询。这种转换后有两个缺点：一、由 HQL 转为 SQL 输出时，打印的 SQL 条数多于直接一对多（one-to-many）关系查询；二、其中的 People 对象存在着大量冗余（只需要一个实例，结果取出了 List.size() 个相同的实例）。我们知道，数据库的性能是有限的，构造对象的代价是高昂的，所以应尽量减少不必要的性能开销。

    虽然我个人不建议把一对多（one-to-many）查询转换成多对一（many -to- one）查询，但事实上有些开发团队却乐意采用，即使他们知道性能有略微的降低。在还没有更深入研究之前，各位看官有何看法呢？


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

     在没有正式开始旅行之前，让我们区分几个名词。 POJO ：在 Hibernate 中代表包含 Seter 、 Geter 这些最基本操作的值对象。而 BO ：代表包含一些业务逻辑的值对象，它的作用域很大，也就是说 BO 在充当持久类的同时可以传到 UI 层。 PO ：代表持久对象，是纳入 Hibernate 管理框架中的，在一定程度上可以和值对象的概念互换，值对象经过 Hibernate 进行处理，就变成了 PO 。 Hibernate 配置文件： hibernate.cfg.xml 或 hibernate.properties ，不过推荐使用 XML 格式。映射文件 *.hbm.xml ：映射文件的作用是将 POJO 与关系型数据库数据相绑定，作为一个桥梁。另外，为数据库中的表进行手工编写映射文件可不是件好差事，幸好开源社区中也有一群同样想法的人，他们开发了 hibernateSynchronizer 映射工具，可到 http://www.binamics.com/hibernatesync/eclipse2.1/ 下载。

     好了，现在去 http://www.hibernate.org 下载 Hibernate 的开发包（目前的版本是 2.1.6 ）。接着打开 Eclipse 2.1 ，在更新管理器中安装 hibernateSynchronizer 。据说 Eclipse 3.0 已内置映射工具，不过我没有试。安装完毕后，新建一个 Web 应用程序 HibernateTest ，接着为这个应用程序添加 Hibernate 类库 hibernate-2.1.6\hibernate-2.1\hibernate2.jar 及其依赖类库、数据库连接包，强烈建议把 hibernate-2.1.6\hibernate-2.1\lib 下的所有类库全部加载，如下图：

    接着使用 hibernateSynchronizer 来生成 hibernate.cfg.xml 文件，新建—— > 其他—— >Hibernate Configuration File ，我使用的是 SQL Server 数据库，各项配置参数见下图：

     生成出来的 hibernate.cfg.xml 文件：

    在项目的 src 目录下新建四个包，分别是 bo 、 bo.base 、 bo.mapping 、 com.dao ，具体什么作用，到时候他们都会一一呈献。在开始映射文件前还要做一件事，为应用程序 HibernateTest 配置 hibernateSynchronizer ，我更喜欢自己写 DAO ，所以没有配置 Data Access Objects ，其他各项参数如下图：

      被映射的表 AutoInfo 结构如下， id 为其主键：

    新建—— > 其他—— >Hibernate Mapping File ，配置好参数再“ Refresh ”后，选择要映射的表，注意千万不要在 800*600 下映射文件！否则有些按钮不会出现，各项配置参数见下图：

       终于、终于，映射文件 AutoInfo.hbm.xml 终于出来了！

    需要修改一下 AutoInfo.hbm.xml 文件为其定义主键，把：

替换为：

    再接再厉，为映射文件生成 POJO。修改 hibernate.cfg.xml 文件在 </session-factory> 标签的上面加上刚才映射的文件 <mapping resource="bo/mapping/AutoInfo.hbm.xml" />。接着在“包资源管理器”中点击 AutoInfo.hbm.xml 右键，Hibernate Synchronizer——>Synchronize Files。再看看 src 中的包：

    O/R Mapping 的旅程先到这里吧，后面的路将会越来越坎坷！你准备好了吗？


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