使用Hibernate模板

與Hibernate進行交互的主要接口是org.hibernate.Session。這個Session接口提供了基本的數據訪問功


能，比如從數據庫保存、更新、刪除和加載對象。通過Hibernate的Session接口，程序的DAO能夠執行任


何存留功能。


獲得Hibernate Session對象引用的標準方式是實現Hibernate的SessionFactory接口。SessionFactory


負責打開、關閉和管理Hibernate Session，以及其他一些功能。


就像JdbcTemplate把JDBC的繁瑣工作抽離出去一樣，Spring的HibernateTemplate在Hibernate Session


之上提供了一個抽象層，其主要功能是簡化打開和關閉Hibernate會話，并且把Hibernate的特定異常轉


化為表5.1列出的Spring ORM異常之一。（對于Hibernate 2來說，這意味著把受檢異常


HibernateException轉化為一個免檢的Spring異常。）
========

SPRING中HIBERNATETEMPLATE類的使用

　　實際情況中，對于編程事務的操作最好還是使用


org.springframework.transaction.support.TransactionTemplate，因為HibernateTemplate在實際操


作中并不是想象的那樣，具體如下：


目的：使用HibernateTemplate執行execute（new HibernateCallback（））方法，從


HibernateCallback中得到session，
在此session中做多個操作，并希望這些操作位于同一個事務中。
　　如果你這樣寫（1）：
　　public static void main(String ss[]) {
　　CtxUtil.getBaseManager().getHibernateTemplate().execute(new HibernateCallback() {
　　public Object doInHibernate(Session session) throws HibernateException, SQLException {
　　// 保存stu1
　　Student stu1 = new Student();
　　stu1.setName("aaaa");// 在數據庫中,name字段不允許為null
　　session.save(stu1);
　　session.flush();//實際上，如果不是程序員"手癢"來調用這個flush(),HibernateTemplate中


session的事務處理
還是很方便的
　　Student stu2 = new Student();
　　session.save(stu2);// 沒有設置name字段，預期會報出例外
　　session.flush();
　　return null;
　　}
　　});
　　}
　　你期望spring在執行完execute回調后，在關閉session的時候提交事務，想法是很好的，但spring


并不會這么做。
讓我們來看看在 Hibernate的源代碼中，session.beginTransation（）做了什么事。看如下代碼（2）


：
　　public Transaction beginTransaction() throws HibernateException {
　　errorIfClosed();
　　if ( rootSession != null ) {
　　// todo : should seriously consider not allowing a txn to begin from a child session
　　// can always route the request to the root session
　　log.warn( "Transaction started on non-root session" );
　　}
　　Transaction result = getTransaction();
　　result.begin();
　　return result;
　　}
　　這個方法中的result是一個org.hibernate.transaction.JDBCTransaction實例，而方法中的


getTransaction（）
方法源代碼為（3）：
　　public Transaction getTransaction() throws HibernateException {
　　if (hibernateTransaction==null) {
　　log.error(owner.getFactory().getSettings()
　　.getTransactionFactory().getClass());
　　hibernateTransaction = owner.getFactory().getSettings()
　　.getTransactionFactory()
　　.createTransaction( this, owner );
　　}
　　return hibernateTransaction;
　　}
　　再次追蹤，owner.getFactory（）。getSettings（） .getTransactionFactory（）的


createTransaction（）方法
源代碼如下（4）：
　　public Transaction createTransaction(JDBCContext jdbcContext, Context?


transactionContext)
　　throws HibernateException {
　　return new JDBCTransaction( jdbcContext, transactionContext );
　　}
　　它返回了一個JDBCTransaction，沒什么特別的。
　　在代碼2中，執行了result.begin（），其實也就是JDBCTransaction實例的begin（）方法，來看看


（5）：
　　public void begin() throws HibernateException {
　　if (begun) {
　　return;
　　}
　　if (commitFailed) {
　　throw new TransactionException("cannot re-start transaction after failed commit");
　　}
　　log.debug("begin");
　　try {
　　toggleAutoCommit = jdbcContext.connection().getAutoCommit();
　　if (log.isDebugEnabled()) {
　　log.debug("current autocommit status: " + toggleAutoCommit);
　　}
　　if (toggleAutoCommit) {
　　log.debug("disabling autocommit");
　　jdbcContext.connection().setAutoCommit(false);//把自動提交設為了false
　　}
　　} catch (SQLException e) {
　　log.error("JDBC begin failed", e);
　　throw new TransactionException("JDBC begin failed: ", e);
　　}
　　callback = jdbcContext.registerCallbackIfNecessary();
　　begun = true;
　　committed = false;
　　rolledBack = false;
　　if (timeout > 0) {
　　jdbcContext.getConnectionManager().getBatcher().setTransactionTimeout(timeout);
　　}
　　jdbcContext.afterTransactionBegin(this);
　　}


