HibernateTemplate 理解（对Callback继续理解）

    经常使用spring封装hibernate的同学，在写dao的具体实现类的时候，一般都会让dao实现类继承HibernateDaoSupport，

这样，在我们的dao实现类中就可以直接获得HibernateTemplate对象来直接使用，HibernateTemplate封装Hibernate的基本操作，

   通过HibernateTemplate源码可知，我们需要给hibernateTemplate一个sessionFactory；一般都是通过spring注入

   hibernateTemplate提供了一系列的CRUD方法，现在我们以get的实现来说明：

//我们实际调用的方法	
public <T> T get(Class<T> entityClass, Serializable id) throws DataAccessException {
		return get(entityClass, id, null);
	}
//真实实现
	public <T> T get(final Class<T> entityClass, final Serializable id, final LockMode lockMode)
			throws DataAccessException {

		return executeWithNativeSession(new HibernateCallback<T>() {
			@SuppressWarnings("unchecked")
			public T doInHibernate(Session session) throws HibernateException {
				if (lockMode != null) {
					return (T) session.get(entityClass, id, lockMode);
				}
				else {
					return (T) session.get(entityClass, id);
				}
			}
		});
	}

//被调用方法
	public <T> T executeWithNativeSession(HibernateCallback<T> action) {
		return doExecute(action, false, true);
	}

    get()方法的具体实现是doExecute()方法，在此使用的Callback，把相同的操作都封装到了doExecute()方法中，具体的实现就在get（）方法中HibernateCallback中实现，通过上面的代码可以看出，我们的Callback方法doInHibernate需要一个参数session, 此参数是在doExecute方法中传入的（doExecute方法在下面描述），真正的获取值最终还是去操作session，这里就和Hibernate里操作一样，只不过此时的session的管理和事务的管理都在

doExecute（）方法中来完成，我们不需要关心，我们只需要关心我们的Callback实现我们需要的逻辑。

  下面我们看一下delete方法的实现：

//我们调用的方法	
public void delete(Object entity) throws DataAccessException {
		delete(entity, null);
	}

//具体实现方法
	public void delete(final Object entity, final LockMode lockMode) throws DataAccessException {
		executeWithNativeSession(new HibernateCallback<Object>() {
			public Object doInHibernate(Session session) throws HibernateException {
				checkWriteOperationAllowed(session);
				if (lockMode != null) {
					session.lock(entity, lockMode);
				}
				session.delete(entity);
				return null;
			}
		});
	}

   看到吗？和get方法如出一辙，底层实现使用doExecute方法，具体实现放到自己的Callback里

   再看一下复杂操作时，我们会调用execute方法，execute方法的实现：

public <T> T execute(HibernateCallback<T> action) throws DataAccessException {
		return doExecute(action, false, false);
	}

   对，不会错了把，HibernateTemplate就是使用Callback模式把所有的方法的相同实现都放到了doExecute（）方法中，具体实现放到CallBack中，Callback的抽象方法需要session，得到session后和hibernate的操作一抹一样。

  下面我们就来看看doExecute（）方法的具体实现：

protected <T> T doExecute(HibernateCallback<T> action, boolean enforceNewSession, boolean enforceNativeSession)
			throws DataAccessException {

		Assert.notNull(action, "Callback object must not be null");

		Session session = (enforceNewSession ?
				SessionFactoryUtils.getNewSession(getSessionFactory(), getEntityInterceptor()) : getSession());
		boolean existingTransaction = (!enforceNewSession &&
				(!isAllowCreate() || SessionFactoryUtils.isSessionTransactional(session, getSessionFactory())));
		if (existingTransaction) {
			logger.debug("Found thread-bound Session for HibernateTemplate");
		}

		FlushMode previousFlushMode = null;
		try {
			previousFlushMode = applyFlushMode(session, existingTransaction);
			enableFilters(session);
			Session sessionToExpose =
					(enforceNativeSession || isExposeNativeSession() ? session : createSessionProxy(session));
                        //此操作以前的代码都是在管理session，处理事务
			T result = action.doInHibernate(sessionToExpose);//此行调用了HibernateCallback的具体逻辑
			flushIfNecessary(session, existingTransaction);
			return result;
		}
		catch (HibernateException ex) {
			throw convertHibernateAccessException(ex);
		}
		catch (SQLException ex) {
			throw convertJdbcAccessException(ex);
		}
		catch (RuntimeException ex) {
			// Callback code threw application exception...
			throw ex;
		}
		finally {
			if (existingTransaction) {
				logger.debug("Not closing pre-bound Hibernate Session after HibernateTemplate");
				disableFilters(session);
				if (previousFlushMode != null) {
					session.setFlushMode(previousFlushMode);
				}
			}
			else {
				// Never use deferred close for an explicitly new Session.
				if (isAlwaysUseNewSession()) {
					SessionFactoryUtils.closeSession(session);
				}
				else {
					SessionFactoryUtils.closeSessionOrRegisterDeferredClose(session, getSessionFactory());
				}
			}
		}
	}

    代码逻辑很清晰，前半部分去获取session，管理事务，然后就是调用hibernateCallback中具体实现的逻辑，返回结果，然后做具体的事务和session管理，

   针对于hibernateTemplate提供的其他方法也是一样，使用callback模式，相同的操作都放到了doExecute中

   就这样hibernateTemplate屏蔽了hibernate的复杂操作，实现了封装