当您初次登录到 developerWorks 时，将会为您创建一份概要信息。您在 developerWorks 概要信息中选择公开的信息将公开显示给其他人，但您可以随时修改这些信息的显示状态。您的姓名（除非选择隐藏）和昵称将和您在 developerWorks 发布的内容一同显示。

所有提交的信息确保安全。

当您初次登录到 developerWorks 时，将会为您创建一份概要信息，您需要指定一个昵称。您的昵称将和您在 developerWorks 发布的内容显示在一起。

昵称长度在 3 至 31 个字符之间。您的昵称在 developerWorks 社区中必须是唯一的，并且出于隐私保护的原因，不能是您的电子邮件地址。

所有提交的信息确保安全。

My developerWorks:

我的通知：

退出

选择语言：

使用 Hibernate 来实现持久对象

陈亚强 (cyqcims@mail.tsinghua.edu.cn), 北京华园天一科技有限公司高级软件工程师

陈亚强：北京华园天一科技有限公司高级软件工程师，擅长J2EE技术，曾参与多个J2EE项目的设计和开发，对Web服务有很大的兴趣并且有一定的项目经验。热爱学习，喜欢新技术，曾参与多本图书的写作。好交朋友，您可以通过 cyqcims@mail.tsinghua.edu.cn和他联系。

简介： 对象、关系的映射（ORM）是一种耗时的工作，在 Java 环境下，有几种框架来表示持久数据，如实体 Bean、OJB、JDO、Hibernate 等。Hibernate 是一种新的 ORM 映射工具，它不仅提供了从 Java 类到数据表的映射，也提供了数据查询和恢复等机制。本文介绍怎么在 Web 应用开发中配置 Hibernate 的环境，并且使用 Hibernate 来开发一个具体的实例。

阅读本文前您需要以下的知识和工具：

Tomcat 5.09，可以从 www.apache.org下载；
Hibernate2.0 相关运行环境，可以从 http://hibernate.bluemars.net/下载；
至少一个数据库服务器并且有相关的 JDBC 驱动程序。

本文的参考资料见参考资料。

标记本文！

发布日期： 2003 年 10 月 13 日
级别： 初级
访问情况： 3445 次浏览
评论：

介绍

面向对象的开发方法是当今的主流，但是同时我们不得不使用关系型数据库，所以在企业级应用开发的环境中，对象、关系的映射（ORM）是一种耗时的工作。围绕对象关系的映射和持久数据的访问，在 Java 领域中发展起来了一些 API 和框架，下面分别简单介绍。

JDBC 可以说是访问持久数据层最原始、最直接的方法。在企业级应用开发中，我们可能使用 DAO（Data Access Object）模式来把数据访问封装起来，然后在其它的层中同一调用。这种方式的优点是运行效率最高，缺点是把 DAO 对象和 SQL 语言紧密耦合在一起使得在大项目中难以维护。但是不管怎么说，使用 JDBC 来直接访问持久数据层是当今企业级应用开发中使用最广泛的。

实体 Bean 是 J2EE 平台中用来表示和访问持久数据的方式。虽然实体 Bean 是一种方便快捷的方法，但是在运行时我们需要额外购买 EJB 容器（当然，如今也有免费的 EJB 容器，如 JBOSS），并且使用不同的应用服务器，需要重新书写不同的部署描述，使得在不同应用服务器下移植企业级应用会带来一些困难。

另外，在 Java 领域中，还有一些表示持久数据的框架，比如 JDO 和 OJB，在这里就不详细介绍了。

Hibernate 是一种新的 ORM 映射工具，它不仅提供了从 Java 类到数据表之间的映射，也提供了数据查询和恢复机制。相对于使用 JDBC 和 SQL 来手工操作数据库，使用 Hibernate，可以大大减少操作数据库的工作量。

Hibernate 可以和多种 Web 服务器或者应用服务器良好集成，如今已经支持几乎所有的流行的数据库服务器（达 16 种）。

