Spring和Hibernate整合的HibernateTemplate的一些常用方法總結

1：get/load存取單條資料

1.               public Teacher getTeacherById(Long id) {  
2.     return (Teacher)this.hibernateTemplate.get(Teacher.class, id);  
3. }  
4.   
5. public Teacher getTeacherById(Long id) {  
6.     return (Teacher)this.hibernateTemplate.load(Teacher.class, id);  
7. }  

2：find/iterate查詢操作

1.              public Iterator getTeachersByAge(int age) {  
2.     Iterator iterator = null;  
3.       
4.     //使用find方法  
5.     List list = (List)this.hibernateTemplate().find("from Teacher t where t.age>?", new Integer(age));  
6.     iterator = list.iterator();  
7.       
8.     //使用iterator方法  
9.     iterator = this.hibernateTemplate().iterate("from Teacher t where t.age>?", new Integer(age));  
10.       
11.     return iterator;  
12. }  

find和iterato的區別主要是iterate採用了N+1次查詢，對於大批量查詢，比如查詢10000條記錄，那麼iterate就要執行10000+1次查詢，find和iterate應根據具體的實際

情況來使用，對於頻繁的寫操作對象，應使用find查詢，而對於一些唯讀資料對象，應使用iterate操作，因為iterate操作使用了Hibernate的緩衝機制

3：save/update/saveOrUpdate/delete 儲存/更新/刪除操作  

 

1.        public void save(Teacher teacher) {  
2.     this.hibernateTemplate.save(teacher);  
3. }  

 

1.        public void update(Teacher teacher) {  
2.     this.hibernateTemplate.update(teacher);  
3. }  

                

1.       public void update(Teacher teacher) {  
2.     this.hibernateTemplate.saveOrUpdate(teacher);  
3. }  

                

1.        public void update(Teacher teacher) {  
2.     this.hibernateTemplate.delete(teacher);  
3. }  

4：bulkUpdate大量刪除或者更新

bulkUpdate提供了大量刪除和更新，直接轉換為相應的update/delete SQL進行大量刪除和更新

1.        public void batchDelete(String name, int age) {  
2.     this.hibernateTemplate.bulkUpdate("delete Teacher where name=? and age = ?", new Object[]{name, age});  
3. }  

              

1.        public void batchDelete(String name, String newName) {  
2.     this.hibernateTemplate.bulkUpdate("update Teacher set name=? where name=?", new Object[]{newName, name});  
3. }  

此時要注意的一個問題是，使用bulkUpdate操作，必須手工清除相關對象在Hibernate中的緩衝(包括一級緩衝和二級緩衝)

5：execute核心方法

1. public Object execute(HibernateCallBack action, boolean exposeNativeSession) throws DataAccessException {  
2.         //擷取一個Session  
3.         Session session = getSession();  
4.         //當前session是否在事務中  
5.         boolean existingTransaction = SessionFactoryUtils.isSessionTransactional(session, getSessionFactory());  
6.         FlushMode previousFlushMode = null;  
7.           
8.         try {  
9.             previousFlushMode = applyFlushMode(session, existingTransaction); //應用flush模式  
10.             enableFilters(session);  
11.               
12.             //暴露給action的session  
13.             Session sessionToExpose = (exposeNativeSession? session: createSessionProxy(session));  
14.             //執行action  
15.             Object result = action.doInHibernate(sessionToExpose);  
16.             flushIfNecessary(session, existingTransaction);  
17.               
18.             return result;  
19.               
20.         } catch(HibernateException ex) {  
21.             throw convertHibernateAccessException(ex);  
22.         } catch(SQLException ex) {  
23.             throw convertJdbcAccessException(ex);  
24.         } catch(RuntimeException ex) {  
25.             throw ex;  
26.         } finally {  
27.             //如果session在事務中，則不關閉session  
28.             if(existingTransaction) {  
29.                 disableFilters(session);  
30.                 if(previousFlushMode != null) {  
31.                     session.setFlushMode(previousFlushMode);  
32.                 }  
33.             } else {  
34.                 //釋放session  
35.                 SessionFactoryUtils.releaseSession(session, getSessionFactory());  
36.             }  
37.         }  
38.     }  

*HibernateCallBack，一般用來實現特定的商務邏輯

 *exposeNativeSession：是一個布爾值，要暴露給HibernateCallBack實際的session對象，而不是一個代理過的對象

6：一般情況下，只有HIberateTemplate提供的方法不能滿足要求時才使用execute方法，它的使用方式如下所示，

1.        public void createDatabaseSchema() throws DataAccessException {  
2.     HibernateTemplate hibernateTemplate = new HibernateTemplate(this.sessionFactory);  
3.     //調用HibernateTempalte的execute方法  
4.     hibernateTemplate.execute(new HibernateCallback() {  
5.         public Object doInHibernate(Session session) throws HibernateException, SQLException {  //實現HibernateCallback的doInHibernate方法  
6.             //具體實現  
7.             Connection conn = session.connection();  
8.             final Dialect dialect = Dialect.getDialect(configuration.getProperties);  
9.             String[] sql = configuration.generateSchemaCreationScript(dialect);  
10.             executeSchemaScript(conn, sql);  
11.         }  
12.     });  
13. }  

使用execute方法的重點是實現HibernateCallback的doInHibernate方法，它會傳遞一個Session執行個體，可以使用此Session執行個體操作資料庫，由此看出execute方法的好處是應用程式不用關心session的建立和釋放，只需要處理關心的商務邏輯即可。