使用Hibernate来实现持久对象

最新推荐文章于 2018-07-13 23:52:36 发布

yukikaze

最新推荐文章于 2018-07-13 23:52:36 发布

阅读量971

点赞数

分类专栏： J2EE 开发文章标签： hibernate iterator string web应用开发数据库 import

J2EE 开发专栏收录该内容

6 篇文章 0 订阅

订阅专栏

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

对象、关系的映射（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驱动程序。

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

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