下面我们来介绍怎么结合 Hibernate2.0 和 Apache Tomcat5.0 在 Web 应用中使用 Hibernate。

回页首

配置

1、下载安装 Tomcat，并且下载 Hibernate 的运行环境（主要包含一些 JAR 包）。

2、把要使用的数据库的 JDBC 驱动程序拷贝到 %TOMCAT_HOME%\common\lib 目录下。笔者使用的是 MYSQL，对应的驱动程序的 JAR 包为 mm.mysql-2.0.4-bin.jar。

3、在 Tomcat 的 Webapps 目录下新建一个 Web 应用，名字为 hibernate。

4、把 Hibernate 提供的 hibernate2.jar 和一些第三方的运行库拷贝到 hibernate\WEB\INF\lib 目录下。（这些第三方的运行库包含在下载的 Hibernate lib 目录下）

5、在 %TOMCAT_HOME%\conf\server.xml 中 Web 应用和数据源。在 server.xml 中加入以下的配置描述。

例程 1 配置 web 应用

<Context path="/hibernate" docBase="hibernate" debug="0"
reloadable="true" crossContext="true">
 <Resource name="jdbc/hibernate" auth="Container" type="javax.sql.DataSource"/>
     <ResourceParams name="jdbc/hibernate">
          <parameter>
             <name>factory</name>
              <value>org.apache.commons.dbcp.BasicDataSourceFactory</value>
          </parameter>
          <parameter>
            <name>driverClassName</name>
                  <value>org.gjt.mm.mysql.Driver</value>
          </parameter>
           <parameter>
                       <name>url</name>
                       <value>jdbc:mysql:///test</value>
         </parameter>
          <parameter>
                  <name>username</name>
                  <value>root</value>
          </parameter>
          <parameter>
            <name>password</name>
            <value></value>
          </parameter>
          <parameter>
            <name>maxActive</name>
            <value>20</value>
          </parameter>
         <parameter>
              <name>maxIdle</name>
              <value>10</value>
          </parameter>
          <parameter>
             <name>maxWait</name>
            <value>-1</value>
          </parameter>
    </ResourceParams>
  </Context>

在这里，配置了一个名为 hibernate 的 Web 应用，并且配置了一个数据源，数据源的 JNDI 名称为 jdbc/hibernate。您需要根据情况修改数据源的链接属性。

6、下一步就是书写 Hibernate 的配置描述符。可以使用 XML 的配置描述，也可以使用基于属性的配置描述。在这里使用基于 XML 的配置描述。在 hibernate\WEB-INF\classes 目录下新建一个 hibernate.cfg.xml 文件。然后加入例程 2 所示的内容。

 <!DOCTYPE hibernate-configuration
    PUBLIC "-//Hibernate/Hibernate Configuration DTD//EN"
    "http://hibernate.sourceforge.net/hibernate-configuration-2.0.dtd">
 <hibernate-configuration>
    <session-factory>
        <property name="connection.datasource">java:comp/env/jdbc/hibernate</property>
        <property name="show_sql">false</property>
        <property name="dialect">net.sf.hibernate.dialect.MySQLDialect</property>
        <!-- Mapping files -->

    </session-factory>
 </hibernate-configuration>

注意 connection.datasource 属性必须和 server.xml 中配置的数据源的属性一样。如果不是使用 MYSQL，那么需要更改 dialect 属性。

到现在，配置基本完成，下面我们来开发一个最简单的应用。

回页首

开发持久对象、编写映射描述

我们使用 hibernate 来封装一个简单的数据表。这个表的名字为 Courses，它有两个字段，一个是 ID，它是 Courses 表的主键；另一个是 name，表示 Courses 的名字。在数据库中使用以下的脚本来创建这个表：

create table Courses(CourseId varchar(32) not null, name varchar(32), constraint pk_Courses primary key (CourseId) );

