当前页面位置: » 丰搜网 » 文档中心 » 详细内容
struts处方:hibernate与struts
struts处方:hibernate与struts在struts应用程序里加入hibernate作者：george franciscus and danilo gurovich译者：katelin(e-mail： katelin2004@hotmail.com)版权声明：可以任意转载，转载时请务必以超链接形式标明文章原始出处和作者信息及本声明
作者:
george;danilo;katelin
原文地址:http://www.
javaworld.com/
javaworld/jw-01-2005/jw-0124-
strutshibernate.
html中文地址:http://www.matrix.org.cn/resource/article/43/43892_
hibernate_
struts.
html关键词：
hibernate struts摘要在这篇从
struts处方的摘录中，(manning publications，2004年12月)作者george franciscus和danilo gurovich举例描述了如何在一个
struts项目中使用
hibernate。他们同时也展示了如何建立一个
struts插件以改善性能(2200字，2005年1月24日)
持久层是一个应用系统最基本的部份。很显然的，如果没有持久层，所有的工作都将丢失。但是，对不同的人来说持久层意味着不同的东西。持久化时间的长短是选择持久层储存媒介的基本衡量标准之一。例如，对于生命周期为一个用户会话的数据来说，http session是非常合适的。与之对应的，跨越多个session，或者多个用户的持久化则需要一个
数据库来保持。数据的数量是另一个非常重要的衡量标准。例如，最佳实践表明大量的数据最好不要被存储在一个http会话中。在这些情况下，你都应该考虑使用
数据库。在这篇文章中，我们的目标就是
数据库持久层。
你选择的
数据库类型对你有架构与设计都有重要的影响。作为面向对象的开发人员，我们倾向于把数据描绘成描述手上商业问题的一组相互关联的对象—这常被称为域模型。 但是，最常用的存储媒介是基于关系模型的。除非我们的对象模型映射成一个关系结构，否则内存中我们数据的表示就会与持久化它的方法不一致。这个问题也被称作不对称问题。最流行的解决这种不对称问题的是一组被称为对象关系映射工具。一个orm工具是被用来把数据从对象
视图转换为关系型、提供诸如创建、读、更新、删除(crud)等持久性服务的软件。有许多的关于orm工具的论文，但是从本质上来说，他们谈论的都是对象映射
模式。最流行的orm工具是
开源的
hibernate工程。
在这篇文章中，我们展示了如何在一个
struts项目中应用
hibernate。另外，我们将展示如何建立一个
struts插件来提升你系统的性能。
处方在这个文摘中，我们使用一个例子来展示你在
struts项目中使用
hibernate时所需要的所有东西。我们将建立一个应用程序来获取和展示从化学元素周期表里取出的元素。这个应用程
序提供给用户一个查找页来通过元素符号来查找元素。应用程序将查询
数据库里匹配这个元素符号名的记录并返回查找到的元素信息来响应用户请求。
首先我们将展示如何启动hypersonic
服务器。当
数据库服务器启动后，我们建立示例程序所需要的表与数据。一旦
数据库准备运行了，我们将建立使用hypersonic
数据库服务器所需的
hibernate的所有东西。接下来的步骤是在action里调用
hibernate来处理
数据库读取来响应查询请求。因为建立
hibernate的factory对象是非常耗资源的，我们建立一个
struts plug-in来建立factory并把它保存在context里。
让我们从建立hypersonic
数据库服务器开始。你需要从http://hsqldb.sourceforge
.net/下载它。放置hsqldb.jar在你的classpath路径里，从dos窗口中敲入以下命令来启动hypersonic:
java org.hsqldb.server虽然不同版本的hypersonic的
服务器响应不同。下面的应答是典型的hypersonic已经准备好响应
数据库请求的应答：
server 1.6 is running
press [ctrl]+{c} to abort随着
数据库服务器的启动，我们可以建表和填充数据，如下列表1所示：
listing 1. 建立元素表
create table elements (id integer(3) identity,
name char(30),
number char(30),
mass char(30),
symbol char(2));
create unique index ui_elements_pk on elements (symbol)
insert into elements ( name, number, mass, symbol) values ('manganese','25','55','mn');
insert into elements ( name, number, mass, symbol) values ('zinc','30','65','zn');
insert into elements ( name, number, mass, symbol) values ('thulium','69','169','tm');
insert into elements ( name, number, mass, symbol) values ('californium','98','251','cf');
insert into elements ( name, number, mass, symbol) values ('gold','79','197','au');
insert into elements ( name, number, mass, symbol) values ('ytterbium','70','173','yb');
insert into elements ( name, number, mass, symbol) values ('molybdenum','42','96','mo');
insert into elements ( name, number, mass, symbol) values ('palladium','46','106','pd');
列表1是建立表的sql语句，在symbol列上建立唯一
索引，插入上面那些化学周期元素。当然你也可以从你高校的化学书本里面找出更多的一些数据插入。
列表2是用来存储从
数据库取出数据的
javabean对象：
listing 2.
javabean元素
package com.strutsrecipes.hibernate.beans;
public class element {
private string name;
private string symbol;
private string number;
private string mass;
private int id;
public element() {
super();
}
public element(string name, string symbol, string number, string mass) {
this.name = name;
this.symbol = symbol;
this.number = number;
this.mass = mass;
}
public int getid() {
return id;
}
public void setid(int id) {
this.id = id;
}
public string getmass() {
return mass;
}
public string getname() {
return name;
}
public string getnumber() {
return number;
}
public string getsymbol() {
return symbol;
}
public void setmass(string mass) {
this.mass = mass;
}
public void setname(string name) {
this.name = name;
}
public void setnumber(string number) {
this.number = number;
}
public void setsymbol(string symbol) {
this.symbol = symbol;
}
}
hibernate是一个对象-关系映射工具。它的任务是映射对象到关系型表,反之亦然。所以，我们必须告诉
hibernate如何映射列到
javabean的属性上。这个是通过element.hbm.
xml文件来完成的。这份文件里面包含的信息用来授予
hibernate从表里面拷贝数据到elements
javabean的权利。如果我们使用
hibernate来更新数据，element.hbm.
xml文件里的信息将被用来解析从elements
javabean来的数据来生成更新的sql语句。列表3显示了element.hbm.
xml。
listing 3. element.hbm.
xml <?xml version="1.0"?>
<!doctype hibernate-mapping public "-//hibernate/hibernate mapping dtd//en"
"http://hibernate.sf.net/hibernate-mapping-2.0.dtd">
<hibernate-mapping>
<class name="com.strutsrecipes.hibernate.beans.element" table="elements">
<id name="id" column="id">
<generator class="native"/>
</id>
<property name="name" column="name"/>
<property name="number" column="number"/>
<property name="mass" column="mass"/>
<property name="symbol" column="symbol"/>
</class>
</hibernate-mapping>
让我们跳到列表3
我们声明了与elements表相联系的类文件的完整的包名。然后我们声明了表的名字与这个类相关联。接下来我们声明从
javabean的id属性到表的id列的映射。因为property和column属性都有相同的值，我们本来可以忽略column属性，但是为了清晰起见，我们还是把column列出来。 <id>是个特殊的标签。它被用来声明表的主键。闭合的标签<generator>表示
hibernate以最适合
数据库实现的方式生成该主键。你可以参考
hibernate文档有关标签<id>的更多信息。最后我们为其它的
javabean属性做声明。为了清晰起见，column属性再次被声明。
一旦映射文件被详细的分析，那一切都非常的明晰了。它简单地声明了表与类的映射和
javabean属性与表的列名的映射。接下来我将告诉你在哪里放置这个文件。
接下来，我们通过声明环境信息来配置
hibernate。在列表4我们展示
hibernate.cfg.
xml文件。
listing 4.
hibernate.cfg.
xml<?xml version='1.0' encoding='utf-8'?>
<!doctype hibernate-configuration public "-//hibernate/hibernate configuration dtd//en"
"http://hibernate.sourceforge.net/hibernate-configuration-2.0.dtd">
<hibernate-configuration>
<session-factory>
<property name="dialect">.net.sf.hibernate.dialect.hsqldialect</property>
<property name="connection.driver_class">org.hsqldb.jdbcdriver</property>
<property name="connection.username">sa</property>
<property name="connection.password"></property>
<property name="connection.url">jdbc:hsqldb:hsql://127.0.0.1</property>
<property name="show_sql"> </property>
<property name="">true</property>
<mapping resource="/com/strutscookbook/hibernate/beans/element.hbm.xml"/>
</session-factory>
</hibernate-configuration>
让我们跳到列表4
我们以指定
数据库实现方言开始，允许
hibernate充分利用实现特殊化的属性。我们声明hypersonic方言。我们可以参考
hibernate文档以选择
数据库相应的方言。然后我们声明
数据库驱动。必须保证这个驱动在应用程序的classpath上。然后我们声明
数据库的用户名，
数据库密码，连接
数据库的url。接下来我们通知
hibernate在日志里显示运行时生成的sql语句。
hibernate.cfg.
xml文件必须被放在你的classpath里。
在你的程序里使用
hibernate必须有下面几个步骤：
1、 建立一个
hibernate configuration对象
2、 使用
hibernate configuration对象来建立一个
hibernate factory对象。
3、 使用
hibernate factory对象来建立一个
hibernate session对象。
4、 使用
hibernate session对象来开始一个事务(可选)
5、 使用
hibernate session对象来建立、读取、更新、删除
数据库里的数据
6、 提交事务（可选）
7、 关闭session
hibernate最佳实践是建立和缓存
hibernate factory来提高性能。所以我们最好在第一步和第二步建立一个
struts plug-in 来在
servlet context中缓存
hibernate factory。如list5所示：
listing 5.
hibernateplugin.
java package com.strutsrecipes.hibernate.plugin;
import java.net.url;
import javax.servlet.servletexception;
import.net.sf.hibernate.hibernateexception;
import.net.sf.hibernate.mappingexception;
import.net.sf.hibernate.sessionfactory;
import.net.sf.hibernate.cfg.configuration;
import org.apache.commons.logging.log;
import org.apache.commons.logging.logfactory;
import org.apache.struts.action.actionservlet;
import org.apache.struts.action.plugin;
import org.apache.struts.config.moduleconfig;
public class hibernateplugin implements plugin {
private configuration config;
private sessionfactory factory;
private string path = "/hibernate.cfg.xml";
private static class clazz = hibernateplugin.class;
public static final string key_name = clazz.getname();
private static log log = logfactory.getlog(clazz);
public void setpath(string path) {
this.path = path;
}
public void init(actionservlet servlet, moduleconfig modconfig)
throws servletexception {
try {
url url = hibernateplugin.class.getresource(path);
config = new configuration().configure(url);
factory = config.buildsessionfactory();
servlet.getservletcontext().setattribute(key_name, factory);
} catch (mappingexception e) {
log.error("mapping error", e);
throw new servletexception();
} catch (hibernateexception e) {
log.error("hibernate error", e);
throw new servletexception();
}
}
public void destroy() {
try {
factory.close();
} catch (hibernateexception e) {
log.error("unable to close factory", e);
}
}
}
建立一个
struts plug-in只需要两个步骤。第一，建立一个类的实现 org.apache.
struts.action。plugin(列表5)。第二，在
struts-config.
xml文件中定义<plug-in>标签(列表6)。
让我们跳到第5步：
我们创建一个常量来储存
servlet上下文属性键值的名字。这里我们选择
hibernateplugin这个类名。注意到这个常量必须是static public final的。我们使用
hibernateplugin类来取用action中这个关键字的值（列表7）。我们定义了path属性。默认的，
hibernate-plugin会在/
hibernate.cfg.ml文件里找
hibernate的配置。我们可以使用这个属性来从classpath里的其它任意路径或文件里加载
hibernate的配置。接下来，我们使用classloader来查找
hibernate配置文件，然后建立
hibernate configuration对象。我们使用
hibernate configuration对象来建立一个
hibernate factory对象，然后我们把这个
hibernate factory对象存在
servlet context中。这个factory现在便可以在
servlet的任意实例中使用了。
作为一个好的实践，应该在destroy方法里面关闭factory。
列表6展示了
struts-config应用程序。这里唯一与平常的不一样的地方是<plug-in>标签。我们在这里声明
hibernate plug-in，它将建立并且缓存
hibernate factory对象。
listing 6.
struts-config.
xml <?xml version="1.0" encoding="iso-8859-1" ?>
<!doctype struts-config public
"-//apache software foundation//dtd struts configuration 1.1//en"
"http://jakarta.apache.org/struts/dtds/struts-config_1_1.dtd">
<struts-config>
<form-beans>
<form-bean name="searchform"type="com.strutsrecipes.hibernate.forms.searchform"/>
</form-beans>
<global-forwards>
<forward name="search" path="/search.jsp"/>
<forward name="searchsubmit" path="/searchsubmit.do"/>
</global-forwards>
<action-mappings>
<action path="/searchsubmit"
type="com.strutsrecipes.hibernate.actions.searchaction"
name="searchform"
scope="request"
input="/search.jsp">
<forward name="success" path="/element.jsp"/>
</action>
</action-mappings>
<plug-in classname="com.strutsrecipes.hibernate.plugin.hibernateplugin">
<set-property property="path" value="/hibernate.cfg.xml"/>
</plug-in>
</struts-config>
列表7展示了用来查询一个元素的searchform。它非常的简单因为用户只能通过元素符号来查询。
listing 7. searchform.
java package com.strutsrecipes.hibernate.forms;
import org.apache.struts.action.actionform;
public class searchform extends actionform {
string symbol;
public string getsymbol() {
return symbol;
}
public void setsymbol(string symbol) {
this.symbol = symbol;
}
}
让我们来看一个列表8的searchaction。虽然我们也许会决定在系统架构的其它部份上使用
hibernate，在这里我们选择在action里面使用它。我们将推迟对其它选择的讨论到我们的讨论部份。
listing 8. searchaction.
java package com.strutsrecipes.hibernate.actions;
import java.util.list;
import javax.servlet.http.httpservletrequest;
import javax.servlet.http.httpservletresponse;
import org.apache.commons.logging.log;
import org.apache.commons.logging.logfactory;
import.net.sf.hibernate.hibernate;
import.net.sf.hibernate.hibernateexception;
import.net.sf.hibernate.session;
import.net.sf.hibernate.sessionfactory;
import org.apache.struts.action.action;
import org.apache.struts.action.actionerror;
import org.apache.struts.action.actionerrors;
import org.apache.struts.action.actionform;
import org.apache.struts.action.actionforward;
import org.apache.struts.action.actionmapping;
import com.strutsrecipes.hibernate.beans.element;
import com.strutsrecipes.hibernate.forms.searchform;
import com.strutsrecipes.hibernate.plugin.hibernateplugin;
public class searchaction extends action {
private static log log = logfactory.getlog(searchaction.class);
final public static string hql_find_element =
"from com.strutsrecipes.hibernate.beans.element as e where e.symbol = ?";
public actionforward execute(
actionmapping mapping,
actionform form,
httpservletrequest request,
httpservletresponse response)
throws exception {
searchform searchform = (searchform) form;
element element = null;
list elements = null;
sessionfactory factory = null;
session session = null;
try {
factory =
(sessionfactory) servlet.getservletcontext()
.getattribute(hibernateplugin.key_name);
session = factory.opensession();
elements = session.find(hql_find_element,searchform.getsymbol(),
hibernate.string);
if (!elements.isempty()) {
element = (element) elements.get(0);
}
} catch (hibernateexception e) {
log.error("hibernate error", e);
} finally {
log.error("hibernate exception encountered");
session.close();
}
if (element != null) {
request.setattribute("element", element);
return mapping.findforward("success");
}
actionerrors errors = new actionerrors();
errors.add(actionerrors.global_error,
new actionerror("error.notfound"));
saveerrors(request, errors);
return mapping.getinputforward();
}
}
让我们迅速的浏览一下在searchaction里面发生了什么。searchaction使用searchform.getsymbol()方法来获取用户在查询页面输入的元素符号。
hibernate被用来查找
数据库并且转换存在
数据库里的数据到一个element对象。这个element对象将被置于请求的下下文中以够
jsp页面使用。让我们跳到列表8来一行一行的详细看到底发生了什么。
首先，我们声明一个常量来搜索
数据库。接着我们将form转换为searchform，然后我们获得
hibernate factory。重新调用已经被创建而且缓存在
servlet上下文的factory。接下来，我们获得一个session。这个session包含了一个到
数据库的连接。
hibernate使用在列表4的配置信息来连接到
数据库。然后我们搜寻
数据库。
有其它的方法来使用
hibernate搜寻
数据库，但find方法无论一个查询是否有使用主键都非常的适合。注意，我们已经声明了hql_find_element常量。在这个常量里定义的sql看起来非常的像标准sql，但不完全。
hibernate使用的sql是
hibernate私有的，oo版本的sql语句。
深入研究
hibernate sql(hql)：
from com.strutsrecipes.hibernate.beans.element as e where e.symbol = ? 这个声明告诉
hibernate选择置于com.
strutsrecipes.
hibernate.beans包下的所有element对象。where子句来用过滤出元素符号匹配运行时参数的所有element对象。as e指明了e将被在hql的任何位置作为一个别名，正如我们已经在where子句里面做的那样。我们可以看到我们从
数据库里选择的是对象而不是行。
hibernate使用列表4里的信息来映射类到其对应的表。在这个例子里，表与对象之间的关系是非常接近的，但这并不是必须的。
find方法的第二个与第三个参数分别是hql替代参数的值与类型。
hibernate参考资料里描述了替换运行时参数的其它方法。
find方法总是返回一个list对象。在这个例子中，我们获得了包含element对象的一个list。这里我们可以确定最多一个实例被返回因为elements表在symbol列上有唯一性的
索引约束。（参列表1）
返回到列表8，我们拷贝list中的第一个元素的引用给变量element。为了处理任何
hibernate异常，我们记录异常并给用户显示一个“找不到”的消息。但是也许你想显示不同的提示信息或使用不同的异常处理。接着，我们关闭session。在finally区段关闭session保证即使在异常抛出的时候也也要关闭它。我们把element对象保存在request上下文中并且在最后找不到符号的时候建立了一个actionerror。为了完整起见，我们展示search。
jsp和element。
jsp（列表10）。
listing 9. search.
jsp <%@ page language="java" %>
<%@ taglib uri="/web-inf/struts-html.tld" prefix="html" %>
<html:html>
<body>
<h1>search for an element</h1>
<html:form action="/searchsubmit.do">
symbol <form:text property="symbol"/>
<html:submit value="search"/>
</html:form>
<html:errors/>
</body>
</html:html>
listing 10. element.jsp
<%@ page language="java" %>
<%@ taglib uri="/web-inf/struts-bean.tld" prefix="bean" %>
<%@ taglib uri="/web-inf/struts-html.tld" prefix="html" %>
<html:html>
<h1>periodic element</h1>
name: <bean:write name="element" property="name"/><br>
symbol: <bean:write name="element" property="symbol"/><br>
number: <bean:write name="element" property="number"/><br>
mass: <bean:write name="element" property="mass"/><br>
<html:link forward="search">search</html:link><p>
</html:html>
在把
hibernate投入使用前，参考
hibernate文档，确保所有
hibernate所需的jar文件都在classpath中。
讨论数据持久化是一项乏味而且费力的工作。让事情更糟糕的是，将基于对象的数据表现形式转化为关系型的或相反都必须付出相当大的努力。幸运的是，有许多优秀的对象-关系映射工具存在来减轻这种负担。在这个摘录中，我们探究了
hibernate – 方便
java程序员使用的，非常流行的
开源orm工具之一。
hibernate是一个功能非常强大的产品，还有一些未知的功能留给你们去发现。我们简单的例子只是关于读这个行为，但是crud里的其它功能也是一样的简单。功能性的更新和读取指定对象一样简单，调用
javabean setter，调用session的commit方法。
hibernate负责帮你生成sql语句并且更新
数据库。一个删除也是非常的简单—session.delete(element)便是所有要做的!最后建立只是需要初始化对象，调用setters方法，然后调用session.save(element)。
hibernate最佳实践推荐缓存
hibernate factory对象。我们选择通过
struts plug-in来建立并且缓存factory。你也可以选择使用其它方法在你的类里缓存它。
虽然这个摘录能很好的满足你的需要，它还有其它的一些缺点。第一，我们在
struts action里使用了
hibernate。迁移到其它的持久层
框架上便将需要我们改变每个使用
hibernate的action。第二，我们的持久层紧密的与表示层连接。这种关联使我们在其它表示层机制中没有重新使用持久层逻辑的机会，例如批处理程序。
虽然有许多改进的空间，当你不需要重用表现层的时候，这个摘录还是很适合的。
关于作者george franciscus是一个
j2ee顾问和
struts权威。他也是manning’s
struts in action的合著者。
danilo gurovich是一家电子商务公司的
web工程师经理。他曾经设计电子商务和erp/eai
struts应用程序，而且领导团导实践了他们。
资源·这篇文章摘录自
struts recipes，george franciscus and danilo gurovich (manning publications, december 2004; isbn: 1932394249):
http://www.manning.com/franciscus
·
hibernate 主页:
http://www.
hibernate.org/
·
hibernate in action, christian bauer, gavin king (manning publications, august 2004; isbn: 193239415x):
http://www.amazon.com/exec/obidos/asin/193239415x/
javaworld
·来自
hibernate in action的摘录: "get started with
hibernate," christian bauer, gavin king (
javaworld, october 2004):
http://www.
javaworld.com/
javaworld/jw-10-2004/jw-1018-
hibernate.
html ·关于数据映射
模式的更多消息，请参阅martin fowler 所著的patterns of enterprise application architecture,(addison-wesley, november 2002; isbn: 0321127420):
http://www.amazon.com/exec/obidos/asin/0321127420/
javaworld
·关于
struts的更多信息，请参阅puneet agarwal 所著的"
struts best practices" (
javaworld, september 2004):
http://www.
javaworld.com/
javaworld/jw-09-2004/jw-0913-
struts.
html ·also check out "jump the hurdles of
struts development," michael coen and amarnath nanduri (
javaworld, april 2003):
http://www.
javaworld.com/
javaworld/jw-04-2003/jw-0418-
struts.
html ·关于
struts 与
hibernate的更多信息，参阅"design a simple service-oriented
j2ee application framework" by fangjian wu (
javaworld, october 2004):
http://www.
javaworld.com/
javaworld/jw-10-2004/jw-1004-soa.
html ·关于持久化的更多信息, 参阅 the persistence section of
javaworld's topical index:
http://www.
javaworld.com/channel_content/jw-persistence-index.s
html ·matrix-中文
java开发者社区:http://www.matrix.org.cn
