Spring和Hibernate集成的HibernateTemplate的一些常用方法总结

1：get/load存取单条数据

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

2：find/iterate查询操作

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

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. try {
8. previousFlushMode = applyFlushMode(session, existingTransaction); //应用flush模式
9. enableFilters(session);
10. //暴露给action的session
11. Session sessionToExpose = (exposeNativeSession? session: createSessionProxy(session));
12. //执行action
13. Object result = action.doInHibernate(sessionToExpose);
14. flushIfNecessary(session, existingTransaction);
15. return result;
16. } catch(HibernateException ex) {
17. throw convertHibernateAccessException(ex);
18. } catch(SQLException ex) {
19. throw convertJdbcAccessException(ex);
20. } catch(RuntimeException ex) {
21. throw ex;
22. } finally {
23. //如果session在事务中，则不关闭session
24. if(existingTransaction) {
25. disableFilters(session);
26. if(previousFlushMode != null) {
27. session.setFlushMode(previousFlushMode);
28. }
29. } else {
30. //释放session
31. SessionFactoryUtils.releaseSession(session, getSessionFactory());
32. }
33. }
34. }

*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的创建和释放，只需要处理关心的业务逻辑即可。