接下来的任务就是为 Courses 表书写持久对象，如例程 3 所示。

例程 3 Courses 的持久对象（Courses.java）

 package com.hellking.study.hibernate;
 import java.util.Set;
 /**
 * 在 hibernate 中代表了 Course 表的类。
 */
 public class Course
 {
   /** 每个属性和表的一个字段对应 **/
   private String id;
   private String name;

   /**students 表示 course 中的学生，在后面才会用到，暂时不管 **/
   private Set students;
   	
    /** 属性的访问方法 **/
	 public void setId(String string) {
		 id = string;
	 }
	
	 public String getId() {
		 return id;
	 }
	
	 public void setName(String name)
	 {
		 this.name=name;
	 }
	 public String getName()
	 {
		 return this.name;
	 }
	 public void setStudents(Set stud)
	 {
		 this.students=stud;
	 }
	 public Set getStudents()
	 {
		 return this.students;
	 }
 }

可以看出，在 Course 类中也包含了两个属性，id 和 name，它的属性和表 Courses 的字段是一一对应的，并且类型一致。

书写好了持久对象，接下来的任务就是书写对象、关系映射描述。在 hibernate\WEB-INF\classes 目录下新建一个 Course.hbm.xml 描述文件，内容如例程 4 所示。

例程 4 Course.hbm.xml

 <?xml version="1.0"?>
 <!DOCTYPE hibernate-mapping PUBLIC
    "-//Hibernate/Hibernate Mapping DTD 2.0//EN"
    "http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd">
 <hibernate-mapping>
    <class
        name="com.hellking.study.hibernate.Course"
        table="Courses"
        dynamic-update="false"
    >
        <id
            name="id"
            column="CourseId"
            type="string"
            unsaved-value="any"
        >
            <generator class="assigned"/>
        </id>
        <property
            name="name"
            type="string"
            update="true"
            insert="true"
            column="Name"
        />
    </class>
 </hibernate-mapping>

在 Course.hbm.xml 映射文件中，指定了要映射的类和映射的表，并且指定了表的各个字段和 Java 对象中各个字段的映射关系，比如 Course 对象中的 id 属性对应了 Courses 表的 courseId 字段。

接下来的任务就是在 hibernate.cfg.xml 中指定这个映射关系。如下所示：

 <session-factory>
…
 <!-- Mapping files -->
 <mapping resource="Course.hbm.xml"/>
 </session-factory>

回页首

编写业务逻辑

到此，我们已经封装了一个名为 Courses 的表，并且配置完成。接下来的任务就是在 Web 应用开发中使用它们，为了演示在 Hibernate 中对数据库的不同类型的操作，我们开发的 Web 应用有以下的功能：

增加一个 Course；
删除一个 Course；
按照 Course 的名字进行模糊搜索；
查看系统中所有的 Course。

虽然我们可以直接在 JSP 中使用 hibernate，但是往往我们不这样，而是把这些业务逻辑封装在 JavaBean 中，然后在 JSP 中通过调用 JavaBean 以访问 Hibernate 封装的对象。

由于访问通过使用 hibernate 有一些共性的操作，在这里我们把这些共性的操作封装在一个专门的类中，这样其它的类可以继承它，如例程 5 所示。

例程 5 HibernateBase.java

 package com.hellking.study.hibernate;
 import net.sf.hibernate.*;
 import net.sf.hibernate.cfg.*;
 import java.util.*;
 import java.io.IOException;
 import java.io.PrintWriter;
 public abstract class HibernateBase
 {
	 protected SessionFactory sessionFactory;// 会话工厂，用于创建会话
    protected Session session;//hibernate 会话
    protected Transaction transaction; //hiberante 事务

    public HibernateBase()throws HibernateException
    {
    	 this.initHibernate();
    }
    // 帮助方法
    protected void initHibernate()
        throws HibernateException {
        // 装载配置，构造 SessionFactory 对象
        sessionFactory = new Configuration().configure().buildSessionFactory();
    }

    /**
     * 开始一个 hibernate 事务
     */
    protected void beginTransaction()
        throws HibernateException {
        session = sessionFactory.openSession();
        transaction = session.beginTransaction();
    }

    /**
     * 结束一个 hibernate 事务。
     */
    protected void endTransaction(boolean commit)
        throws HibernateException {
        if (commit) {
            transaction.commit();
        } else {
           // 如果是只读的操作，不需要 commit 这个事务。
            transaction.rollback();
        }
         session.close();
    }
 }

