Spring封装Hibernate

Spring封装Hibernate
 
public Object execute(HibernateCallback action) throws DataAccessException {
  return execute(action, isExposeNativeSession());
 }

 public List executeFind(HibernateCallback action) throws DataAccessException {
  Object result = execute(action, isExposeNativeSession());
  if (result != null && !(result instanceof List)) {
   throw new InvalidDataAccessApiUsageException(
     "Result object returned from HibernateCallback isn't a List: [" + result + "]");
  }
  return (List) result;
 }

 public Object execute(HibernateCallback action, boolean exposeNativeSession) throws DataAccessException {
  Assert.notNull(action, "Callback object must not be null");

  Session session = getSession();
  boolean existingTransaction = SessionFactoryUtils.isSessionTransactional(session, getSessionFactory());
  if (existingTransaction) {
   logger.debug("Found thread-bound Session for HibernateTemplate");
  }

  FlushMode previousFlushMode = null;
  try {
   previousFlushMode = applyFlushMode(session, existingTransaction);
   Session sessionToExpose = (exposeNativeSession ? session : createSessionProxy(session));
   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) {
   // Callback code threw application exception...
   throw ex;
  }
  finally {
   if (existingTransaction) {
    logger.debug("Not closing pre-bound Hibernate Session after HibernateTemplate");
    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());
    }
   }
  }
 }


-----------------------------

public void update(Object entity) throws DataAccessException {
  update(entity, null);
 }

 public void update(final Object entity, final LockMode lockMode) throws DataAccessException {
  execute(new HibernateCallback() {
   public Object doInHibernate(Session session) throws HibernateException {
    checkWriteOperationAllowed(session);
    session.update(entity);
    if (lockMode != null) {
     session.lock(entity, lockMode);
    }
    return null;
   }
  }, true);
 }

 public void saveOrUpdate(final Object entity) throws DataAccessException {
  execute(new HibernateCallback() {
   public Object doInHibernate(Session session) throws HibernateException {
    checkWriteOperationAllowed(session);
    session.saveOrUpdate(entity);
    return null;
   }
  }, true);
 }

 public void saveOrUpdateAll(final Collection entities) throws DataAccessException {
  execute(new HibernateCallback() {
   public Object doInHibernate(Session session) throws HibernateException {
    checkWriteOperationAllowed(session);
    for (Iterator it = entities.iterator(); it.hasNext();) {
     session.saveOrUpdate(it.next());
    }
    return null;
   }
  }, true);
 }

 public Object saveOrUpdateCopy(final Object entity) throws DataAccessException {
  return execute(new HibernateCallback() {
   public Object doInHibernate(Session session) throws HibernateException {
    checkWriteOperationAllowed(session);
    return session.saveOrUpdateCopy(entity);
   }
  }, true);
 }

-------------------------

 public List find(final String queryString, final Object[] values, final Type[] types)
   throws DataAccessException {

  if (values != null && types != null && values.length != types.length) {
   throw new IllegalArgumentException("Length of values array must match length of types array");
  }
  return (List) execute(new HibernateCallback() {
   public Object doInHibernate(Session session) throws HibernateException {
    Query queryObject = session.createQuery(queryString);
    prepareQuery(queryObject);
    if (values != null) {
     for (int i = 0; i < values.length; i++) {
      if (types != null && types[i] != null) {
       queryObject.setParameter(i, values[i], types[i]);
      }
      else {
       queryObject.setParameter(i, values[i]);
      }
     }
    }
    return queryObject.list();
   }
  }, true);
 }

----------------------------

 public List findByNamedParam(
     final String queryString, final String[] paramNames, final Object[] values, final Type[] types)
     throws DataAccessException {

  if (paramNames.length != values.length) {
   throw new IllegalArgumentException("Length of paramNames array must match length of values array");
  }
  if (types != null && paramNames.length != types.length) {
   throw new IllegalArgumentException("Length of paramNames array must match length of types array");
  }
  return (List) execute(new HibernateCallback() {
   public Object doInHibernate(Session session) throws HibernateException {
    Query queryObject = session.createQuery(queryString);
    prepareQuery(queryObject);
    if (values != null) {
     for (int i = 0; i < values.length; i++) {
      applyNamedParameterToQuery(queryObject, paramNames[i], values[i], (types != null ? types[i] : null));
     }
    }
    return queryObject.list();
   }
  }, true);
 }

 public List findByValueBean(final String queryString, final Object valueBean)
   throws DataAccessException {

  return (List) execute(new HibernateCallback() {
   public Object doInHibernate(Session session) throws HibernateException {
    Query queryObject = session.createQuery(queryString);
    prepareQuery(queryObject);
    queryObject.setProperties(valueBean);
    return queryObject.list();
   }
  }, true);
 }

