学步园

1：get/load存取单条数据

                public Teacher getTeacherById(Long id) {
			return (Teacher)this.hibernateTemplate.get(Teacher.class, id);
		}
		
		public Teacher getTeacherById(Long id) {
			return (Teacher)this.hibernateTemplate.load(Teacher.class, id);
		}

2：find/iterate查询操作

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

  find和iterato的区别主要是iterate采用了N+1次查询，对于大批量查询，比如查询10000条记录，那么iterate就要执行10000+1次查询，find和iterate应根据具体的实际

情况来使用，对于频繁的写操作对象，应使用find查询，而对于一些只读的数据对象，应使用iterate操作，因为iterate操作使用了Hibernate的缓存机制

3：save/update/saveOrUpdate/delete 保存/更新/删除操作

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

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

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

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

4：bulkUpdate批量删除或者更新

     bulkUpdate提供了批量删除和更新，直接转换为相应的update/delete SQL进行批量删除和更新

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

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

 此时要注意的一个问题是，使用bulkUpdate操作，必须手工清除相关对象在Hibernate中的缓存(包括一级缓存和二级缓存)

5：execute核心方法

public Object execute(HibernateCallBack action, boolean exposeNativeSession) throws DataAccessException {
		//获取一个Session
		Session session = getSession();
		//当前session是否在事务中
		boolean existingTransaction = SessionFactoryUtils.isSessionTransactional(session, getSessionFactory());
		FlushMode previousFlushMode = null;
		
		try {
			previousFlushMode = applyFlushMode(session, existingTransaction); //应用flush模式
			enableFilters(session);
			
			//暴露给action的session
			Session sessionToExpose = (exposeNativeSession? session: createSessionProxy(session));
			//执行action
			Object result = action.doInHibernate(sessionToExpose);
			flushIfNecessary(session, existingTransaction);
			
			return result;
			
		} catch(HibernateException ex) {
			throw convertHibernateAccessException(ex);
		} catch(SQLException ex) {
			throw convertJdbcAccessException(ex);
		} catch(RuntimeException ex) {
			throw ex;
		} finally {
			//如果session在事务中，则不关闭session
			if(existingTransaction) {
				disableFilters(session);
				if(previousFlushMode != null) {
					session.setFlushMode(previousFlushMode);
				}
			} else {
				//释放session
				SessionFactoryUtils.releaseSession(session, getSessionFactory());
			}
		}
	}

 *HibernateCallBack，一般用来实现特定的业务逻辑

 *exposeNativeSession：是一个布尔值，要暴露给HibernateCallBack实际的session对象，而不是一个代理过的对象

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

        public void createDatabaseSchema() throws DataAccessException {
		HibernateTemplate hibernateTemplate = new HibernateTemplate(this.sessionFactory);
		//调用HibernateTempalte的execute方法
		hibernateTemplate.execute(new HibernateCallback() {
			public Object doInHibernate(Session session) throws HibernateException, SQLException {  //实现HibernateCallback的doInHibernate方法
				//具体实现
				Connection conn = session.connection();
				final Dialect dialect = Dialect.getDialect(configuration.getProperties);
				String[] sql = configuration.generateSchemaCreationScript(dialect);
				executeSchemaScript(conn, sql);
			}
		});
	}

  使用execute方法的重点是实现HibernateCallback的doInHibernate方法，它会传递一个Session实例，可以使用此Session实例操作数据库，由此看出execute方法的好处是应用程序不用关心session的创建和释放，只需要处理关心的业务逻辑即可。