下面编写业务逻辑类，新建一个名为 CourseBean 的 JavaBean，并且 CourseBean 继承 HibernateBase 类，代码如例程 6 所示。

例程 6 CourseBean.java

 package com.hellking.study.hibernate;
 import net.sf.hibernate.*;
 import net.sf.hibernate.cfg.*;
 import java.util.*;
 /**
 * 和 course 相关的业务逻辑
 */
 public class CourseBean extends HibernateBase
 {
	 public CourseBean()throws HibernateException
	 {
		 super();
	 }
	 /**
	 * 增加一个 Course
	 */
	 public void addCourse(Course st)throws HibernateException
	 {
		 beginTransaction();
         session.save(st);
         endTransaction(true);
    }

    /**
     * 查询系统中所有的 Course，返回的是包含有 Course 持久对象的 Iterator。
     */
    public Iterator getAllCourses()throws HibernateException
    {
     	 String queryString = "select courses from Course as courses";
        beginTransaction();
        Query query = session.createQuery(queryString);
        Iterator it= query.iterate();
        return it;
    }

    /**
     * 删除给定 ID 的 course
     */
    public void deleteCourse(String id)throws HibernateException
    {
     	 beginTransaction();    	
     	 Course course=(Course)session.load(Course.class,id);    	
     	 session.delete(course);
     	 endTransaction(true);
     }

    /**
     * 按 course 的名字进行模糊查找，返回的是包含有 Course 持久对象的 Iterator。
     */
    public Iterator getSomeCourse(String name)throws HibernateException
    {
      	 String queryString = "select c from Course as c where c.name like :name" ;
         beginTransaction();
         Query query = session.createQuery(queryString);
         query.setString("name", "%"+name+"%");
        Iterator it= query.iterate();
        return it;
    }    	
 }

在 CourseBean 封装了 4 个业务方法，你可以根据情况增加其它的业务方法。在 CourseBean 中，通过 Hibernate 来操作潜在的数据库资源。

要保存 Course 数据到数据库，可以通过：

 session.save(Course);

方法来保存，它相当于使用在 JDBC 中执行以下语句：

Connection con= …
Statement stmt=con.createStatement();
stmt.executeUpdate("insert into courses values('" + 
    course.getId(),+"','"+course.getName()+"')");
con.close();

可以看出，通过使用 Hibernate，可以大大减少数据访问的复杂度。

回页首

在 JSP 中调用业务逻辑

添加数据

CourseBean 这个业务对象封装了和 Hibernate 的交互关系，从而使 JSP 和 Hibernate 关系的解藕。我们来看测试主页面的部分代码，如例程 7 所示。

例程 7 测试 Hibernate 开发的应用（course.jsp）

