用hbm2java生成Hibernate类

用hbm2java生成Hibernate类

czyczy 发表于 2006-03-02 02:15:53
作者:czyczy;John;Smart     来源:matrix.org.cn;onjava
评论数:4 点击数:2,553     投票总得分:14 投票总人次:4
关键字:hbm2java;Hibernate

摘要:

在本文中, 我们会介绍基于给定的SQL 模式,手工编写Hibernate 映射文件,并利用hbm2java工具生成Java类。尽管这样的选择通常只是约略的尝试, 但此方法的确在多数情况下有许多优势。
Hibernate 是流行的处理对象/关系持久化及查询的开源工具。 在Hibernate 中,数据库表与POJO(“plain old Java objects”,“普通Java对象”)类之间的映射是由一组XML 映射文件来配置的。  hbm2java 是把映射文件转化成POJO 类的代码生成器。它是Hibernate Tools 子项目的一部分, 可以从独立的Hibernate Extension下载包中得到。

版权声明:任何获得Matrix授权的网站,转载时请务必保留以下作者信息和链接
作者:John;Smart; czyczy(作者的blog: http://blog.matrix.org.cn/page/czyczy)
原文: http://www.onjava.com/pub/a/onjava/2005/12/14/hibernate-class-generation-with-hbm2java.html
译文: http://www.matrix.org.cn/resource/article/44/44248_hbm2java+Hibernate.html
关键字:hbm2java;Hibernate

对于管理Hiberante 映射文件,现有多种策略, 如:
·        一切手工编写
·        把xdoclet标记放在你的Java 类中, 让其生成相应的映射文件。
·        从SQL 模式(schema)生成Hibernate 映射文件和Java类。
·        手工编写Hibernate 映射文件, 并且从Hibernate 映射生成Java类和SQL模式。
·        基于给定的SQL 模式,手工编写Hibernate 映射文件,并利用hbm2java工具生成Java类。

在本文中, 我们会着眼于上述方法中的最后那种方法。尽管这样的选择通常只是约略的尝试, 但此方法的确在多数情况下有许多优势:
·        Hibernate 映射集中在映射文件中,而不是把这些信息散布在Java源代码中,这使维护变得更加容易。在某些情况下,XDoclet annotation 不支持所有在Hibernate映射模式中可用的功能,你还可通过映射获得更好的控制。
·        数据库模式可分开来维护,而不是从Java 类或Hibernate映射文件生成。这允许那些对Java/Hibernate不甚了解的数据库管理员(DBA)对数据库细节(索引,表空间,表类型等)本身有更好的控制。

由映射文件生成Java类

这种方式下,Hibernate映射文件主导着一切。所有的映射信息都集中在这些文件中, 就意味着不会在源代码中使用annotations。所有的持久化类都由hbm2java工具生成。之后,那些类就不能被修改。
此过程如图1所示。首先,你持有一组Hibernate映射文件。你或许也需要一个hbm2java配置文件,通常称之为hbm2java.xml。利用这两个引子,hbm2java工具为每个Hibernate映射文件生成一个或多个Java类。hbm2java配置文件对类生成过程的优化是有用的。

image
图1.用hbm2java工具将Hibernate映射生成Java类

        
一个简单类生成的例子

让我们从一个非常简单的例子开始。假设我们想映射一个BOOK的简单数据库表,表结构定义如下:

Column          |         Type                   | Modifiers
------------+-----------------------+-----------
BOOK_ID      | character(32)             | not null
BOOK_TITLE | character varying(80) | not null
BOOK_ISBN  | character varying(20) | not null


为了生成这个类, 我们可以使用以下的Hiberante映射文件。注意怎样利用元属性(meta-attriute)来添加注释或优化类的生成。
<?xml version="1.0"?>


<hibernate-mapping>

    <class name="Book" table="BOOK">
        <meta attribute="class-description">
            A Book business object.
            @author Duke
        </meta>
        <id name="id" type="string" unsaved-value="null" >
            <column name="BOOK_ID" sql-type="char(32)" not-null="true"/>
            <generator class="uuid.hex"/>
        </id>

        <property column="BOOK_NAME" name="name"/>
        <property column="BOOK_ISBN" name="isbn">
            <meta attribute="field-description"/>
            The unique ISBN code for this book.
            </meta>
        </property>
    </class>

</hibernate-mapping>


使用此映射文件,hbm2java会生成看起来象这样的类:
/**
* A Book business object.
* @author Duke
*/
public class Book {

    private String id;
    private String name;
    private String isbn;

    public Book() {
    }

    public String getId() {
        return id;
    }

    private void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    /**
     * The unique ISBN code for this book.
     */
    public String getIsbn() {
        return isbn;
    }

    public void setIsbn(String isbn) {
        this.isbn = isbn;
    }
}
        

为实际项目生成类

实际上,hbm2java被设计成用来把Hibernate映射文件转化成一组相应的Java类。如果你想在实际的应用程序中使用这种方法,很显然,对于所有的Hibernate映射文件一次性生成类会更为方便。最好的方法是把类生成结合进你的自动化构建过程中。
结合进Ant构建过程中使用Ant调用hbm2java是相当直接的。首先,你需要申明hbm2java任务(task)以便Ant可以调用它:
  
     <taskdef name="hbm2java"
                classname="net.sf.hibernate.tool.hbm2java.Hbm2JavaTask"
                classpathref="project.class.path"/>

  
接着,你要用到这个任务。例如,通过写一个目标(target)将源目录中的所有*.hbm.xml文件生成源代码。假设${src.hibernate}表示含有Hibernate映射文件的目录,${src.generated}就是你想放源代码的地方。这样Ant任务看起来就象是:
       <target name="codegen"
               description="Generate Java source code
                            from the Hibernate mapping files">
         <hbm2java output="${source.generated}">
           <fileset dir="${src.hibernate}">
             <include name="**/*.hbm.xml"/>
           </fileset>
         </hbm2java>
       </target>

  
用Maven 1 定制构建过程

为结合进Maven (  1.0)构建过程,你需要修改maven.xml文件。Maven代码就存放在这个文件中。脚本(script)主要检查了Hibernate映射文件自上次类生成后是否已被更改(使用uptodate 标记),如果没有,就调用此前所描述的Ant中的hbm2java任务。这种情况下,我们做了以下的假设:
·        hbm2java.xml配置文件应在src/hibernate目录中
·        Hibernate映射文件应在src/hibernate目录中
·        在src/generated/src/java目录下生成Java类
  
<goal name="generate-hibernate-classes">
    <ant:echo message="Hibernate class generation"/>

    <fileset dir="${basedir}/src" id="fileset.hbm.xml">
        <include name="**/*.hbm.xml"/>
    </fileset>

    <uptodate property="hibernateBuild.uptodate"
              targetfile="${maven.src.dir}/generated/hbm.jar">
       <srcfiles refid="fileset.hbm.xml"/>
    </uptodate>

    <j:set var="buildHibernateFiles"
           value="${hibernateBuild.uptodate}"/>

    <j:choose>
        <j:when test="${buildHibernateFiles != null}">
              <ant:echo message="Hibernate classes up to date"/>
        </j:when>
        <j:otherwise>
              <ant:echo message="Generating Hibernate classes to src/java"/>

              <ant:taskdef name="hbm2java"
                           classname="net.sf.hibernate.tool.hbm2java.Hbm2JavaTask"
                           classpathref="maven.dependency.classpath"/>

              <ant:hbm2java config="${maven.src.dir}/conf/hbm2java.xml"
                            output="${maven.src.dir}/generated/src/java" >
                  <ant:fileset dir="${maven.src.dir}/hibernate">
                      <ant:include name="**/*.hbm.xml"/>
                  </ant:fileset>
              </ant:hbm2java>

              <ant:jar jarfile="${maven.src.dir}/generated/hbm.jar">
                  <fileset refid="fileset.hbm.xml"/>
              </ant:jar>
        </j:otherwise>
    </j:choose>
</goal>
  

用Maven 2 定制构建过程

若碰巧你正使用Maven 2,事情就更简单一点了。把maven-antrun-plugin插件添加到pom.xml文件中,而不是在maven.xml文件中使用完整的goals属性(pre and post goals)。在此插件中的task那部分,你可以象上述那样直接调用Ant 任务。
<project...>
  <modelVersion>4.0.0</modelVersion>
  ...
  <build>
    ...
    <plugins>
       <plugin>
          <artifactId>maven-antrun-plugin</artifactId>
          <executions>
            <execution>
              <phase>generate-sources</phase>
              <configuration>
                <tasks>
                  <taskdef name="hibernatetool"
                           classname="org.hibernate.tool.ant.HibernateToolTask"
                           classpathref="maven.dependency.classpath"/>

                  <hbm2java output="src/generated">
                      <fileset dir="src/hibernate">
                          <include name="**/*.hbm.xml"/>
                      </fileset>
                  </hbm2java>
                </tasks>
              </configuration>
              <goals>
                <goal>run</goal>
              </goals>
            </execution>
          </executions>
        </plugin>
     </plugins>
  </build>
</project>
  
        
在Hibernate 3中使用hbm2java

Hbm2java 工具已经经受了Hibernate 3 的考验。hbm2java任务与其它相似的任务一起,被集成进了新版Hibernate 工具集中的hibernatetool任务(撰写此文时仍是alpha版)。Ant任务需要在类路径(class path)中查找以下的.jar 文件:
·        hibernate-tools.jar
·        velocity-1.4.jar
·        velocity-tools-generic-1.4.jar
·        jtidy-r8-21122004.jar
·        hibernate3.jar
·        JDBC drivers

这样一来,Ant任务就要作如下申明:
    <taskdef name="hibernatetool"
        classname="org.hibernate.tool.ant.HibernateToolTask"
        classpathref="maven.dependency.classpath"/>


最后,你在hibernatetool 任务中调用hbm2java任务,做法如下:
  
    <taskdef name="hibernatetool"
        classname="org.hibernate.tool.ant.HibernateToolTask"
        classpathref="maven.dependency.classpath"/>

    <hibernatetool destdir="src/main/generated/src/java">
        <configuration configurationfile="src/main/hibernate/hibernate.cfg.xml">
            <fileset dir="src/main/hibernate">
                <include name="**/*.hbm.xml"/>
            </fileset>
        </configuration>

        <hbm2java />
    </hibernatetool>

  
注意:尽管Hibernate 3版的工具是很有前途的,但它仍只是在alpha阶段,因此使用时务必小心为是。(译注:翻译此文时最新的Hibernate版本是3.1.2,Hibernate Tools的版本是3.1 beta 4)

定制生成的Domain类

现在你知道了怎样从Hibernate映射生成Java源代码, 那么下一步呢?
为了更加具体地讨论,我们将使用如图2 和3所描述的简单类模型。这个类模型表示Employee数据库。每个employee赋予一country,讲一种或多种language。每个country 也有一组国际机场(airport)。

image
图2. 示例应用程序的UML类图

image
图3. 示例中所用的数据库模式

有时,你可能想添加域逻辑到Domain类中。实际上,对多数人来说,生成Java类的主要缺点是Domain类变得相对被动,而且把业务逻辑方法加入生成的Domain类中并不容易,就如所论证的那样使它们更不接近“面向对象“。对这问题并没有一个万能的解决方案,但我们在此描述了一些可能的方法。
        
把代码放入映射文件: class-code元属性(meta attribute)
对于简单的方法,你可以用class-code元属性来在Hibernate映射文件中指定额外的Java代码。例如,假设我们想在country和airports间建立双向关系。只要我们想增加airport属性到Country 对象,我们就要确定在Airport对象中相应地增加country属性。我们可以这么做:
  
    <class name="Country" table="COUNTRY" dynamic-update="true">
        <meta attribute="implement-equals">true</meta>
        <meta attribute="class-code">
            <![CDATA[
                /**
                 * Add an airport to this country
                 */
                public void addAirport(Airport airport) {
                    airport.setCountry(this);
                    if (airports == null) {
                          airports = new java.util.HashSet();
                    }
                    airports.add(airport);
                }

            ]]>
        </meta>


        <id name="id" type="long" unsaved-value="null" >
            <column name="cn_id" not-null="true"/>
            <generator class="increment"/>
        </id>

           <property column="cn_code" name="code" type="string"/>
           <property column="cn_name" name="name" type="string"/>

          <set name="airports" >
            <key column="cn_id"/>
            <one-to-many class="Airport"/>
          </set>
    </class>
  

除了那些非常小的方法,这种做法并不是特别地令人满意:在XML文件里编写Java代码的做法很容易出错而且难于维护。
使用SQL表达式有时业务逻辑(特别地如果引入了聚合,求和,合计等运算)可能会更自然地用SQL表达式来定义:
  
    <property name="orderTotal" type="java.lang.Double"
              formula="(select sum(item.amount)
                        from item
                        where item.order_id = order_id)" />

  