在直接使用Hibernate時，要在事務結束的時候，寫上一句：tx.commit（），這個commit（）的源碼為


：
　　public void commit() throws HibernateException {
　　if (!begun) {
　　throw new TransactionException("Transaction not successfully started");
　　}
　　log.debug("commit");
　　if (!transactionContext.isFlushModeNever() && callback) {
　　transactionContext.managedFlush(); // if an exception occurs during
　　// flush, user must call
　　// rollback()
　　}
　　notifyLocalSynchsBeforeTransactionCompletion();
　　if (callback) {
　　jdbcContext.beforeTransactionCompletion(this);
　　}
　　try {
　　commitAndResetAutoCommit();//重點代碼，它的作用是提交事務，并把connection的autocommit屬


性恢復為true
　　log.debug("committed JDBC Connection");
　　committed = true;
　　if (callback) {
　　jdbcContext.afterTransactionCompletion(true, this);
　　}
　　notifyLocalSynchsAfterTransactionCompletion(Status.STATUS_COMMITTED);
　　} catch (SQLException e) {
　　log.error("JDBC commit failed", e);
　　commitFailed = true;
　　if (callback) {
　　jdbcContext.afterTransactionCompletion(false, this);
　　}
　　notifyLocalSynchsAfterTransactionCompletion(Status.STATUS_UNKNOWN);
　　throw new TransactionException("JDBC commit failed", e);
　　} finally {
　　closeIfRequired();
　　}
　　}
　　上面代碼中，commitAndResetAutoCommit（）方法的源碼如下：
　　private void commitAndResetAutoCommit() throws SQLException {
　　try {
　　jdbcContext.connection().commit();//這段不用說也能理解了
　　} finally {
　　toggleAutoCommit();//這段的作用是恢復connection的autocommit屬性為true
　　}
　　}
　　上述代碼的toggleAutoCommit（）源代碼如下：
　　private void toggleAutoCommit() {
　　try {
　　if (toggleAutoCommit) {
　　log.debug("re-enabling autocommit");
　　jdbcContext.connection().setAutoCommit(true);//這行代碼的意義很明白了吧
　　}
　　} catch (Exception sqle) {
　　log.error("Could not toggle autocommit", sqle);
　　}
　　}
　　因此，如果你是直接使用hibernate，并手動管理它的session，并手動開啟事務關閉事務的話，完


全可以保證你的
事務（好像完全是廢話）。
　　但是，如果你用的是HibernateTemplate，如同源代碼1一樣，則不要指望spring在關閉session的時


候為你提交事務
（罪魁禍首就是在代碼1中調用了session.flush（））。因為在使用代碼1時，spring中得到session的


方式如下：
Session session = （entityInterceptor ！= null ？ sessionFactory.openSession


（entityInterceptor） ：
sessionFactory。openSession（））；簡單地說它就是得到了一個session，而沒有對connection的?


autocommit（）
作任何操作，spring管理范圍內的session所持有的connection是autocommit=true 的，spring借助這個


屬性，在它關
閉session時，提交數據庫事務。，因此如果你在源代碼1中加上一句話：
　　public static void main(String ss[]) {
　　CtxUtil.getBaseManager().getHibernateTemplate().execute(new HibernateCallback() {
　　public Object doInHibernate(Session session) throws HibernateException, SQLException {
　　log.info(session.connection().getAutoCommit());//打印一下事務提交方式
　　// 保存stu1
　　Student stu1 = new Student();
　　stu1.setName("aaaa");// 在數據庫中,name字段不允許為null
　　session.save(stu1);
　　session.flush();
　　Student stu2 = new Student();
　　session.save(stu2);// 沒有設置name字段，預期會報出例外
　　session.flush();
　　return null;
　　}
　　});
　　}
　　運行后，它打出的結果是true，也就是說，雖然保存stu2時會報出例外，但如果commit屬性為true


，則每一個到
達數據庫的sql語句會立即被提交。換句話說，在調用完session.save（stu1）后，調用session.flush


（），會發送
sql語句到數據庫，再根據commit 屬性為true，則保存stu1的操作已經被持久到數據庫了，盡管后面的


一條insert語
句出了問題。
　　因此，如果你想在HibernateCallback中使用session的事務，需要如下寫：
　　public static void main(String ss[]) {
　　CtxUtil.getBaseManager().getHibernateTemplate().execute(new HibernateCallback() {
　　public Object doInHibernate(Session session) throws HibernateException, SQLException {
　　session.connection().setAutoCommit(false);
　　//保存stu1
　　Student stu1=new Student();
　　stu1.setName("aaaa");//在數據庫中,name字段不允許為null
　　session.save(stu1);
　　session.flush();
　　Student stu2 = new Student();
　　session.save(stu2);//沒有設置name字段，預期會報出例外
　　 session.flush();
　　session.connection().commit();
　　//至于session的關閉就不用我們操心了
　　return null;
　　}
　　});
　　}