----------------------

 public List findByNamedQuery(final String queryName, final Object[] values, final Type[] types)
   throws DataAccessException {

  if (values != null && types != null && values.length != types.length) {
   throw new IllegalArgumentException("Length of values array must match length of types array");
  }
  return (List) execute(new HibernateCallback() {
   public Object doInHibernate(Session session) throws HibernateException {
    Query queryObject = session.getNamedQuery(queryName);
    prepareQuery(queryObject);
    if (values != null) {
     for (int i = 0; i < values.length; i++) {
      if (types != null && types[i] != null) {
       queryObject.setParameter(i, values[i], types[i]);
      }
      else {
       queryObject.setParameter(i, values[i]);
      }
     }
    }
    return queryObject.list();
   }
  }, true);
 }

------------------------

 public List findByNamedQueryAndNamedParam(
     final String queryName, final String[] paramNames, final Object[] values, final Type[] types)
     throws DataAccessException {

  if (paramNames != null && values != null && paramNames.length != values.length) {
   throw new IllegalArgumentException("Length of paramNames array must match length of values array");
  }
  if (values != null && types != null && paramNames.length != types.length) {
   throw new IllegalArgumentException("Length of paramNames array must match length of types array");
  }
  return (List) execute(new HibernateCallback() {
   public Object doInHibernate(Session session) throws HibernateException {
    Query queryObject = session.getNamedQuery(queryName);
    prepareQuery(queryObject);
    if (values != null) {
     for (int i = 0; i < values.length; i++) {
      applyNamedParameterToQuery(queryObject, paramNames[i], values[i], (types != null ? types[i] : null));
     }
    }
    return queryObject.list();
   }
  }, true);
 }

 public List findByNamedQueryAndValueBean(final String queryName, final Object valueBean)
   throws DataAccessException {

  return (List) execute(new HibernateCallback() {
   public Object doInHibernate(Session session) throws HibernateException {
    Query queryObject = session.getNamedQuery(queryName);
    prepareQuery(queryObject);
    queryObject.setProperties(valueBean);
    return queryObject.list();
   }
  }, true);
 }

-------------------

 protected void prepareQuery(Query queryObject) {
  if (isCacheQueries()) {
   queryObject.setCacheable(true);
   if (getQueryCacheRegion() != null) {
    queryObject.setCacheRegion(getQueryCacheRegion());
   }
  }
  if (getFetchSize() > 0) {
   queryObject.setFetchSize(getFetchSize());
  }
  if (getMaxResults() > 0) {
   queryObject.setMaxResults(getMaxResults());
  }
  SessionFactoryUtils.applyTransactionTimeout(queryObject, getSessionFactory());
 }

 protected void prepareCriteria(Criteria criteria) {
  if (isCacheQueries()) {
   criteria.setCacheable(true);
   if (getQueryCacheRegion() != null) {
    criteria.setCacheRegion(getQueryCacheRegion());
   }
  }
  if (getFetchSize() > 0) {
   criteria.setFetchSize(getFetchSize());
  }
  if (getMaxResults() > 0) {
   criteria.setMaxResults(getMaxResults());
  }
  SessionFactoryUtils.applyTransactionTimeout(criteria, getSessionFactory());
 }

-----------------------


 protected void applyNamedParameterToQuery(Query queryObject, String paramName, Object value, Type type)
   throws HibernateException {

  if (value instanceof Collection) {
   if (type != null) {
    queryObject.setParameterList(paramName, (Collection) value, type);
   }
   else {
    queryObject.setParameterList(paramName, (Collection) value);
   }
  }
  else if (value instanceof Object[]) {
   if (type != null) {
    queryObject.setParameterList(paramName, (Object[]) value, type);
   }
   else {
    queryObject.setParameterList(paramName, (Object[]) value);
   }
  }
  else {
   if (type != null) {
    queryObject.setParameter(paramName, value, type);
   }
   else {
    queryObject.setParameter(paramName, value);
   }
  }
 }