内容


使用 Hibernate 来实现持久对象

Comments

介绍

面向对象的开发方法是当今的主流,但是同时我们不得不使用关系型数据库,所以在企业级应用开发的环境中,对象、关系的映射(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获得本书的部分章节。

评论

添加或订阅评论,请先登录注册

static.content.url=http://www.ibm.com/developerworks/js/artrating/
SITE_ID=10
Zone=Java technology
ArticleID=52975
ArticleTitle=使用 Hibernate 来实现持久对象
publish-date=10132003