<filter>
<filter-name>OpenSessionInViewFilter</filter-name>
<filter-class>org.springframework.orm.hibernate3.support.OpenSessionInViewFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>OpenSessionInViewFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
<filter>
<filter-name>struts2</filter-name>
<filter-class>org.apache.struts2.dispatcher.FilterDispatcher</filter-class>
</filter>
<filter-mapping>
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
]]>
JavacM字段的类型ؓ java.util.Date
<property name="createdDate" type="timestamp" >
<column name="CREATED_DATE" />
</property>
映射文g中property元素的type属性gؓ timestamp .
]]>
<class name="org.gecs.hibernate.test.AdDepartment" table="AD_DEPARTMENT" schema="BARCODE"
dynamic-insert="true" dynamic-update="true">
<id name="adDepartmentId" type="long">
<column name="AD_DEPARTMENT_ID" precision="22" scale="0" />
<generator class="sequence">
<param name="sequence">AD_DEPARTMENT_SEQ</param>
</generator>
</id>
<property name="departmentName" type="string">
<column name="DEPARTMENT_NAME" length="50" not-null="true" />
</property>
<property name="active" type="java.lang.Character" insert="false" update="true">
<column name="ACTIVE" length="1" />
</property>
<property name="createdTime" type="date" insert="false" update="false">
<column name="CREATED_TIME" length="7" />
</property>
<property name="createdUser" type="string">
<column name="CREATED_USER" length="20" not-null="true" />
</property>
<many-to-one name="parentDepartment" column="PARENT_DEPARTMENT_ID"/>
<set name="childDepartment" cascade="save-update" lazy="true" inverse="true">
<key column="PARENT_DEPARTMENT_ID"/>
<one-to-many class="org.gecs.hibernate.test.AdDepartment"/>
</set>
</class>
</hibernate-mapping>
表结构：
AdDepartment department = new AdDepartment();
department.setDepartmentName("華南資訊?);
department.setCreatedUser("bob");
AdDepartment child_department = new AdDepartment();
child_department.setDepartmentName("PCBA應用pȝ?);
child_department.setCreatedUser("bob");
child_department.setParentDepartment(department);
//
department.getChildDepartment().add(child_department);
Transaction tran = session.beginTransaction();
session.save(department);
//session.save(child_department);
tran.commit();
}
效果Q?/span>
]]>
http://sourceforge.net/projects/hibernate/files/
先决条gQ?/font>
已经安装?/span>ant?/span>MySQL数据库，数据库表已经建立?/span>
1?span style="font-family: 'Times New Roman'; font-style: normal; font-variant: normal; font-weight: normal; font-size: 7pt; line-height: normal; font-size-adjust: none; font-stretch: normal;"> ?/span>Hibernate官方|站下蝲Middlegen-Hibernate?/span>hibernate-extensionsQƈ解压?/span>
2?span style="font-family: 'Times New Roman'; font-style: normal; font-variant: normal; font-weight: normal; font-size: 7pt; line-height: normal; font-size-adjust: none; font-stretch: normal;"> 配置Middlegen-Hibernate:
2.1 配置数据库连?/span>
假设q接的数据库?/span>MySQLQ在Middlegen-Hibernate-r5\config\database目录中有一?/span>mysql.xml文gQ是用来配置MySQL数据库的q接的。内容ؓQ?/span>
<property name="database.script.file" value="${src.dir}/sql/${name}-mysql.sql"/>
<property name="database.driver.file" value="${lib.dir}/mysql-connector-java-3.0.15-ga-bin.jar"/>
<property name="database.driver.classpath" value="${database.driver.file}"/>
<property name="database.driver" value="org.gjt.mm.mysql.Driver"/>
<property name="database.url" value="jdbc:mysql://localhost/jboss"/>
<property name="database.userid" value="jboss"/>
<property name="database.password" value="jboss"/>
<property name="database.schema" value=""/>
<property name="database.catalog" value=""/>
<property name="jboss.datasource.mapping" value="mySQL"/>
?/span>mysql-connector-java-3.0.15-ga-bin.jar拯?/span>${lib.dir}Q也是Middlegen-Hibernate-r5\lib目录?/span>
修改配置文g中的数据库连接项?/span>database.url?/span>database.userid?/span>database.userid ?/span>Middlegen-Hibernate可以扑ֈ数据库?/span>
2.2 配置Middlegen-Hibernate-r5?/span>antq行文gbuild.xml
<!DOCTYPE project [
<!ENTITY database SYSTEM "file:./config/database/mysql.xml">
]>
指出使用的数据库配置文g?/font>
<project name="Middlegen Hibernate" default="all" basedir=".">
<property file="${basedir}/build.properties"/>
<property name="name" value="hibernatesample"/>
指出你的应用名称?/font>
<property name="build.gen-src.dir" value="C:/sample"/>
指出hbm的输\径?/span>
<hibernate
destination="${build.gen-src.dir}"
package="org.hibernate.sample"
genXDocletTags="false"
genIntergratedCompositeKeys="false"
javaTypeMapper="middlegen.plugins.hibernate.HibernateJavaTypeMapper"
/>
指出hbm所在的包的位置?/span>
指出hbm.xml中是否需?/span>XDoclet Tags?/span>
3?span style="font-family: 'Times New Roman'; font-style: normal; font-variant: normal; font-weight: normal; font-size: 7pt; line-height: normal; font-size-adjust: none; font-stretch: normal;"> q行Middlegen-Hibernate:
?/span>Middlegen-Hibernate目录下运?/span>antQ进?/span>Middlegen-Hibernate的图形界面。可以设|表Q和字段的特性。然后按GenarateQ?/span>hbm.xml文g?/span>
4?span style="font-family: 'Times New Roman'; font-style: normal; font-variant: normal; font-weight: normal; font-size: 7pt; line-height: normal; font-size-adjust: none; font-stretch: normal;"> 配置hibernate-extensions
?/span>hibernate-extensions-2.1.2\tools\bin目录有一?/span>setenv.bat文gQ改变其内容为：
set JDBC_DRIVER=C:\java\Middlegen-Hibernate-r5\lib\mysql-connector-java-3.0.15-ga-bin.jar
set HIBERNATE_HOME=C:\java\hibernate-2.1.6
set CORELIB=%HIBERNATE_HOME%\lib
set LIB=..\lib
set PROPS=%HIBERNATE_HOME%\src
set CP=%JDBC_DRIVER%;%PROPS%;%HIBERNATE_HOME%\hibernate2.jar;%CORELIB%\commons-logging-1.0.4.jar;%CORELIB%\commons-collections-2.1.1.jar;%CORELIB%\commons-lang-1.0.1.jar;%CORELIB%\cglib-full-2.0.2.jar;%CORELIB%\dom4j-1.4.jar;%CORELIB%\odmg-3.0.jar;%CORELIB%\xml-apis.jar;%CORELIB%\xerces-2.4.0.jar;%CORELIB%\xalan-2.4.0.jar;%LIB%\jdom.jar;%LIB%\..\hibernate-tools.jar
注意U色字体提示的均是\径和JAR文g名，一定要正确?/span>
5、运?/span>hibernate-extensionsQ根?/span>hbm.xml产生POJO文g
?/span>DOS中运?/span>hbm2java c:\sample\org\hibernate\sample\*.xml --output=c:\sample\轉自Qhttp://www.aygfsteel.com/relax/archive/2005/03/01/1588.html
]]>
]]>
q么做，因ؓ多对多的单向关系可以用多对一或者一对多的半向关pL表达Q不必要d一?br /> 辅助表）Q如学生与课E之_一个学生对应多个课E，一个课E也可以被多个学生选择?/p>
Student.hbm.xml
...
<hibernate-mapping>
<class name="model.Student" table="student">
<id name="id" unsaved-value="null">
<generator class="uuid.hex"/>
</id>
<property name="name" type="string"/>
<set name="courses"
table="student_course"
cascade="save-update"
>
<key column="stu_id"/>
<many-to-many class="model.Course
column="course_id"/>
</set>
<class>
</hibernate-mapping>
多对多关p需要配|的属性比较多一些。初学者经怼?lt;key column=""/>?lt;column="">的?br />
弄反了，其实只要C一个原则：<key column="">L和本w类的主键id对应Q?lt;column="">
L与关联类的主键id相对应。对于上面的Student.hbm.xml,兌cLCourse,本ncd是Student
Course.hbm.xml
...
<hibernate-mapping>
<class name="model.Course" table="course">
<id name="id" unsaved-value="null">
<generator class="uuid.hex"/>
</id>
<propery name="name" type="string"/>
<set name="students"
table="student_course"
cascade="save-update"
>
<key columm="course_id"/>
<many-to-many class="model.Student"
column="stu_id"/>
</set>
</class>
</hibernate-mapping>
注意QStudent与Course的cascade都设|ؓsave-updateQ在多对多的关系中，all,delete{?br />
cascade是没有意义的Q因为多对多关系中，q不能因为父对象被删除，而造成被包括的子对?br />
被删除，因ؓ可能q有其他的父对象参考了q个子对象?/span>
另外Q在多对多关pMQ如果双斚w有控制权Q也是双方都没有设|inverse="true"Q，?br /> 双方都要把关联关pd映到数据库。必d某一方设|inverse="true"Q然后在执行语句时?br /> L方进行操作（也就是没有设|inverse="true"的那一方）?/strong>
]]>
Hibernate3支持DetachedCriteriaQ这是一个非常有意义的特性！我们知道Q在常规的Web~程中，有大量的动态条件查询，即用户在|页上面自由选择某些条gQ?a class="bluekey" target="_blank">E序Ҏ用户的选择条gQ动态生成SQL语句Q进行查询?
针对q种需求，对于分层应用E序来说QWeb层需要传递一个查询的条g列表l业务层对象Q业务层对象获得q个条g列表之后Q然后依ơ取出条Ӟ构造查询语句。这里的一个难Ҏ条g列表用什么来构造？传统上用MapQ但是这U方式缺陷很大，Map可以传递的信息非常有限Q只能传递name和valueQ无法传递究竟要做怎样的条件运，I竟是大于，于QlikeQ还是其它的什么，业务层对象必ȝ切掌握每条entry的隐含条件。因此一旦隐含条件改变，业务层对象的查询构造算法必ȝ应修改，但是q种查询条g的改变是隐式U定的，而不是程序代码约束的Q因此非常容易出错?
DetachedCriteria可以解决q个问题Q即在web层，E序员用DetachedCriteria来构造查询条Ӟ然后这个DetachedCriteria作ؓҎ调用参数传递给业务层对象。而业务层对象获得DetachedCriteria之后Q可以在session范围内直接构造CriteriaQ进行查询。就此，查询语句的构造完全被搬离到web层实玎ͼ而业务层则只负责完成持久化和查询的封装即可，与查询条件构造完全解耦，非常完美Q这恐怕也是以前很多企囑֜web层代码中构造HQL语句的h惛_现的梦想吧！
CZ代码片段如下Q?
web层程序构造查询条Ӟ
java代码:
| DetachedCriteria detachedCriteria = DetachedCriteria.forClass(Department.class); detachedCriteria.add(Restrictions.eq("name", "department")).createAlias("employees", "e").add(Restrictions.gt(("e.age"), new Integer(20))); |
Department和Employee是一对多兌Q查询条件ؓQ?
名称?#8220;department”开发部门；
部门里面的雇员年龄大?0岁；
业务层对象用该条g执行查询Q?
java代码:
| detachedCriteria.getExecutableCriteria(session).list(); |
最大的意义在于Q业务层代码是固定不变的Q所有查询条件的构造都在web层完成，业务层只负责在session内执行之。这样代码就可放之四皆准，都无M改了?br />
然而Spring和Hibernate3的DetachedCriteria有不兼容的问题，因此在Spring环境下面使用Hibernate3需要注意：
Spring的HibernateTemplate提供了Hibernate的完封装，即通过匿名cd现回调，来保证Session的自动资源管理和事务的管理。其中核心方法是Q?
java代码:
| HibernateTemplate.execute(new HibernateCallback() { public Object doInHibernate(Session session) throws HibernateException { .... } } |
回调Ҏ提供了session作ؓ参数Q有了sessionQ就可以自由的用Hibernate API~程了。用了spring的之后，代码修改如下Q?
web层代码：
java代码:
| DetachedCriteria detachedCriteria = DetachedCriteria.forClass(Department.class); detachedCriteria.createAlias("employees", "e").add(Restrictions.eq("name", "department")).add(Restrictions.gt(("e.age"), new Integer(20))); departmentManager.findByCriteria(detachedCriteria); |
构造detachedCriteriaQ作为参C递给departmentManager
业务层代码用springQDepartmentManager的findByCriteria如下Q?
java代码:
| public List findByCriteria(final DetachedCriteria detachedCriteria) { return (List) getHibernateTemplate().execute(new HibernateCallback() { public Object doInHibernate(Session session) throws HibernateException { Criteria criteria = detachedCriteria.getExecutableCriteria(session); return criteria.list(); } }); } |
实际上也是Q?
java代码:
| Criteria criteria = detachedCriteria.getExecutableCriteria(session); return criteria.list(); |
而已
但是该程序代码执行，会抛出强制类型{换异常！
我跟t了一下spring和Hibernate源代码，原因如下Q?
spring的HibernateTemplate的executeҎ提供的回调接口具有Session作ؓ参数Q但是实际上Q默认情况下QHibernateTemplate传递给回调接口的sessionq不是org.hibernate.impl.SessionImplc，而是SessionImplcȝ一个ProxycR之所以替换成Z个Proxyc，HibernateTemplate的注释说明，Proxy提供了一些额外的功能Q包括自动设|CachableQTransaction的超时时_Session资源的更U极的关闭等{?
java代码:
| private boolean exposeNativeSession = false; ... |
executeҎ内部Q?
| Session sessionToExpose = (exposeNativeSession ? session : createSessionProxy(session)); |
但是遗憾的是QHibernate的DetachedCriteria的setExecutableCriteriaҎ却要求将session参数强制转ؓSessionImplQ但是spring传过来的却是一个Proxyc，因此报错了?
java代码:
| public Criteria getExecutableCriteria(Session session) { impl.setSession( (SessionImpl) session ); // 要求SessionImplQSpring传递的是Proxy return impl; } |
解决ҎQ禁止Spring的HibernateTemplate传递Proxyc，强制要求它传递真实的SessionImplc，即给exexuteҎ增加一个参敎ͼ提供参数为trueQ如下：
java代码:
| public List findByCriteria(final DetachedCriteria detachedCriteria) { return (List) getHibernateTemplate().execute(new HibernateCallback() { public Object doInHibernate(Session session) throws HibernateException { Criteria criteria = detachedCriteria.getExecutableCriteria(session); return criteria.list(); } }, true); } |
]]>
一对多、多对多Q末端ؓ多）的情况：在集合的配置中设|，?set ZQ如下所C：
<set name="students" inverse="true" cascade="all" lazy="false" batch-size="2" ><!-- 一对多的gq加载设|?-->
<key>
<column name="TEAMID" length="32" not-null="true" />
</key>
<one-to-many class="edu.dgut.ke.model.Student" />
</set>
一对一、多对一Q末端ؓ一Q的情况Q如果要Ҏ端ؓ一的关联设|批量加载，要在“一”q端的配|文件中q行讄Q比如学生对w䆾证，要实现对班的批量加载，应设|如?br />
<class name="edu.dgut.ke.model.Certificate" table="CERTIFICATE" lazy="true" batch-size="10" >
试例子
List list = session.createQuery("from Student").list();
HibernateSessionFactory.closeSession();
QStudent对Certificate是采用立卛_载策略）
控制台输?/u>
Hibernate: select student0_.ID as ID0_, student0_.cardId as cardId0_, student0_.TEAMID as TEAMID0_, student0_.STUDENTNAME as STUDENTN4_0_ from STUDENT student0_
Hibernate: select certificat0_.ID as ID1_0_, certificat0_.`DESCRIBE` as DESCRIBE2_1_0_ from CERTIFICATE certificat0_ where certificat0_.ID in (?, ?, ?, ?, ?, ?)
]]>
1.不管Acdproperty1在配|文仉是什么策?可能是预先抓?立即或gq检?它们都失?,q时都采用HQL指定的左外连?左外q接必定会初始化property1属?或对?,但是如果配置文g里对property1的检索策略是延迟加蝲,Acd 到对properyt1的引?Z得到q个引用,需要再ơ发送一条SQL语句来确立这U引用关p?q种情况在property1为集合时l常出现.
2.Acd配置文g中设|的对property2的预先抓取策略将被忽?/strong>(不管q个{略是fetch或是select),对property2有媄响的讄是立卛_延迟加蝲,hibernate只看得到q两U策?所以在使用语句"from A as a left outer join a.property1"?property2的加载策略将仅由lazy="true"或者是lazy="false"来决?nbsp;
Team.hbm.xml
... ...
<set name="students" inverse="true" cascade="all" lazy="true" fetch="join"><!-- 一对多的gq加载设|?-->
<key>
<column name="TEAMID" length="32" not-null="true" />
</key>
<one-to-many class="edu.dgut.ke.model.Student" />
</set>
... ...
Student.hbm.xml
... ...
<many-to-one name="certificate"
class="edu.dgut.ke.model.Certificate"
unique="true"
column="cardId"
cascade="all"
lazy="false"
fetch="join">
</many-to-one>
<many-to-one name="team" class="edu.dgut.ke.model.Team" fetch="join">
<column name="TEAMID" length="32" not-null="true" />
</many-to-one>
... ...
试代码
Session session = HibernateSessionFactory.getSession();
List list = session.createQuery("from Student as s left join s.team").list();
HibernateSessionFactory.closeSession();
//list 包括两个长度?的数l?每一个数l中包括一个学生对象和一个班U对?br />
Object[] stuAndTeam1 = (Object[]) list.get(0);
Student stu = (Student) stuAndTeam1[0];
System.out.println(stu.getStudentname());
System.out.println(stu.getTeam().getTeamname());
System.out.println(stu.getTeam().getStudents().size());
Hibernate: select student0_.ID as ID0_0_, team1_.ID as ID2_1_, student0_.cardId as cardId0_0_, student0_.TEAMID as TEAMID0_0_, student0_.STUDENTNAME as STUDENTN4_0_0_, team1_.TEAMNAME as TEAMNAME2_1_ from STUDENT student0_ left outer join TEAM team1_ on student0_.TEAMID=team1_.ID
Hibernate: select certificat0_.ID as ID1_0_, certificat0_.`DESCRIBE` as DESCRIBE2_1_0_ from CERTIFICATE certificat0_ where certificat0_.ID=?
Hibernate: select certificat0_.ID as ID1_0_, certificat0_.`DESCRIBE` as DESCRIBE2_1_0_ from CERTIFICATE certificat0_ where certificat0_.ID=?
张三
05计算机应用技?1)?br /> Exception in thread "main" org.hibernate.LazyInitializationException: failed to lazily initialize a collection of role: edu.dgut.ke.model.Team.students, no session or session was closed
at org.hibernate.collection.AbstractPersistentCollection.throwLazyInitializationException(AbstractPersistentCollection.java:358)
at org.hibernate.collection.AbstractPersistentCollection.throwLazyInitializationExceptionIfNotConnected(AbstractPersistentCollection.java:350)
at org.hibernate.collection.AbstractPersistentCollection.readSize(AbstractPersistentCollection.java:97)
at org.hibernate.collection.PersistentSet.size(PersistentSet.java:114)
at edu.dgut.ke.test.chapter3.Query.main(Query.java:44)
注意Q在配置文g中设|的索策略只能媄响到session.get()或者session.load()ҎQ对于直接?br /> session.createQuery("from Student as s left join s.team")q种指明HQL的方式，忽略配|文件的预先抓取索策略（学生对班U的预先索策略被忽略Q，q语句指明了学生和班U之间用左外连接策略，因此控制台输出的W一条语句，即用了左外q接得到?个对象：2个学生和1个班U?br /> 得到了学生对象之后，学生以n份证的预先抓取策略失效，所以会有第二条和第三条语句Q即使用了立卛_?br /> 得到班对象后，׃班对学生采用gq加载（q个{略不会被忽略）Q于是班U的学生集合q未得到初始化，所以当输出学生的h敎ͼ抛Z例外?
]]>
Team.hbm.xml
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!--
Mapping file autogenerated by MyEclipse Persistence Tools
-->
<hibernate-mapping>
<class name="edu.dgut.ke.model.Team" table="TEAM" lazy ="true" ><!-- 多对一的gq加载设|?-->
<id name="id" type="java.lang.String">
<column name="ID" length="32" />
<generator class="uuid.hex" />
</id>
<property name="teamname" type="java.lang.String">
<column name="TEAMNAME" length="32" not-null="true" unique="true" />
</property>
<set name="students" inverse="true" cascade="all" lazy="true" > <!-- 一对多的gq加载设|?nbsp;-->
<key>
<column name="TEAMID" length="32" not-null="true" />
</key>
<one-to-many class="edu.dgut.ke.model.Student" />
</set>
</class>
</hibernate-mapping>
Certificate.hbm.xml
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!--
Mapping file autogenerated by MyEclipse Persistence Tools
-->
<hibernate-mapping>
<class name="edu.dgut.ke.model.Certificate" table="CERTIFICATE" lazy="true" ><!-- 一对一的gq加载设|?nbsp;-->
<id name="id" type="java.lang.String">
<column name="ID" length="32" />
<generator class="uuid">
</generator>
</id>
<property name="describe" type="java.lang.String">
<column name="`DESCRIBE`" length="50" not-null="true" />
</property>
<one-to-one name="student"
class="edu.dgut.ke.model.Student"
constrained="true" ><!-- 一对一的gq加载设|?nbsp;-->
</one-to-one>
</class>
</hibernate-mapping>
Student.hbm.xml
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!--
Mapping file autogenerated by MyEclipse Persistence Tools
-->
<hibernate-mapping>
<class name="edu.dgut.ke.model.Student" table="STUDENT" lazy="true" >
<id name="id" type="java.lang.String">
<column name="ID" length="32" />
<generator class="uuid.hex" />
</id>
<many-to-one name="certificate"
class="edu.dgut.ke.model.Certificate"
unique="true"
column="cardId"
cascade="all"
>
</many-to-one>
<many-to-one name="team" class="edu.dgut.ke.model.Team">
<column name="TEAMID" length="32" not-null="true" />
</many-to-one>
<property name="studentname" type="java.lang.String">
<column name="STUDENTNAME" length="16" not-null="true" unique="true" />
</property>
</class>
</hibernate-mapping>
注意Q对one-to-one 关系q行延迟加蝲和其他关pȝ比稍微有些不同。many-to-one 的gq加载是在配|文件的class 标签
上设|?lazy="true" Qone-to-many ?many-to-many 的gq加载是?set 标签中设|lazy="true"。而one-to-one 不只要在 classs
标签讄 lazy="true"Q而且要在one-to-one 标签中设|constrained="true" ?br /> 如果不设|constrained="true"Q则一对一查询使用默认的预先抓取策?fetch="join")?/strong>
]]>
很多E序需要在某个事务中获取对象，然后对象发送到界面层去操作Q最后在一个新的事务保存所做的修改?在高q发讉K的环境中使用q种方式Q通常使用附带版本信息的数据来保证q些“?#8220;工作单元之间的隔R?
Hibernate通过提供使用Session.update()?tt class="literal" style="color: #0000ff">Session.merge()Ҏ 重新兌q实例的办法来支持q种模型?
// in the first session Cat cat = (Cat) firstSession.load(Cat.class, catId); Cat potentialMate = new Cat(); firstSession.save(potentialMate); // in a higher layer of the application cat.setMate(potentialMate); // later, in a new session secondSession.update(cat); // update cat secondSession.update(mate); // update mate
如果hcatId持久化标识的Cat之前已经?tt class="literal">另一Session(secondSession)装蝲了， 应用E序q行重关联操?reattach)的时候会抛出一个异常?
如果你确定当前session没有包含与之h相同持久化标识的持久实例Q?tt class="literal">update()?如果想随时合q你的的改动而不考虑session的状态，使用merge()?/strong> 换句话说Q在一个新session中通常W一个调用的?tt class="literal">update()ҎQ以便保证重新关联脱?detached)对象的操作首先被执行?
希望相关联的q对象Q通过引用“可到?#8221;的脱对象）的数据也要更新到数据库时Qƈ且也仅仅在这U情况）Q?应用E序需要对该相兌的脱对象单独调?tt class="literal">update() 当然q些可以自动完成Q即通过使用传播性持久化(transitive persistence)Q请?a title="11.11. 传播性持久化(transitive persistence)" tppabs="http://www.hibernate.org/hib_docs/v3/reference/zh-cn/html/objectstate.html#objectstate-transitive">W?nbsp;11.11 ?“传播性持久化(transitive persistence)”?
lock()Ҏ也允许程序重新关联某个对象到一个新session上。不q，该脱?detached)的对象必L没有修改q的Q?
//just reassociate: sess.lock(fritz, LockMode.NONE); //do a version check, then reassociate: sess.lock(izi, LockMode.READ); //do a version check, using SELECT ... FOR UPDATE, then reassociate: sess.lock(pk, LockMode.UPGRADE);
h意，lock()可以搭配多种LockModeQ?更多信息请阅读API文以及关于事务处理(transaction handling)的章节。重新关联不?tt class="literal">lock()的唯一用途?
其他用于长时间工作单元的模型会在W?nbsp;12.3 ?“乐观q发控制(Optimistic concurrency control)”中讨论?
文章出处:http://docs.huihoo.com/framework/hibernate/reference-v3_zh-cn/objectstate.html]]>
1)充当蓄水池的作用,减少E序讉K数据库的ơ数.很多对象数据不是l常改变?W一ơ访问这些对象时,Hibernate会将它们?br /> 入缓存中,以后只要q个对象没有改动q?讉Kq个对象时Hibernate׃会去数据库里加蝲它的数据,而是从内存中直接q回应用E序,q样子效率就比较高了.
2)保证~存中的数据与数据库同步.~存毕竟不是数据?它的数据可能和数据库不一?q时Hibernate会负责将~存中的数据同步到数据库.当然q要参照FlushMode的具体设|?
Hibernate向我们提供的主要的操U|据库的接?Session是其中的一?它提供了基本的增,??查方?而且h一个缓存机?能够按照某个旉?按照~存中的持久化对象属性的变化来更新数据库,着是Session的缓存清理过E?在Hibernate中对象分Z个状?临时,持久?游离.如果我们希望JAVA里的一个对象一直存?必L一个变量一直引用着q个对象.当这个变量没?对象也就被JVM回收?当然q个是最基本的常识了.当Session的save()Ҏ持久化了一个对象的时?即ɘq个对象的引用变量小时了.q个对象也依然存?因ؓSessoin里保存了一个这个对象的引用,当然Session~存被清I?q个对象OVER?在这个对象保存在Sessoin的时候如果调用load()Ҏ试图L据库中加载一个对?q个时候Session会先判断~存中有没有q个对象,如果有了,那么׃需要去数据库加载了.q样可以减少讉K数据库的频率,q可以保证缓存中的对象于数据库的同步.
Session有两个方?一个commit()事务提交Ҏ,q有flush()h~存Ҏ,都有着清理~存的作?flush()q行~存的清?执行一pd的SQL语句,但不会提交事?而commit()Ҏ会先调用flush()Ҏ,然后在提交事?Sessionq有一个方法就是setFushMode()Ҏ,用户讑֮清理~存的时间点,主要有下面几U模?默认Flush.Mode.AUTO
1)FlushMode.AUTO Hibernate 判断对象的属性是更改,如果被更改过成了脏数?则会在下一个查询语句前更新此改动以保证同步数据库.
2)FlushMode.COMMIT 在事务结束之前清理Session的缓?其它M时候都不清理缓?br /> 3)FlushMode.NEVER 除非强制调用Session的flush()Ҏ,否则怸清理~存
4)FlushMode.ALWAYS 在每一个查询语句前都调用flush()Ҏq行~存清理.
对象的时状?刚用new创徏对象的时?它还没有被持久化,q个时候是临时状?
对象的持久化状?已经被加入到Session的缓存中,通常所说的持久化对象就是只一个对象在q个状态的时?
对象的游ȝ?已经被持久化,但是不属于Session的缓存的时候是游离状?
]]>
分页支持c：
- package com.javaeye.common.util;
- import java.util.List;
- public class PaginationSupport {
- public final static int PAGESIZE = 30;
- private int pageSize = PAGESIZE;
- private List items;
- private int totalCount;
- private int[] indexes = new int[0];
- private int startIndex = 0;
- public PaginationSupport(List items, int totalCount) {
- setPageSize(PAGESIZE);
- setTotalCount(totalCount);
- setItems(items);
- setStartIndex(0);
- }
- public PaginationSupport(List items, int totalCount, int startIndex) {
- setPageSize(PAGESIZE);
- setTotalCount(totalCount);
- setItems(items);
- setStartIndex(startIndex);
- }
- public PaginationSupport(List items, int totalCount, int pageSize, int startIndex) {
- setPageSize(pageSize);
- setTotalCount(totalCount);
- setItems(items);
- setStartIndex(startIndex);
- }
- public List getItems() {
- return items;
- }
- public void setItems(List items) {
- this.items = items;
- }
- public int getPageSize() {
- return pageSize;
- }
- public void setPageSize(int pageSize) {
- this.pageSize = pageSize;
- }
- public int getTotalCount() {
- return totalCount;
- }
- public void setTotalCount(int totalCount) {
- if (totalCount > 0) {
- this.totalCount = totalCount;
- int count = totalCount / pageSize;
- if (totalCount % pageSize > 0)
- count++;
- indexes = new int[count];
- for (int i = 0; i < count; i++) {
- indexes[i] = pageSize * i;
- }
- } else {
- this.totalCount = 0;
- }
- }
- public int[] getIndexes() {
- return indexes;
- }
- public void setIndexes(int[] indexes) {
- this.indexes = indexes;
- }
- public int getStartIndex() {
- return startIndex;
- }
- public void setStartIndex(int startIndex) {
- if (totalCount <= 0)
- this.startIndex = 0;
- else if (startIndex >= totalCount)
- this.startIndex = indexes[indexes.length - 1];
- else if (startIndex < 0)
- this.startIndex = 0;
- else {
- this.startIndex = indexes[startIndex / pageSize];
- }
- }
- public int getNextIndex() {
- int nextIndex = getStartIndex() + pageSize;
- if (nextIndex >= totalCount)
- return getStartIndex();
- else
- return nextIndex;
- }
- public int getPreviousIndex() {
- int previousIndex = getStartIndex() - pageSize;
- if (previousIndex < 0)
- return 0;
- else
- return previousIndex;
- }
- }
抽象业务c?
- /**
- * Created on 2005-7-12
- */
- package com.javaeye.common.business;
- import java.io.Serializable;
- import java.util.List;
- import org.hibernate.Criteria;
- import org.hibernate.HibernateException;
- import org.hibernate.Session;
- import org.hibernate.criterion.DetachedCriteria;
- import org.hibernate.criterion.Projections;
- import org.springframework.orm.hibernate3.HibernateCallback;
- import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
- import com.javaeye.common.util.PaginationSupport;
- public abstract class AbstractManager extends HibernateDaoSupport {
- private boolean cacheQueries = false;
- private String queryCacheRegion;
- public void setCacheQueries(boolean cacheQueries) {
- this.cacheQueries = cacheQueries;
- }
- public void setQueryCacheRegion(String queryCacheRegion) {
- this.queryCacheRegion = queryCacheRegion;
- }
- public void save(final Object entity) {
- getHibernateTemplate().save(entity);
- }
- public void persist(final Object entity) {
- getHibernateTemplate().save(entity);
- }
- public void update(final Object entity) {
- getHibernateTemplate().update(entity);
- }
- public void delete(final Object entity) {
- getHibernateTemplate().delete(entity);
- }
- public Object load(final Class entity, final Serializable id) {
- return getHibernateTemplate().load(entity, id);
- }
- public Object get(final Class entity, final Serializable id) {
- return getHibernateTemplate().get(entity, id);
- }
- public List findAll(final Class entity) {
- return getHibernateTemplate().find("from " + entity.getName());
- }
- public List findByNamedQuery(final String namedQuery) {
- return getHibernateTemplate().findByNamedQuery(namedQuery);
- }
- public List findByNamedQuery(final String query, final Object parameter) {
- return getHibernateTemplate().findByNamedQuery(query, parameter);
- }
- public List findByNamedQuery(final String query, final Object[] parameters) {
- return getHibernateTemplate().findByNamedQuery(query, parameters);
- }
- public List find(final String query) {
- return getHibernateTemplate().find(query);
- }
- public List find(final String query, final Object parameter) {
- return getHibernateTemplate().find(query, parameter);
- }
- public PaginationSupport findPageByCriteria(final DetachedCriteria detachedCriteria) {
- return findPageByCriteria(detachedCriteria, PaginationSupport.PAGESIZE, 0);
- }
- public PaginationSupport findPageByCriteria(final DetachedCriteria detachedCriteria, final int startIndex) {
- return findPageByCriteria(detachedCriteria, PaginationSupport.PAGESIZE, startIndex);
- }
- public PaginationSupport findPageByCriteria(final DetachedCriteria detachedCriteria, final int pageSize,
- final int startIndex) {
- return (PaginationSupport) getHibernateTemplate().execute(new HibernateCallback() {
- public Object doInHibernate(Session session) throws HibernateException {
- Criteria criteria = detachedCriteria.getExecutableCriteria(session);
- int totalCount = ((Integer) criteria.setProjection(Projections.rowCount()).uniqueResult()).intValue();
- criteria.setProjection(null);
- List items = criteria.setFirstResult(startIndex).setMaxResults(pageSize).list();
- PaginationSupport ps = new PaginationSupport(items, totalCount, pageSize, startIndex);
- return ps;
- }
- }, true);
- }
- public List findAllByCriteria(final DetachedCriteria detachedCriteria) {
- return (List) getHibernateTemplate().execute(new HibernateCallback() {
- public Object doInHibernate(Session session) throws HibernateException {
- Criteria criteria = detachedCriteria.getExecutableCriteria(session);
- return criteria.list();
- }
- }, true);
- }
- public int getCountByCriteria(final DetachedCriteria detachedCriteria) {
- Integer count = (Integer) getHibernateTemplate().execute(new HibernateCallback() {
- public Object doInHibernate(Session session) throws HibernateException {
- Criteria criteria = detachedCriteria.getExecutableCriteria(session);
- return criteria.setProjection(Projections.rowCount()).uniqueResult();
- }
- }, true);
- return count.intValue();
- }
- }
用户在web层构造查询条件detachedCriteriaQ和可选的startIndexQ调用业务bean的相应findByCriteriaҎQ返回一个PaginationSupport的实例ps?/p>
ps.getItems()得到已分好的结果集
ps.getIndexes()得到分页索引的数l?
ps.getTotalCount()得到ȝ果数
ps.getStartIndex()当前分页索引
ps.getNextIndex()下一늃?
ps.getPreviousIndex()上一늃?br />
文章出处:http://www.javaeye.com/topic/14657
]]>
]]>
q Object execute(HibernateCallback action)
q List execute(HibernateCallback action)
q两个方法都需要一?/span>HibernateCallback的实例，HibernateCallback实例可在M有效?/span>Hibernate数据讉K中用。程序开发者通过HibernateCallbackQ可以完全?/span>Hibernate灉|的方式来讉K数据库，解决Spring装Hibernate后灵zL不的~陷?/span>HibernateCallback是一个接口，该接口只有一个方?/span>doInHibernate(org.hibernate.Session session)Q该Ҏ只有一个参?/span>Session?/span>
通常Q程序中采用实现HibernateCallback的匿名内部类来获?/span>HibernateCallback的实例，ҎdoInHibernate的方法体是Spring执行的持久化操作。具体代码如下：
public class PersonDaoImpl implements PersonDao
{
//U有实例变量保存SessionFactory
private SessionFactory sessionFactory;
//依赖注入必须?/span>setterҎ
public void setSessionFactory(SessionFactory sessionFactory)
{
this.sessionFactory = sessionFactory;
}
/**
* 通过人名查找所有匹配该名的Person实例
* @param name 匚w的h?/span>
* @return 匚w该Q命的全部Person集合
*/
public List findPersonsByName(final String name)
{
//创徏HibernateTemplate实例
HibernateTemplate hibernateTemplate =
new HibernateTemplate(this.sessionFactory);
//q回HibernateTemplate?/span>execute的结?/span>
return (List) hibernateTemplate.execute(
//创徏匿名内部c?/span>
new HibernateCallback()
{
public Object doInHibernate(Session session) throws HibernateException
{
//使用条g查询的方法返?/span>
List result = session.createCriteria(Person.class)
.add(Restrictions.like(“name”, name+”%”)
.list();
return result;
}
});
}
}
注意Q方?/span>doInHibernateҎ内可以访?/span>SessionQ该Session对象是绑定到该线E的Session实例。该Ҏ内的持久层操作，与不使用Spring时的持久层操作完全相同。这保证对于复杂的持久层讉KQ依然可以?/span>Hibernate的访问方式?/span>
]]>
]]>
一?span style="font: 7pt 'Times New Roman'"> 数据库事务概?/span>
数据库事务的特征Q?/span> ACID
Atomic Q原子性）?/span> Consistency Q一致性）?/span> Isolation Q隔L）?/span> Durability Q持久性）?/span> DBMS 用日志来保证数据的原子性、一致性和持久性；用锁的机制来保证数据的隔L?/span>
二?span style="font: 7pt 'Times New Roman'"> 事务的边?/span>
数据库支?/span> 2 U事务模式：自动提交和手动提交?/span>
JDBC API 的事务边?/span>
try 
{
Connection conn = java.sql.DriverManager,.getConnection(dbUrl,dbUser,dbPwd); conn.setAutoCommit( false ); // 讄成手动模?/span> stmt = conn.createStatement(); stmt.executeUpdate( " 
. " ); // 数据库更? stmt.executeUpdate( " . " ); // 数据库更? conn.commit();
} catch (Exception e) { conn.rollback();} finally { stmt.close(); conn.close();} Hibernate API 声明事务边界
Session session = factory.openSession();Transaction tx; try { tx = session.beginTransaction(); // 开始事?br />
// 执行操作 。。。。?br />
tx.commit();} catch (Exception e) { if (tx != null )
{
tx.rollback();
} } finally { session.close();} 注：一?/span> session 可以对应多个事务Q但是推荐的做法是一?/span> session 对应一个事务?/span>
三?/font>
多事务的q发问题当多个事务同时访问相同的数据的时候，E序如果没有采取适当的隔L施，׃发生数据库的q发问题。常见的q发问题有：
W一cM失更斎ͼ撤消事务的时候，把其他的事务已经提交的数据给覆盖了；
脏读Q读了没有提交的数据Q?/span>
虚读Q一个事务读到另外一个事务已l提交的新插入的数据Q?/span>
不可重复读：一个事务读到另外一个事务已l提交的更新的数据；
W二cM失更斎ͼ一个事务覆盖另外一个事务已l提交的更新数据?/span>
四?/strong> ?/span>
一般地Q大型的 DBMS 都会自动的管理锁定机Ӟ但是在对数据的安全性、完整性和一致性有Ҏ要求的地方，可以׃务本w来理琐的机制?/span>
有一点要x的是Q锁的粒度越大，隔离性越好，q发性越差?/span>
按照锁的E度来分有：
׃n锁：用读操作Q非独占的，其他事务可以读，但是不能更新Qƈ发性好Q?/span>
独占锁：用与 insert update ?/span> delete {语句，其他事务不能读，也不能改Qƈ发性差Q?/span>
更新锁：执行 update 的时候，加锁?/span>
ȝQ多是事务分别锁定了一个资源，又请求锁定对方已l锁定的资源Q就造成了请求环?/span>
降低死锁的最好办法是使用短事务?/span>
五?/font> 数据库的事务隔离U别
数据库提?/span> 4 U事务隔ȝ别：
Serializable Q串行化Q（隔离U别最高） 1
Repeatable Read Q可重复读； 2
Read Commited Q读已提交数据； 4
Read Uncommited Q读未提交数据；Q隔ȝ别最低） 8
Hiberate 中的隔离U别的设|?/span>
?/span> Hibernate 的配|文件中 hibernate.connection.isolation=2
六?/font> 悲观锁和乐观?/span>
从应用程序的角度来看Q锁分ؓ悲观锁和乐观锁?/span>
悲观锁：昄的ؓE序加锁Q但是降低ƈ发性?/span>
Select ……. For update;
?/span> Hibernate 中的代码
Session.get(Account.class,net Long(1),LockMode.UPGRADE) Q?/span> // E序采用悲观?/span>
乐观锁：依靠 DBMS 来管理锁Q程序依靠版本控制来避免q发问题?/span>
在对?/span> - 关系映射的文件中Q用 <version> 或?/span> <timestamp> 可以理q发。乐观琐比悲观琐有更好的q发性，优先考虑乐观琐?/span>
]]>
Hibernate 提供?/span> 3 U检索策略：
l 延迟索；
l 立即索；
l q切左外q接Q?/span>
Hibernate 提供 2 U方式来定索策略，一中是在配|文件当中，另外一U是在程序种讄。当Ӟ如果你在E序中设|了索策略，那么你在配置文g中的讄也就无效了。另外的一U情冉| HQL 会忽略配|文件的讄Q而L采用q切左外q接?/span>
一?cȝ别的?/span>
可以选择的检索策略是立即索和延迟索，默认的是立即索。用配置文g中的 <class> 节点?/span> lazy 来控制?/span>
注意Q不你在配|?/span> class ?/span> lazy ?/span> true q是 false Q对 get() ?/span> create Criteria () Ҏ都不起作用，只有?/span> load() Ҏ起作用?/span>
当你使用的检索策略是 lazy 的时候，当你执行
Customer customer = (Customer)session.load(Customer.class,new Long(1));
的时候， Hibernate 不从数据库检索数据，而只是生一个代理类Q只有当你执?/span>
Customer.getName();
的时候， Hibernate 才到数据库取数据。所以，如下的代码是会被抛出异常的：
Session session = sessionFactory.openSession();transaction tx = null ;tx = session.beginTransaction();Customer customer = (Customer)session.load(Customer. class , new Long( 1 ));
tx.commit();session.close();
customer.getName(); get() ҎL用的立即索，如果和它相关联的cM是用的立x索，那么也会把相兌的数据也索出来?/span>
二?一对和多对多关联检?/span>
一般地Qؓ了有减少Ҏ据库的访问，我们往往用gq检索的{略。所以，我们优先使用如下方式Q?/span>
<set class=”order” inverse=”true’ lazy=”true” >
但是Q我们在?#8220;?#8221;的一方的时候， Hibernate 不能为我们生代理类。由此，我们p?/span> betch-size 的配|来减少 SQL 语句?/span>
当我们?/span> outer-join 属性的时候，我们没有必要?/span> lazy 属性了?/span> Outer-join 会一ơ将“一”方和与之相关?#8220;?#8221;方用左外q接的方式检索出来?/span>
Session session = sessionFactory.openSession();
Transaction tx = null;
tx = session.beginTransaction();
Customer customer = (Customer)session.get(Customer.class,new Long(1));
产生?/span> SQL 语句如下Q?/span>
Hibernate: select customer0_.ID as ID1_, customer0_.NAME as NAME2_1_, orders1_.CUSTOMER_ID as CUSTOMER3_3_, orders1_.ID as ID3_, orders1_.ID as ID0_, orders1_.ORDER_NUMBER as ORDER2_1_0_, orders1_.CUSTOMER_ID as CUSTOMER3_1_0_ from sampledb.customers customer0_ left outer join sampledb.orders orders1_ on customer0_.ID=orders1_.CUSTOMER_ID where customer0_.ID=?
]]>
通过SessionFactory对象得到Session对象,然后开始一个新的事?br> 通过chain对象的doFilter()Ҏ来完成业务处?br> 提交或者回滚事?
HibernateFilter.java
import java.io.IOException;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.hibernate.SessionFactory;
import cn.hxex.blog.hibernate.HibernateUtil;
public class HibernateFilter implements Filter {
private static Log log = LogFactory.getLog(HibernateFilter.class);
/**
* qo器的主要Ҏ
* 用于实现Hibernate事务的开始和提交
*/
public void doFilter(ServletRequest request,
ServletResponse response,
FilterChain chain)
throws IOException, ServletException
{
// 得到SessionFactory对象的实?br> SessionFactory sf = HibernateUtil.getSessionFactory();
try
{
// 开始一个新的事?br> log.debug("Starting a database transaction");
sf.getCurrentSession().beginTransaction();
log.debug( "Request Path:\t" + ((HttpServletRequest)request).getServletPath() );
// Call the next filter (continue request processing)
chain.doFilter(request, response);
// 提交事务
log.debug("Committing the database transaction");
sf.getCurrentSession().getTransaction().commit();
}
catch (Throwable ex)
{
ex.printStackTrace();
try
{
// 回滚事务
log.debug("Trying to rollback database transaction after exception");
sf.getCurrentSession().getTransaction().rollback();
}
catch (Throwable rbEx)
{
log.error("Could not rollback transaction after exception!", rbEx);
}
// 抛出异常
throw new ServletException(ex);
}
}
/**
* Servletqo器的初始化方?br> * 可以d配置文g中设|的配置参数
*/
public void init(FilterConfig filterConfig) throws ServletException {}
/**
* Servlet的销毁方?br> * 用于释放qo器所甌的资?br> */
public void destroy() {}
}
]]>
BaseModel.java
import java.io.Serializable;
import org.apache.commons.lang.builder.EqualsBuilder;
import org.apache.commons.lang.builder.HashCodeBuilder;
import org.apache.commons.lang.builder.ReflectionToStringBuilder;
public class BaseModel implements Serializable{
/**
* The Generated SerialVersionUID
*/
private static final long serialVersionUID = 7766184319541530720L;
/**
* The identify of the object
*/
private String id;
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
/**
* Common implement equals method
*/
public boolean equals( Object obj )
{
if( this==obj ) return true;
if( !( obj instanceof BaseModel ) )
return false;
BaseModel target = (BaseModel)obj;
if( this.getId()!=null && this.getId().length()>0 )
{
return this.getId().equals( target.getId() );
}
if( target.getId()!=null && target.getId().length()>0 )
{
return false;
}
return EqualsBuilder.reflectionEquals(this, obj);
}
/**
* Generate the hash code
*/
public int hashCode()
{
if( this.getId()!=null && this.getId().length()>0 )
{
return this.getId().hashCode();
}
return HashCodeBuilder.reflectionHashCode(this);
}
/**
* Common implement toString method
*/
public String toString()
{
return ReflectionToStringBuilder.toString( this );
}
}
equals()Ҏ,用于判断两个对象是否相等,但ƈ不是在?=="q行两个对象是否相等的判断时调用.因ؓ使用"=="所判断的是两个对象的引用是否相{?也可以简单理解ؓ两个实例所引用的是否ؓ内存中的同一个对?equals()Ҏ可以理解Z个对象在"含义"上是否相{?也就是说q两个对象所表达的意思是否相?equals()Ҏ在对象保存到集合容器c?Collection)中时被调?因ؓ集合容器cM允许其中存在两个相同对象实例,其判断的依据是通过调用该实体对象的equals()Ҏ来进行判断的.
如果修改了equals()Ҏ,必M改hashCode()Ҏ.如果不这L?p反java.lang.Object的通用的hashCode的约?从而导致该cL法与Z散列值的集合cMh常工?
toString()Ҏ,用于当前Java对象的实例{换ؓ可以描述其内容的字符?q个Ҏ的作用是在程序调试的q程可以方便地得到实体对象中令h感兴的信息,有利于更准确及时地发现程序中的问?
]]>
对于Hibernate 3.1 以前的的版本在实现Hibernate工具cL,需要通过两个U程
局部变量来保存与当前进行相对应的Session和事务对象的实例.
而对于Hibernate 3.1 以后的版?使用U程局部变量保存Session和事务对象的
工作完全不需要自己去实现?只需在Hibernate.cfg.xml配置文g中增加一个名?br>Current_session_context_class的属?q且讄该属性的gؓthread.q样Hibernate
可以自动地使用U程局部变量来保存当前的进E的Session和事务对象了.
相应?Hibernate也ؓ其Session对象增加了getTransaction()Ҏ,以便可以随时
得到当前的事务ƈq行提交或者回滚操?q个Ҏ在以前版本的hibernate中是不存?br>?
Hibernate工具cM要包括以下功?
(1)Hibernate的初始化操作
q个功能不放在Q何方法中,采用静态编码的处理方式,在对象的初始化的时候被
调用一ơ就可以?
(2)得到当前的配|信?/em>
q个Ҏ可以得到当前的配|信?以便于动态进行配|参数的修改.hibernate
的配|信息只在Hibernate初始化的时候用一?在完成初始化之后寚w|文?br> 或者Configuration对象所做的修改不会生?
(3)得到SessionFactory对象的实?/em>
q个Ҏ用于得到当前pȝq行时的SessionFactory对象的实?q个对象的实?br> 对于整个pȝ而言是全局唯一?
(4)释放各种资源
q个Ҏ用于l止Hibernate的报务后,释放各种Hibernate所使用的资?虽然q个
Ҏ几乎不会用到,但对于申误源的及时释放是每个程序应该掌握的基本原则.
(5)重徏SessionFactory
׃SessionFactory对于整个Hibernate应用是唯一?q且是在Hibernate初始?br> 之后建立好的,而且对于配置文g的修改也不会影响到已l初始化的SessionFactory
对象.那么如何才能使修改的配置信息对Hibernate起作用呢.q就需要重建SessionFactory
对象实例.
(6)拦截器注?/em>
用于注册拦截器ƈ重徏SessionFactory.
HibenateUtil.java
import javax.naming.InitialContext;
import javax.naming.NamingException;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.hibernate.Interceptor;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.hibernate.cfg.Environment;
/**
* 基础的Hibernate辅助c，用于Hibernate的配|和启动?br> * <p>
* 通过静态的初始化代码来dHibernate启动参数Qƈ初始?br> * <tt>Configuration</tt>?lt;tt>SessionFactory</tt>对象?br> * <p>
*
* @author galaxy
*/
public class HibernateUtil
{
private static Log log = LogFactory.getLog(HibernateUtil.class);
// 指定定义拦截器属性名
private static final String INTERCEPTOR_CLASS = "hibernate.util.interceptor_class";
// 静态Configuration和SessionFactory对象的实例（全局唯一的）
private static Configuration configuration;
private static SessionFactory sessionFactory;
static
{
// 从缺省的配置文g创徏SessionFactory
try
{
// 创徏默认的Configuration对象的实?br> // 如果你不使用JDK 5.0或者注释请使用new Configuration()
// 来创建Configuration()对象的实?br> configuration = new Configuration();
// dhibernate.properties或者hibernate.cfg.xml文g
configuration.configure();
// 如果在配|文件中配置了拦截器Q那么将其设|到configuration对象?br> String interceptorName = configuration.getProperty(INTERCEPTOR_CLASS);
if (interceptorName != null)
{
Class interceptorClass =
HibernateUtil.class.getClassLoader().loadClass(interceptorName);
Interceptor interceptor = (Interceptor)interceptorClass.newInstance();
configuration.setInterceptor(interceptor);
}
if (configuration.getProperty(Environment.SESSION_FACTORY_NAME) != null)
{
// 让HibernateSessionFacoryl定到JNDI
configuration.buildSessionFactory();
}
else
{
// 使用静态变量来保持SessioFactory对象的实?br> sessionFactory = configuration.buildSessionFactory();
}
}
catch (Throwable ex)
{
// 输出异常信息
log.error("Building SessionFactory failed.", ex);
ex.printStackTrace();
throw new ExceptionInInitializerError(ex);
}
}
/**
* q回原始的Configuration对象的实?br> *
* @return Configuration
*/
public static Configuration getConfiguration()
{
return configuration;
}
/**
* q回全局的SessionFactory对象的实?br> *
* @return SessionFactory
*/
public static SessionFactory getSessionFactory()
{
SessionFactory sf = null;
String sfName = configuration.getProperty(Environment.SESSION_FACTORY_NAME);
if ( sfName != null)
{
log.debug("Looking up SessionFactory in JNDI.");
try
{
sf = (SessionFactory) new InitialContext().lookup(sfName);
}
catch (NamingException ex)
{
throw new RuntimeException(ex);
}
}
else
{
sf = sessionFactory;
}
if (sf == null)
throw new IllegalStateException( "SessionFactory not available." );
return sf;
}
/**
* 关闭当前的SessionFactoryq且释放所有的资源
*/
public static void shutdown()
{
log.debug("Shutting down Hibernate.");
// Close caches and connection pools
getSessionFactory().close();
// Clear static variables
configuration = null;
sessionFactory = null;
}
/**
* 使用静态的Configuration对象来重新构建SessionFactory?br> */
public static void rebuildSessionFactory()
{
log.debug("Using current Configuration for rebuild.");
rebuildSessionFactory(configuration);
}
/**
* 使用指定的Configuration对象来重新构建SessionFactory对象?br> *
* @param cfg
*/
public static void rebuildSessionFactory(Configuration cfg)
{
log.debug("Rebuilding the SessionFactory from given Configuration.");
synchronized(sessionFactory)
{
if (sessionFactory != null && !sessionFactory.isClosed())
sessionFactory.close();
if (cfg.getProperty(Environment.SESSION_FACTORY_NAME) != null)
cfg.buildSessionFactory();
else
sessionFactory = cfg.buildSessionFactory();
configuration = cfg;
}
}
/**
* 在当前SessionFactory中注册一个拦截器
*/
public static SessionFactory registerInterceptorAndRebuild(Interceptor interceptor)
{
log.debug("Setting new global Hibernate interceptor and restarting.");
configuration.setInterceptor(interceptor);
rebuildSessionFactory();
return getSessionFactory();
}
/**
* 获得拦截器对?br> *
* @return Interceptor
*/
public static Interceptor getInterceptor()
{
return configuration.getInterceptor();
}
/**
* 提交当前事务Qƈ开始一个新的事?br> */
public static void commitAndBeginTransaction()
{
sessionFactory.getCurrentSession().getTransaction().commit();
sessionFactory.getCurrentSession().beginTransaction();
}
}
]]>