作者：陈亚强 来自：ibm
对象、关系的映射（orm）是一种耗时的工作，在java环境下，有几种框架来表示持久数据，如实体bean、ojb、jdo、hibernate等。hibernate是一种新的orm映射工具，它不仅提供了从java类到数据表的映射，也提供了数据查询和恢复等机制。本文介绍怎么在web应用开发中配置hibernate的环境，并且使用hibernate来开发一个具体的实例。
介绍
面向对象的开发方法是当今的主流，但是同时我们不得不使用关系型数据库，所以在企业级应用开发的环境中，对象、关系的映射（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来为复杂的数据表进行映射，并且维护它们之间的关系。
闽公网安备 35060202000074号