<%@ page import="java.sql.*,java.util.*" errorPage="error.jsp"%>
 <jsp:useBean id="course" class="com.hellking.study.hibernate.Course" 
     scope="page">
 <jsp:setProperty name="course" property="*"/>
 </jsp:useBean>
 <jsp:useBean id="courseBusiness" class="com.hellking.study.hibernate.CourseBean"
     scope="page"/>
 <html><body><center>
 <%
  try
  {
  if(course.getId().equals(null)||course.getId().equals(""));
  else courseBusiness.addCourse(course);

  %>
成功添加了 Course：<br>
 name：<%=course.getName()%>
 Id:<%=course.getId()%>
 <%
 }
  catch(Exception e)
  {
  }
 %>
 <hr>
 <br>:: 增加一个 course::<br>
 <form action="course.jsp" method="get" name="add">
 id:<input type=text name="id"><br>
 name:<input type=text name="name"><br>
 <input type=submit value="submit"><br>
 </form>
 <hr>
 :: 按名字模糊查找 ::<br>
 <form action="queryCourse.jsp" method="get" name="queryByName">
 name:<input type=text name="name"><br>
 <input type=submit value="query"><br>
 </form>
 <hr>
 :: 删除一个 Course::<br>
 <form action="deleteCourse.jsp" method="get" name="queryByName">
 id:<input type=text name="id"><br>
 <input type=submit value="delete"><br>
 </form>
 <hr>
 <a href=viewAll.jsp>:: 查看所有 Course::<a>
 </body>
 </html>

首先通过一个值对象 Course（这个类正好是 Hibernate 使用的持久对象，这里作为值对象来传递数据）接收获得的参数，然后 CourseBean 的 addCourse(Course) 方法把数据保存到数据库。可以看出，通过使用 Hibernate，把数据从表单中添加到数据库非常简单。

查询

下面来看模糊查找的 JSP 代码，如例程 8 所示。

例程 8 按名字模糊查找 Course

<%@ page import="java.sql.*,java.util.*,com.hellking.study.hibernate.Course" 
 errorPage="error.jsp"%>
 <jsp:useBean id="courseBusiness" class="com.hellking.study.hibernate.CourseBean" 
 scope="page"/>
…
 <% try
 {
   Iterator it=courseBusiness.getSomeCourse((String)request.getParameter("name"));
   while(it.hasNext())
   {
     Course temp=(Course)it.next();
     out.println("<tr><td>"+temp.getId()+"</td>");
     out.println("<td>"+temp.getName()+"</td></tr>");
   }
  }
  catch(Exception e)
  {
    out.println(e.getMessage());
   }
 %>
… .

它实际上调用的是 CourseBean 的 Iterator getSomeCourse(String name) 方法。我们来回顾一下这个方法中的代码：

 /**
     * 按 course 的名字进行模糊查找
     */
    public Iterator getSomeCourse(String name)throws HibernateException
    {
      	 String queryString = "select c from Course as c where c.name like :name" ;
        beginTransaction();
        Query query = session.createQuery(queryString);
         query.setString("name", "%"+name+"%");
        Iterator it= query.iterate();
        return it;
    }

在查询前，首先调用 beginTransaction 方法启动新的 Hibernate 事务，然后创建一个 Query 对象，在创建这个对象时，同时指定查询的语句。

注意，在查询语句：

 select c from Course as c where c.name like :name"

中，它虽然和普通的 SQL 语句相似，但是不同，在数据库中，使用的表的名字是 Courses，而在这个查询语句中使用的是 Course，它和持久对象的名字一致，也就是说，这个查询的概念是查询持久对象，而不是数据库的记录。

创建了查询对象 Query 后，需要设置查询的参数，它和在 JDBC 中 PreparedStatement 对象中设置参数的方法相似。通过"Iterator it= query.iterate()"语句来执行查询，并且返回一个 Iterator 对象。在这里使用了 Hibernate 提供的查询机制，一般的 JDBC 查询返回的是 ResultSet 对象，而这里返回的是包含了 CourseBean 对象的 Iterator。

要查询系统中所有的 Course，也同样非常简单，可以通过例程 9 所示的代码实现。

例程 9 查询数据库中所有的 Course

…
 <jsp:useBean id="courseBusiness" class="com.hellking.study.hibernate.CourseBean"
 scope="page"/>