運行上述代碼，沒問題了。至此，可能有些讀者早就對代碼1不滿意了：為什么每次save（）以后要調用


flush（）？這是
有原因的。下面我們來看看把session.flush（）去掉后會出什么問題。改掉后的代碼如下：
　　public static void main(String ss[]) {
　　CtxUtil.getBaseManager().getHibernateTemplate().execute(new HibernateCallback() {
　　public Object doInHibernate(Session session) throws HibernateException, SQLException {
　　session.connection().setAutoCommit(false);
　　// 保存stu1
　　Student stu1 = new Student();
　　stu1.setName("aaaa");// 在數據庫中,name字段不允許為null
　　session.save(stu1);
　　// session.flush();
　　Student stu2 = new Student();
　　session.save(stu2);// 沒有設置name字段，預期會報出例外
　　// session.flush();
　　session.connection().commit();
　　return null;
　　}
　　});
　　}
　　運行上述代碼，后臺報數據庫的not null錯誤，這個是合理的，打開數據庫，沒有發現新增記錄，


這個也是合理的。
你可能會說：由于事務失敗，數據庫當然不可能會有任何新增記錄。好吧，我們再把代碼改一下，去除


not null的錯誤，
以確保它能正常運行。代碼如下：
　　public static void main(String ss[]) {
　　CtxUtil.getBaseManager().getHibernateTemplate().execute(new HibernateCallback() {
　　public Object doInHibernate(Session session) throws HibernateException, SQLException {
　　session.connection().setAutoCommit(false);
　　// 保存stu1
　　Student stu1 = new Student();
　　stu1.setName("aaaa");// 在數據庫中,name字段不允許為null
　　session.save(stu1);
　　// session.flush();
　　Student stu2 = new Student();
　　stu2.setName("asdfasdf");//好了，這個字段設過值，不會再報not null錯誤了
　　session.save(stu2);
　　// session.flush();
　　session.connection().commit();
　　return null;
　　}
　　});
　　}
　　至此再運行上述代碼，出現了一個奇怪的問題：雖然控制臺把insert語句打出來了，但是：數據庫


沒有出現任何新的記錄。
　　究其原因，有二：
　　一、 session.connection（）。commit（）確實導致數據庫事務提交了，但是此刻session并沒有


向數據庫發送任何語句。
　　二、在spring后繼的flushIfNecessary（）和closeSessionOrRegisterDeferredClose（）方法中，


第一個方法向數據
庫發送sql語句，第二個方法關閉session，同時關閉connection，然后問題在于：connection已經在程


序中被手動設置為
auttocommit=false了，因此在關閉數據庫時，也不會提交事務。
　　解決這個問題很容易，在程序中手動調用session.flush（）就可以了。如下代碼：
　　public static void main(String ss[]) {
　　CtxUtil.getBaseManager().getHibernateTemplate().execute(new HibernateCallback() {
　　public Object doInHibernate(Session session) throws HibernateException, SQLException {
　　session.connection().setAutoCommit(false);
　　//保存stu1
　　Student stu1=new Student();
　　stu1.setName("aaaa");//在數據庫中,name字段不允許為null
　　session.save(stu1);
　　Student stu2 = new Student();
　　session.save(stu2);//沒有設置name字段，預期會報出例外
　　session.flush();//向數據庫發送sql
　　session.connection().commit();
　　return null;
　　}
　　});
　　}
　　運行上述代碼，打開數據庫查看，沒有新增任何記錄。在代碼中新加一行stu2.setName（"aaa"）；


再次運行代碼，
發現數據庫表中多了兩條記錄。事務操作成功。
　　至此，雖然操作成功，但事情還沒有結束。這是因為spring在調用doInHibernate（）的后繼的步驟


中，還要進行
flushIfNecessary（）操作，這個操作其實最后調用的還是session.flush（）。因為在程序中已經手動


調用過
session.flush（），所以由spring調用的session.flush（）并不會對數據庫發送sql（因為臟數據比對


的原因）。
雖然不會對結果有什么影響，但是多調了一次flush（），還是會對性能多少有些影響。能不能控制讓


spring不調
用session.flush（）呢？可以的，只要加上一句代碼，如下所示：
　　public static void main(String ss[]) {
　　CtxUtil.getBaseManager().getHibernateTemplate().setFlushMode(0);//0也就是FLUSH_NEVER
　　CtxUtil.getBaseManager().getHibernateTemplate().execute(new HibernateCallback() {
　　public Object doInHibernate(Session session) throws HibernateException, SQLException {
　　session.connection().setAutoCommit(false);
　　//保存stu1
　　Student stu1=new Student();
　　stu1.setName("aaaa");//在數據庫中,name字段不允許為null
　　session.save(stu1);
　　Student stu2 = new Student();
　　stu2.setName("sdf");
　　session.save(stu2);//沒有設置name字段，預期會報出例外
　　session.flush();
　　session.connection().commit();
　　return null;
　　}
　　});
　　}
　　通過設置HibernateTemplate的flushMode=FLUSH_NEVER來通知spring不進行session.flush（）的調