在多数情况下这是非常好的解决方案。但是,必须注意的是每次Hibernate从数据库加载对象时都会执行查询的动作,这可能会对性能造成影响。

使用基类
你也可以用generated-class元属性来定义基类,hbm2java会用这些元属性生成基类,这样你就可以在所生成基类的子类中自由地添加业务逻辑。例如,我们可以在Country类上应用这种技术,就象下面所描述的:
  
    <class name="Country" table="COUNTRY" dynamic-update="true">
        <meta attribute="implement-equals">true</meta>
        <meta attribute="generated-class">CountryBase</meta>
        <meta attribute="scope-field">protected</meta>

        <id name="id" type="long" unsaved-value="null" >
            <column name="cn_id" not-null="true"/>
            <generator class="increment"/>
        </id>

           <property column="cn_code" name="code" type="string"/>
           <property column="cn_name" name="name" type="string"/>

          <set name="airports" >
            <key column="cn_id"/>
            <one-to-many class="Airport"/>
          </set>
    </class>
  

hbm2java生成CountryBase类,此类包含了所有在映射文件中描述的属性,getter,setter等。接着,你可以在Country的派生类中自由地添加业务逻辑,这些会被Hibernate使用并实例化,例如:
  
    public class Country extends CountryBase {
        /**
         * Add an airport to this country
         */
        public void addAirport(Airport airport) {
                airport.setCountry(this);
                if (getAirports() == null) {
                        setAirports(new java.util.HashSet());
                }
                getAirports().add(airport);
        }
    }

  
包装(Wrapper)或委派(Delegate)模式(Pattern)
对于更复杂的业务逻辑,你或许也想使用下列技术中的一种:
·        你可以定义“wrapper”或“delegate”类,这些类含有作为属性的Domain类,并且提供了指定域类额外的业务逻辑。
·        你可能更喜欢“服务(service)”或“外观(fa&ccedil;ade)”方法,“fa&ccedil;ade”对象(如无状态的会话EJB)提供了一套相关的业务服务来操作Domain对象。

结论
本文描述了我们用来管理Hibernate映射的一种方法, 这在我们所特定的环境中工作得很好。 当然,还有许多别的方法。或许本文会给你的项目提供一些想法,但无论你做什么, 总要使用最适合你项目的方法。

资源
·        Hibernate
·        Hibernate Tools
·        Ant
·        Hibernate Ant tool
·        Maven

John Ferguson Smart从1991起涉足IT行业, 99年开始从事J2EE的开发。 
©️2020 CSDN 皮肤主题: 大白 设计师:CSDN官方博客 返回首页