…
 <% try
 {
   Iterator it=courseBusiness.getAllCourses();
   while(it.hasNext())
   {
     Course temp=(Course)it.next();
     out.println("<tr><td>"+temp.getId()+"</td>");
     out.println("<td>"+temp.getName()+"</td></tr>");
   }
  }
  catch(Exception e)
  {
    out.println(e.getMessage());
   }
 %>
…

实际上调用的是 CourseBean 的 getAllCourses 方法，它和 getSomeCourse 方法机制一样，就不再介绍了。

删除数据

在 JSP 中，使用以下的代码来执行删除操作。

例程 10 删除数据库中 Courses 表的记录

<jsp:useBean id="courseBusiness" class="com.hellking.study.hibernate.CourseBean"
    scope="page"/>
…
删除 id 为：<%=request.getParameter("id")%> 的 course：:::<br>
 <% try
 {
	 courseBusiness.deleteCourse(request.getParameter("id"));
	 out.println("删除成功");
 }
  catch(Exception e)
  {
    out.println("不存在这个记录");
   }
 %>

我们来看 CourseBean 中执行删除操作的具体代码：

 /**
     * 删除给定 ID 的 course
     */
    public void deleteCourse(String id)throws HibernateException
    {
    	 beginTransaction();    	
    	 Course course=(Course)session.load(Course.class,id);    	
    	 session.delete(course);
    	 endTransaction(true);
     }

在这个方法中，首先开始一个事务，然后通过 session.load(Course.class,id) 方法来装载指定 ID 的持久对象，接下来通过"session.delete(course)"来删除已经装载的 course，并且结束 Hibernate 事务。

回页首

总结

下面总结一下使用 Hibernate 的开发过程：

1、配置 Hibernate（一次即可）；

2、确定数据表；

3、创建持久对象；

4、编写对象和数据表的映射描述；

5、编写和业务逻辑。

实际上，上面的过程和使用 EJB 没有什么区别：在使用 EJB 时，首先当然也是配置环境，初始化数据表；然后创建实体 Bean（对象于 Hibernate 的持久对象）；接下来编写部署描述符（ejb-jar.xml，厂商专有的部署描述），在这些部署描述符里，指定了 EJB 和数据表的映射关系，如果多个实体 Bean 存在关联关系，需要描述它们之间的关系，这些描述对应于 Hibernate 中持久对象的描述，如 Course.hbm.xml；往往我们并不在应用程序中直接操作实体 Bean，而是通过业务对象（如会话 Bean）来操作，这里的会话 Bean 可以简单的和 Hibernate 中执行业务逻辑的 JavaBean 对应。这里只是简单的类比，不是绝对的，比如我们同样可以在会话 Bean 中访问 Hibernate 持久对象，也就是说使用 Hibernate，同样可以把业务逻辑放在会话 Bean 中。

通过本文的学习，相信读者对 Hibernate 已经有了初步的认识，并且能够使用 Hibernate 开发简单的应用。在下一篇中，我们将学习怎么使用 Hibernate 来为复杂的数据表进行映射，并且维护它们之间的关系。

参考资料

http://www.apache.org下载 Tomcat。
Hibernate 的官方网站， http://hibernate.bluemars.net/，包含了 Hibernate 最新资料。
Hibernate 中文论坛，hibernate.fankai.com 包含了 Hibernate 较多的参考资料。
包含了 Hibernate 技术讨论网站， www.jdon.com，
于 Hibernate、JDO、CMP 等技术的热烈讨论 1： http://www.jdon.com/jive/thread.jsp?forum=16&thread=6062&start=0&msRange=15
于 Hibernate、JDO、CMP 等技术的热烈讨论 2： http://www.theserverside.com/discussion/thread.jsp?thread_id=19732
Hibernate2 Reference Documentation，可以从 Hibernate 官方网站获得，非常好的参考资料。
Hibernate In Action，一本非常专业的 Hibernate 参考书，由 Hibernate 项目主要开发人员 Gavin King 等著，Manning 出版社出版。您可以从 http://www.theserverside.com获得本书的部分章节。