用，則spring
的flushIfNecessary（）將不進行任何操作，它的flushIfNecessary（）源代碼如下：
　　protected void flushIfNecessary(Session session, boolean existingTransaction) throws?


HibernateException {
　　if (getFlushMode() == FLUSH_EAGER || (!existingTransaction && getFlushMode() !=?


FLUSH_NEVER)) {
　　logger.debug("Eagerly flushing Hibernate session");
　　session.flush();
　　}
　　}
　　至此，代碼1中的main（）終于修改完畢。但事實上，這樣的操作無疑是比較麻煩的，因此如果在


spring中想利
用session進行事務操作時，最好還是用TransactionTemplate（編程式事務）或是聲明式事務比較方便


一些。
　　本例通過這么一個雖然簡單但又繞來繞去的例子，主要是說明hibernate事務的一些內在特性，以及
HibernateTemplate中如何處理 session和事務的開關，讓讀者對HibernateTemplate的源代碼處理細節


有一些了解，
希望能給讀者有拋磚引玉的作用。
========

HibernateTemplate用法

private HibernateTemplate hibernateTemplate;


?


使用HbernateTemplate
HibernateTemplate提供持久層訪問模板化，使用HibernateTemplate無須實現特定接口，它只需要提供


一個SessionFactory的引用，就可執行持久化操作。SessionFactoyr對象可通過構造參數傳入，或通過


設值方式傳入。如下：
//獲取Spring上下文
ApplicationContext ctx = new FileSystemXmlApplicationContext("bean.xml");
//通過上下文獲得SessionFactory
SessionFactory sessionFactory = (SessionFactory) ctx.getBean(“sessionFactory”);
然后創建HibernateTemplate實例。HibernateTemplate提供如下三個構造函數
q HibernateTemplate()
q HibernateTemplate(org.hibernate.SessionFactory sessionFactory)
q HibernateTemplate(org.hibernate.SessionFactory sessionFactory, boolean allowCreate)
第一個構造函數，構造一個默認的HibernateTemplate實例，因此，使用HibernateTemplate實例之前，


還必須使用方法setSessionFactory(SessionFactory sessionFactory)來為HibernateTemplate傳入


SessionFactory的引用。
第二個構造函數，在構造時已經傳入SessionFactory引用。
第三個構造函數，其boolean型參數表明：如果當前線程已經存在一個非事務性的Session，是否直接返


回此非事務性的Session。
對于在Web應用，通常啟動時自動加載ApplicationContext，SessionFactory和DAO對象都處在Spring上


下文管理下，因此無須在代碼中顯式設置，可采用依賴注入解耦SessionFactory和DAO，依賴關系通過配


置文件來設置，如下所示：
<?xml version="1.0" encoding="gb2312"?>
<!-- Spring配置文件的DTD定義-->
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
"http://www.springframework.org/dtd/spring-beans.dtd">
<!-- Spring配置文件的根元素是beans-->
<beans>
<!--定義數據源,該bean的ID為dataSource-->
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<!-- 指定數據庫驅動-->
<property name="driverClassName"><value>com.mysql.jdbc.Driver</value></property>
<!-- 指定連接數據庫的URL-->?
<property name="url"><value>jdbc:mysql://wonder:3306/j2ee</value></property>
<!-- root為數據庫的用戶名-->
<property name="username"><value>root</value></property>
<!-- pass為數據庫密碼-->
<property name="password"><value>pass</value></property>
</bean>
<!--定義Hibernate的SessionFactory-->
<bean id="sessionFactory"?


class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<!-- 依賴注入數據源，注入正是上文定義的dataSource>
<property name="dataSource"><ref local="dataSource"/></property>
<!-- mappingResouces屬性用來列出全部映射文件>
<property name="mappingResources">
<list>
<!--以下用來列出所有的PO映射文件-->
<value>lee/Person.hbm.xml</value>
</list>
</property>
<!--定義Hibernate的SessionFactory的屬性 -->
<property name="hibernateProperties">
<props>
<!-- 指定Hibernate的連接方言-->
<prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
<!-- 不同數據庫連接，啟動時選擇create,update,create-drop-->
<prop key="hibernate.hbm2ddl.auto">update</prop>
</props>
</property>
</bean>
<!-- 配置Person持久化類的DAO bean-->
<bean id="personDao" class="lee.PersonDaoImpl">
<!-- 采用依賴注入來傳入SessionFactory的引用>
<property name="sessionFactory"><ref local="sessionFactory"/></property>
</bean>
</beans>
DAO實現類中，可采用更簡單的方式來取得HibernateTemplate的實例。代碼如下：
public class PersnDAOImpl implements PersonDAO
{
//以私有的成員變量來保存SessionFactory。
private SessionFactory sessionFactory;
//設值注入SessionFactory必需的setter方法
public void setSessionFactory(SessionFactory sessionFactory)
{
this.sessionFactory = sessionFactory;
}


public List loadPersonByName(final String name)
{
HibernateTemplate hibernateTemplate =
new HibernateTemplate(this.sessionFactory);
//此處采用HibernateTemplate完成數據庫訪問
}
}


10.6.1 HibernateTemplate的常規用法


HibernateTemplate提供非常多的常用方法來完成基本的操作，比如通常的增加、刪除、修改、查詢等操


作，Spring 2.0更增加對命名SQL查詢的支持，也增加對分頁的支持。大部分情況下，使用Hibernate的


常規用法，就可完成大多數DAO對象的CRUD操作。下面是HibernateTemplate的常用方法簡介：
q void delete(Object entity)：刪除指定持久化實例
q deleteAll(Collection entities)：刪除集合內全部持久化類實例
q find(String queryString)：根據HQL查詢字符串來返回實例集合
q findByNamedQuery(String queryName)：根據命名查詢返回實例集合
q get(Class entityClass, Serializable id)：根據主鍵加載特定持久化類的實例
q save(Object entity)：保存新的實例
q saveOrUpdate(Object entity)：根據實例狀態，選擇保存或者更新
q update(Object entity)：更新實例的狀態，要求entity是持久狀態
q setMaxResults(int maxResults)：設置分頁的大小
下面是一個完整DAO類的源代碼：
public class PersonDAOHibernate implements PersonDAO
{
//采用log4j來完成調試時的日志功能
private static Log log = LogFactory.getLog(NewsDAOHibernate.class);
//以私有的成員變量來保存SessionFactory。
private SessionFactory sessionFactory;
//以私有變量的方式保存HibernateTemplate
private HibernateTemplate hibernateTemplate = null;
//設值注入SessionFactory必需的setter方法
public void setSessionFactory(SessionFactory sessionFactory)
{
this.sessionFactory = sessionFactory;
}
//初始化本DAO所需的HibernateTemplate
public HIbernateTemplate getHibernateTemplate()
{
//首先，檢查原來的hibernateTemplate實例是否還存在
if ( hibernateTemplate == null)
{
//如果不存在，新建一個HibernateTemplate實例
hibernateTemplate = new HibernateTemplate(sessionFactory);
}
return hibernateTemplate;
}
//返回全部的人的實例
public List getPersons()
{?
//通過HibernateTemplate的find方法返回Person的全部實例
return getHibernateTemplate().find("from Person");
}


public void savePerson(Person person)
{?
getHibernateT
========

使用HibernateTemplate進行數據庫功能開發完成Spring+Hibernate架構

在Spring架構基礎上 將其中的JdbcTemplate訪問數據庫的代碼改成用HibernateTemplate訪問數據庫 最


后形成Spring+Hibernate的軟件架構
?
準備工作：
1 ?刪除目錄\src\com\demo\spring\dao 該目錄下面的代碼是基于JdbcTemplate開發的DAO層代碼 我們


將開發基于HibernateTemplate的DAO層來替換它
2 ?復制jar文件到當前項目的\WEB-INF\lib目錄下 使項目來支持Hibernate事務 以及能夠提供對


Hibernate映射文件的解析
dom4j-1.6.jar
antlr-2.7.5H3.jar
jta.jar
3 ?基于Hibernate的開發 都需要創建數據庫表的映射文件和持久化類 將User.hbm.xml ?


AbstractUser.java ?User.java 復制到當前項目中\src\com\demo\hibernate\beans
?
開發過程：
需要在Bean配置文件中添加一系列組件 這些組件相互注入
dataSource 為sessionFactory提供數據源
sessionFactory Hibernate管理工廠 為userDAO的事務管理策略對象transactionManager提供


sessionFactory
transactionManager 為userDAO提供POJO類 利用被注入的數據源 定義一系列的業務操作函數 使用


JdbcTemplate來操作POJO類 實現對數據庫的操作
UserDAOProxy userDAO的事務管理策略對象 該對象規定了userDAO的管理策略 因此他需要注入userDAO


作為被管理的對象 進行事務管理也需要提供事務管理器 因此需要注入transactionManager作為事務管


理器
Action類 該類是響應處理類 負責調度userDAO函數即可實現數據庫的訪問 而對于userDAO的訪問都將在


UserDAOProxy的監管之下
圖示：
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? dataSource ?定義數據源
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?　｜　　注入數據源
　　　　　　　　　　　　　　　sessionFactory
? ? ? ? ? ? ?注入Hibernate ?| ? ? ? ? ? ? | 注入Hibernate
? ? ? ? ? ? POJO ? ? ? ? userDAO ? ? ? ?transactionManager
? ? ? ? ? ? ? ? ? ?注入DAO | ? ? ? | ?注入事務 |
? ? ? ? ? ? ? ? ? ? Action類 ? ? ? UserDAOProxy
步驟：
1 創建數據源dataSource
2 創建sessionFactory 并注入dataSource
3 創建事務管理對象transactionManager 并注入sessionFactory?
4 創建userDAO 并注入sessionFactory
5 創建事務管理策略對象UserDAOProxy 并注入管理策略對象userDAO和所用的事務管理器


transactionManager
6 創建Action 并注入userDAO
詳細步驟：
1 數據源配置
在applicationContext.xml中添加一個名稱為dataSource的 指向的類為DBCP的數據源類
?
<!-- 配置數據源 -->
? ? <bean id="dataSource"
? ? ? ? class="org.apache.commons.dbcp.BasicDataSource"
? ? ? ? destroy-method="close">
? ? ? ? <property name="driverClassName">
? ? ? ? ? ? <value>org.gjt.mm.mysql.Driver</value>
? ? ? ? </property>
? ? ? ? <property name="url">
? ? ? ? ? ? <value>jdbc:mysql://localhost:3306/demo</value>
? ? ? ? </property>
? ? ? ? <property name="username">
? ? ? ? ? ? <value>root</value>
? ? ? ? </property>
? ? ? ? <property name="password">
? ? ? ? ? ? <value></value>
? ? ? ? </property>
? ? </bean>
?
2 SessionFactory的配置
配置SessionFactory對象 為DAO層提供HIbernate的數據庫連接對象 注入配置的dataSource對象
?
<!-- 配置Hibernate -->
? ? <bean id="sessionFactory"
? ? ? ? class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
? ? ? ? <property name="dataSource">
? ? ? ? ? ? <ref local="dataSource" />
? ? ? ? </property>
? ? ? ? <property name="mappingResources">
? ? ? ? ? ? <list>
? ? ? ? ? ? ? ? <value>com/demo/hibernate/beans/User.hbm.xml</value>
? ? ? ? ? ? </list>
? ? ? ? </property>
? ? ? ? <property name="hibernateProperties">
? ? ? ? ? ? <props>
? ? ? ? ? ? ? ? <prop key="hibernate.dialect">
? ? ? ? ? ? ? ? ? ? org.hibernate.dialect.MySQLDialect
? ? ? ? ? ? ? ? </prop>
? ? ? ? ? ? ? ? <prop key="hibernate.show_sql">true</prop>
? ? ? ? ? ? </props>
? ? ? ? </property>
? ? </bean>
?
3 ?配置事務
為SessionFactory對象增加事務配置組件 并注入上面配置的SessionFactory對象
?
<!-- 配置事務 -->
? ? <bean id="transactionManager"
? ? ? ? class="org.springframework.orm.hibernate3.HibernateTransactionManager">
? ? ? ? <property name="sessionFactory">
? ? ? ? ? ? <ref local="sessionFactory" />
? ? ? ? </property>
? ? </bean>
4 ?配置DAO組件
我們先配置該組件的Bean對象 ?一個基于HibernateTemplate的DAO類


com.demo.hibernate.dao.UserDAO.java 并為這個對象注入SessionFactory對象
?
<!-- 定義DAO -->
? ? <bean id="userDAO" class="com.demo.hibernate.dao.UserDAO">
? ? ? ? <property name="sessionFactory">
? ? ? ? ? ? <ref local="sessionFactory" />
? ? ? ? </property>
? ? </bean>
5 ?配置DAO事務
為上面配置的DAO對象配置事務組件 使得對userDAO的訪問都在spring的事務監管下 改組件需要注入上


面配置的事務對象transactionManager DAO對象userDAO 并配置事務管理的策略
?
<!-- 定義DAO代理 -->
? ? <bean id="UserDAOProxy"
? ? ? ? class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
? ? ? ? <property name="transactionManager">
? ? ? ? ? ? <ref bean="transactionManager" />
? ? ? ? </property>
? ? ? ? <property name="target">
? ? ? ? ? ? <ref local="userDAO" />
? ? ? ? </property>
? ? ? ? <property name="transactionAttributes">
? ? ? ? ? ? <props>
? ? ? ? ? ? ? ? <prop key="insert*">PROPAGATION_REQUIRED</prop>
? ? ? ? ? ? ? ? <prop key="*">PROPAGATION_REQUIRED,readOnly</prop>
? ? ? ? ? ? </props>
? ? ? ? </property>
? ? </bean>
?
6 ?創建Hibernate DAO 類
? 首先創建一個接受類　com.demo.hibernate.dao.IUserDAO.java 創建接口的原因是為了讓Spring的


AOP機制能夠進行事務的管理 因為事務的管理是基于AOP實現的
在接口中聲明要實現的操作函數
package com.demo.hibernate.dao;


import java.util.List;


import com.demo.hibernate.beans.User;


public interface IUserDAO {


? ? public boolean isValid(final String username, final String password);


? ? public boolean i***ist(String username);


? ? public void insertUser(User user);


? ? public User getUser(String userid);


? ? public List getUsers();


? ? public void deleteUser(String userid);
}
在UserDAO.java 中實現聲明的函數
?
package com.demo.hibernate.dao;


import java.util.List;


import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.criterion.Restrictions;
import org.springframework.orm.hibernate3.HibernateCallback;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;


import com.demo.hibernate.beans.User;


public class UserDAO extends HibernateDaoSupport implements IUserDAO {


? ? public boolean isValid(final String username, final String password) {
? ? ? ? List list = (List) getHibernateTemplate().execute(new HibernateCallback() {
? ? ? ? ? ? public Object doInHibernate(Session session)
? ? ? ? ? ? ? ? ? ? throws HibernateException {
? ? ? ? ? ? ? ? List result = session.createCriteria(User.class).add(
? ? ? ? ? ? ? ? ? ? ? ? Restrictions.eq("username", username)).add(
? ? ? ? ? ? ? ? ? ? ? ? Restrictions.eq("password", password)).list();
? ? ? ? ? ? ? ? return result;
? ? ? ? ? ? }
? ? ? ? });
? ? ? ? if (list.size() > 0) {
? ? ? ? ? ? return true;
? ? ? ? } else {
? ? ? ? ? ? return false;
? ? ? ? }
? ? }


? ? public boolean i***ist(final String username) {
? ? ? ? List list = (List) getHibernateTemplate().execute(new HibernateCallback() {
? ? ? ? ? ? public Object doInHibernate(Session session)
? ? ? ? ? ? ? ? ? ? throws HibernateException {
? ? ? ? ? ? ? ? List result = session.createCriteria(User.class).add(
? ? ? ? ? ? ? ? ? ? ? ? Restrictions.eq("username", username)).list();
? ? ? ? ? ? ? ? return result;
? ? ? ? ? ? }
? ? ? ? });
? ? ? ? if (list.size() > 0) {
? ? ? ? ? ? return true;
? ? ? ? } else {
? ? ? ? ? ? return false;
? ? ? ? }
? ? }


? ? public void insertUser(User user) {
? ? ? ? getHibernateTemplate().saveOrUpdate(user);
? ? }


? ? public User getUser(String userid) {
? ? ? ? return (User) getHibernateTemplate().get(User.class,
? ? ? ? ? ? ? ? new Integer(userid));
? ? }


? ? public List getUsers() {
? ? ? ? return getHibernateTemplate().find("from User");
? ? }


? ? public void deleteUser(String userid) {
? ? ? ? Object p = getHibernateTemplate().load(User.class, new Integer(userid));
? ? ? ? getHibernateTemplate().delete(p);
? ? }
}
至此 就完成了使用HibernateTemplate訪問數據庫的DAO代碼的開發了 下面修改Action中的業務函數來


調用DAO中的函數
7 ?修改LoginAction訪問UserDAO進行登錄驗證
首先為LoginAction添加一個變量
?
UserDAO userDAO; ? ?


? ? public UserDAO getUserDAO() {
? ? ? ? return userDAO;
? ? }


? ? public void setUserDAO(UserDAO userDAO) {
? ? ? ? this.userDAO = userDAO;
? ? }
?
為applicationContext.xml中的loginAction的配置注入userDAO變量
?
<!---定義Action-->
? ? <bean id="loginAction"
? ? ? ? class="com.demo.spring.actions.LoginAction">
? ? ? ? <property name="commandClass">
? ? ? ? ? ? <value>com.demo.spring.forms.LoginForm</value>
? ? ? ? </property>
? ? ? ? <!-- 指定DAO類 -->
? ? ? ? <property name="userDAO">
? ? ? ? ? ? <ref local="userDAO" />
? ? ? ? </property>
? ? ? ? <!-- 指定驗證類 -->
? ? ? ? <property name="validator">
? ? ? ? ? ? <ref local="loginValidator" />
? ? ? ? </property>
? ? ? ? <!-- 指定失敗要返回的頁面 -->
? ? ? ? <property name="formView">
? ? ? ? ? ? <value>login</value>
? ? ? ? </property>
? ? ? ? <!-- 指定成功要返回的頁面 -->
? ? ? ? <property name="successView">
? ? ? ? ? ? <value>welcome</value>
? ? ? ? </property>
? ? </bean>
修改LoginAction處理類中用戶登錄驗證函數isValid() 使用被注入對象userDAO的isValid()函數
?
public boolean isValid(LoginForm loginForm) {
? ? ? ? /*if (loginForm.getUsername().equals("admin")
? ? ? ? ? ? ? ? || loginForm.getPassword().equals("admin")) {
? ? ? ? ? ? return true;
? ? ? ? } else {
? ? ? ? ? ? return false;
? ? ? ? }*/
? ? ? ? if(userDAO.isValid(loginForm.getUsername(), loginForm.getPassword())) {
? ? ? ? ? ? return true;
? ? ? ? } else {
? ? ? ? ? ? return false;
? ? ? ? }
? ? }
8 ?RegisterAction訪問UserDAO進行用戶注冊?
方法如7
這樣就形成了Spring+Hibernate架構 ?
========

hibernateTemplate內部實現原理

Spring中 Callback模式和Template模式合用 隨處可見。下面以常用的HibernateTemplate為例進行簡要


簡述。
在HibernateTemplate模板類中有一個核心的方法:doExecute，這個核心的方法采用模板方法 完成相關


的固定 操作（建立連接，執行操作，釋放連接） ，其中的具體步驟通過回調傳入的對象（這個對象就


是實現了Callback接口的類)來完成。


[java] view plain copy print?
import org.springframework.orm.hibernate3.HibernateTemplate; ?
@Component("userDaoImpl") ?
public class UserDaoImpl implements UserDao { ?
? ? private HibernateTemplate hibernateTemplate; ?
? ? public HibernateTemplate getHibernateTemplate() ?
? ? { ?
? ? ? ? return hibernateTemplate; ?
? ? } ?
??
? ? @Resource(name="hibernatTemplate") ?
? ? public void setHibernateTemplate(HibernateTemplate hibernateTemplate) { ?
? ? ? ? this.hibernateTemplate = hibernateTemplate; ?
? ? } ?
? ? @Override ?
? ? public void save(User u) { ? ? ? ? ?
? ? ? ? hibernateTemplate.save(u); ?
? ? ? ? //這里可以直接save了，session已經被hibernateTemplate處理了。我們不需要關心它了。 ?
? ? ? ? //因為HibernateTemplate中已經注入了SessionFactory了，因為它自己會處理好session及其


事務的。 ?
? ? ? ? System.out.println("user save..."); ?
}} ?


下面講一下HibernateTemplate的內部實現原理


[java] view plain copy print?
//建立HibernateTemplate回調函數 ?
interface HibernateCallback ?
{ ?
? ? //內部只有doInHibernate方法 ?
? ? public Object doInHibernate(Session session); ?
} ?
??
//建立Session類為實際該類為sessionFactory創建 ?
class Session ?
{ ? ? ?
? ? //這里只列出createQuery方法，實際存在save,update,load等方法 ?
? ? public Object createQuery(String hql) ?
? ? { ?
? ? ? ? System.out.println(hql); ?
? ? ? ? return "添加成功"; ?
? ? } ?
} ?
//HibernateTemplate類 ?
class BackCallTemplate ?
{ ?
? ? //這里是執行的方法 ?
? ? public Object execute(HibernateCallback backCall) ?
? ? { ?
? ? ? ? //這個方法的請求處理交給doExceute; ?
? ? ? ? return doExecute(backCall); ?
? ? } ?
??
? ? //它來做請求處理 ?
? ? public Object doExecute(HibernateCallback action) ?
? ? { ?
? ? ? ? //首先去判斷是否已經有一個session對象，如果沒有則創建一個,存在就返回Session對象 ?
? ? ? ? //Session session = (enforceNewSession ?SessionFactoryUtils.getNewSession


(getSessionFactory(), getEntityInterceptor()) : getSession()); ?
? ? ? ? Session session = new Session(); ?
? ? ? ? //這里執行架設函數 ?
? ? ? ? return action.doInHibernate(session); ?
? ? } ?
} ?
public class TempateMain ?
{ ?
? ? //這里僅僅使用main作測試 ?
? ? public static void main(String[] args) ?
? ? { ?
? ? ? ? //傳遞： ?
? ? ? ? //1.得到HibernateTemplate對象 ?
? ? ? ? //2.向HibernateTemplate.execute方法中傳遞HibernateCallback對象 ?
? ? ? ? //3.覆寫HibernateCallback對象 ?
? ? ??
? ? ? ? BackCallTemplate getHibernateTemplate = new BackCallTemplate(); ?
? ? ? ? //我們使用的是回調函數，在回調函數里處理行為 ?
? ? ? ? //疑問：怎么才能調用getHibernateTempleate.save(X x)呢？ ?
? ? ? ? //答：可將Main方法進行封裝，通過方法參數傳遞參數即可! ?
? ? ? ? String str = (String) getHibernateTemplate.execute(new HibernateCallback() ?
? ? ? ? { ?
? ? ? ? ? ? public Object doInHibernate(Session session) ?
? ? ? ? ? ? { ?
? ? ? ? ? ? ? ? return session.createQuery("select count(id) from table"); ?
? ? ? ? ? ? } ?
? ? ? ? }); ?
? ? ? ? ??
? ? ? ? System.out.println(str); ?
? ? } ?
??
} ?




參考文檔：http://blog.csdn.net/itpinpai/article/details/8236547
========

總結

以上是生活随笔為你收集整理的Java Hibernate模板 学习总结的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。