Sping学习之HibernateTemplate源码

        对Spring和Hibernate整合过程中，一直不太懂原理，感觉看着API用，实在是不踏实，于是上网找到了这个HibernateDaoSupport中提供的模版方法的源码，代码如下：

/* * Copyright 2002-2008 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * *      http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */package org.springframework.orm.hibernate3;import java.io.Serializable;import java.lang.reflect.InvocationHandler;import java.lang.reflect.InvocationTargetException;import java.lang.reflect.Method;import java.lang.reflect.Proxy;import java.sql.SQLException;import java.util.Collection;import java.util.Iterator;import java.util.List;import org.hibernate.Criteria;import org.hibernate.Filter;import org.hibernate.FlushMode;import org.hibernate.Hibernate;import org.hibernate.HibernateException;import org.hibernate.LockMode;import org.hibernate.Query;import org.hibernate.ReplicationMode;import org.hibernate.Session;import org.hibernate.SessionFactory;import org.hibernate.criterion.DetachedCriteria;import org.hibernate.criterion.Example;import org.hibernate.engine.SessionImplementor;import org.hibernate.event.EventSource;import org.springframework.dao.DataAccessException;import org.springframework.dao.DataAccessResourceFailureException;import org.springframework.dao.InvalidDataAccessApiUsageException;import org.springframework.util.Assert;/** * Helper class that simplifies Hibernate data access code. Automatically * converts HibernateExceptions into DataAccessExceptions, following the * <code>org.springframework.dao exception hierarchy. * * <p>The central method is execute, supporting Hibernate access code * implementing the {@link HibernateCallback} interface. It provides Hibernate Session * handling such that neither the HibernateCallback implementation nor the calling * code needs to explicitly care about retrieving/closing Hibernate Sessions, * or handling Session lifecycle exceptions. For typical single step actions, * there are various convenience methods (find, load, saveOrUpdate, delete). * * <p>Can be used within a service implementation via direct instantiation * with a SessionFactory reference, or get prepared in an application context * and given to services as bean reference. Note: The SessionFactory should * always be configured as bean in the application context, in the first case * given to the service directly, in the second case to the prepared template. * * <p>NOTE: As of Hibernate 3.0.1, transactional Hibernate access code can * also be coded in plain Hibernate style. Hence, for newly started projects, * consider adopting the standard Hibernate3 style of coding data access objects * instead, based on {@link org.hibernate.SessionFactory#getCurrentSession()}.</b> * * <p>This class can be considered as direct alternative to working with the raw * Hibernate3 Session API (through <code>SessionFactory.getCurrentSession()). * The major advantage is its automatic conversion to DataAccessExceptions as well * as its capability to fall back to 'auto-commit' style behavior when used outside * of transactions. <b>Note that HibernateTemplate will perform its own Session * management, not participating in a custom Hibernate CurrentSessionContext * unless you explicitly switch {@link #setAllowCreate "allowCreate"} to "false".</b> * * <p>{@link LocalSessionFactoryBean} is the preferred way of obtaining a reference * to a specific Hibernate SessionFactory, at least in a non-EJB environment. * The Spring application context will manage its lifecycle, initializing and * shutting down the factory as part of the application. * * <p>Note that operations that return an Iterator (i.e. iterate) * are supposed to be used within Spring-driven or JTA-driven transactions * (with HibernateTransactionManager, JtaTransactionManager, or EJB CMT). * Else, the Iterator won't be able to read results from its ResultSet anymore, * as the underlying Hibernate Session will already have been closed. * * <p>Lazy loading will also just work with an open Hibernate Session, * either within a transaction or within OpenSessionInViewFilter/Interceptor. * Furthermore, some operations just make sense within transactions, * for example: <code>contains, evict, lock, * <code>flush, clear. * * @author Juergen Hoeller * @since 1.2 * @see #setSessionFactory * @see HibernateCallback * @see org.hibernate.Session * @see LocalSessionFactoryBean * @see HibernateTransactionManager * @see org.springframework.transaction.jta.JtaTransactionManager * @see org.springframework.orm.hibernate3.support.OpenSessionInViewFilter * @see org.springframework.orm.hibernate3.support.OpenSessionInViewInterceptor */public class HibernateTemplate extends HibernateAccessor implements HibernateOperations {private boolean allowCreate = true;private boolean alwaysUseNewSession = false;private boolean exposeNativeSession = false;private boolean checkWriteOperations = true;private boolean cacheQueries = false;private String queryCacheRegion;private int fetchSize = 0;private int maxResults = 0;/** * Create a new HibernateTemplate instance. */public HibernateTemplate() {}/** * Create a new HibernateTemplate instance. * @param sessionFactory SessionFactory to create Sessions */public HibernateTemplate(SessionFactory sessionFactory) {setSessionFactory(sessionFactory);afterPropertiesSet();}/** * Create a new HibernateTemplate instance. * @param sessionFactory SessionFactory to create Sessions * @param allowCreate if a non-transactional Session should be created when no * transactional Session can be found for the current thread */public HibernateTemplate(SessionFactory sessionFactory, boolean allowCreate) {setSessionFactory(sessionFactory);setAllowCreate(allowCreate);afterPropertiesSet();}/** * Set if a new {@link Session} should be created when no transactional * <code>Session can be found for the current thread. * The default value is <code>true. * <p>HibernateTemplate is aware of a corresponding * <code>Session bound to the current thread, for example when using * {@link HibernateTransactionManager}. If <code>allowCreate is * <code>true, a new non-transactional Session will be * created if none is found, which needs to be closed at the end of the operation. * If <code>false, an {@link IllegalStateException} will get thrown in * this case. * <p>NOTE: As of Spring 2.5, switching allowCreate * to <code>false will delegate to Hibernate's * {@link org.hibernate.SessionFactory#getCurrentSession()} method,</b> * which - with Spring-based setup - will by default delegate to Spring's * <code>SessionFactoryUtils.getSession(sessionFactory, false). * This mode also allows for custom Hibernate CurrentSessionContext strategies * to be plugged in, whereas <code>allowCreate set to true * will always use a Spring-managed Hibernate Session. * @see SessionFactoryUtils#getSession(SessionFactory, boolean) */public void setAllowCreate(boolean allowCreate) {this.allowCreate = allowCreate;}/** * Return if a new Session should be created if no thread-bound found. */public boolean isAllowCreate() {return this.allowCreate;}/** * Set whether to always use a new Hibernate Session for this template. * Default is "false"; if activated, all operations on this template will * work on a new Hibernate Session even in case of a pre-bound Session * (for example, within a transaction or OpenSessionInViewFilter). * <p>Within a transaction, a new Hibernate Session used by this template * will participate in the transaction through using the same JDBC * Connection. In such a scenario, multiple Sessions will participate * in the same database transaction. * <p>Turn this on for operations that are supposed to always execute * independently, without side effects caused by a shared Hibernate Session. */public void setAlwaysUseNewSession(boolean alwaysUseNewSession) {this.alwaysUseNewSession = alwaysUseNewSession;}/** * Return whether to always use a new Hibernate Session for this template. */public boolean isAlwaysUseNewSession() {return this.alwaysUseNewSession;}/** * Set whether to expose the native Hibernate Session to * HibernateCallback code. * <p>Default is "false": a Session proxy will be returned, suppressing * <code>close calls and automatically applying query cache * settings and transaction timeouts. * @see HibernateCallback * @see org.hibernate.Session * @see #setCacheQueries * @see #setQueryCacheRegion * @see #prepareQuery * @see #prepareCriteria */public void setExposeNativeSession(boolean exposeNativeSession) {this.exposeNativeSession = exposeNativeSession;}/** * Return whether to expose the native Hibernate Session to * HibernateCallback code, or rather a Session proxy. */public boolean isExposeNativeSession() {return this.exposeNativeSession;}/** * Set whether to check that the Hibernate Session is not in read-only mode * in case of write operations (save/update/delete). * <p>Default is "true", for fail-fast behavior when attempting write operations * within a read-only transaction. Turn this off to allow save/update/delete * on a Session with flush mode NEVER. * @see #setFlushMode * @see #checkWriteOperationAllowed * @see org.springframework.transaction.TransactionDefinition#isReadOnly */public void setCheckWriteOperations(boolean checkWriteOperations) {this.checkWriteOperations = checkWriteOperations;}/** * Return whether to check that the Hibernate Session is not in read-only * mode in case of write operations (save/update/delete). */public boolean isCheckWriteOperations() {return this.checkWriteOperations;}/** * Set whether to cache all queries executed by this template. * <p>If this is "true", all Query and Criteria objects created by * this template will be marked as cacheable (including all * queries through find methods). * <p>To specify the query region to be used for queries cached * by this template, set the "queryCacheRegion" property. * @see #setQueryCacheRegion * @see org.hibernate.Query#setCacheable * @see org.hibernate.Criteria#setCacheable */public void setCacheQueries(boolean cacheQueries) {this.cacheQueries = cacheQueries;}/** * Return whether to cache all queries executed by this template. */public boolean isCacheQueries() {return this.cacheQueries;}/** * Set the name of the cache region for queries executed by this template. * <p>If this is specified, it will be applied to all Query and Criteria objects * created by this template (including all queries through find methods). * <p>The cache region will not take effect unless queries created by this * template are configured to be cached via the "cacheQueries" property. * @see #setCacheQueries * @see org.hibernate.Query#setCacheRegion * @see org.hibernate.Criteria#setCacheRegion */public void setQueryCacheRegion(String queryCacheRegion) {this.queryCacheRegion = queryCacheRegion;}/** * Return the name of the cache region for queries executed by this template. */public String getQueryCacheRegion() {return this.queryCacheRegion;}/** * Set the fetch size for this HibernateTemplate. This is important for processing * large result sets: Setting this higher than the default value will increase * processing speed at the cost of memory consumption; setting this lower can * avoid transferring row data that will never be read by the application. * <p>Default is 0, indicating to use the JDBC driver's default. */public void setFetchSize(int fetchSize) {this.fetchSize = fetchSize;}/** * Return the fetch size specified for this HibernateTemplate. */public int getFetchSize() {return this.fetchSize;}/** * Set the maximum number of rows for this HibernateTemplate. This is important * for processing subsets of large result sets, avoiding to read and hold * the entire result set in the database or in the JDBC driver if we're * never interested in the entire result in the first place (for example, * when performing searches that might return a large number of matches). * <p>Default is 0, indicating to use the JDBC driver's default. */public void setMaxResults(int maxResults) {this.maxResults = maxResults;}/** * Return the maximum number of rows specified for this HibernateTemplate. */public int getMaxResults() {return this.maxResults;}public Object execute(HibernateCallback action) throws DataAccessException {return doExecute(action, false, false);}public List executeFind(HibernateCallback action) throws DataAccessException {Object result = doExecute(action, false, false);if (result != null && !(result instanceof List)) {throw new InvalidDataAccessApiUsageException("Result object returned from HibernateCallback isn't a List: [" + result + "]");}return (List) result;}/** * Execute the action specified by the given action object within a * new {@link org.hibernate.Session}. * <p>This execute variant overrides the template-wide * {@link #isAlwaysUseNewSession() "alwaysUseNewSession"} setting. * @param action callback object that specifies the Hibernate action * @return a result object returned by the action, or <code>null * @throws org.springframework.dao.DataAccessException in case of Hibernate errors */public Object executeWithNewSession(HibernateCallback action) {return doExecute(action, true, false);}/** * Execute the action specified by the given action object within a * native {@link org.hibernate.Session}. * <p>This execute variant overrides the template-wide * {@link #isExposeNativeSession() "exposeNativeSession"} setting. * @param action callback object that specifies the Hibernate action * @return a result object returned by the action, or <code>null * @throws org.springframework.dao.DataAccessException in case of Hibernate errors */public Object executeWithNativeSession(HibernateCallback action) {return doExecute(action, false, true);}/** * Execute the action specified by the given action object within a Session. * @param action callback object that specifies the Hibernate action * @param enforceNativeSession whether to enforce exposure of the native * Hibernate Session to callback code * @return a result object returned by the action, or <code>null * @throws org.springframework.dao.DataAccessException in case of Hibernate errors * @deprecated as of Spring 2.5, in favor of {@link #executeWithNativeSession} */public Object execute(HibernateCallback action, boolean enforceNativeSession) throws DataAccessException {return doExecute(action, false, enforceNativeSession);}/** * Execute the action specified by the given action object within a Session. * @param action callback object that specifies the Hibernate action * @param enforceNewSession whether to enforce a new Session for this template * even if there is a pre-bound transactional Session * @param enforceNativeSession whether to enforce exposure of the native * Hibernate Session to callback code * @return a result object returned by the action, or <code>null * @throws org.springframework.dao.DataAccessException in case of Hibernate errors */protected Object doExecute(HibernateCallback 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));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");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());}}}}/** * Return a Session for use by this template. * <p>Returns a new Session in case of "alwaysUseNewSession" (using the same * JDBC Connection as a transactional Session, if applicable), a pre-bound * Session in case of "allowCreate" turned off, and a pre-bound or new Session * otherwise (new only if no transactional or otherwise pre-bound Session exists). * @return the Session to use (never <code>null) * @see SessionFactoryUtils#getSession * @see SessionFactoryUtils#getNewSession * @see #setAlwaysUseNewSession * @see #setAllowCreate */protected Session getSession() {if (isAlwaysUseNewSession()) {return SessionFactoryUtils.getNewSession(getSessionFactory(), getEntityInterceptor());}else if (isAllowCreate()) {return SessionFactoryUtils.getSession(getSessionFactory(), getEntityInterceptor(), getJdbcExceptionTranslator());}else {try {return getSessionFactory().getCurrentSession();}catch (HibernateException ex) {throw new DataAccessResourceFailureException("Could not obtain current Hibernate Session", ex);}}}/** * Create a close-suppressing proxy for the given Hibernate Session. * The proxy also prepares returned Query and Criteria objects. * @param session the Hibernate Session to create a proxy for * @return the Session proxy * @see org.hibernate.Session#close() * @see #prepareQuery * @see #prepareCriteria */protected Session createSessionProxy(Session session) {Class[] sessionIfcs = null;Class mainIfc = (session instanceof org.hibernate.classic.Session ?org.hibernate.classic.Session.class : Session.class);if (session instanceof EventSource) {sessionIfcs = new Class[] {mainIfc, EventSource.class};}else if (session instanceof SessionImplementor) {sessionIfcs = new Class[] {mainIfc, SessionImplementor.class};}else {sessionIfcs = new Class[] {mainIfc};}return (Session) Proxy.newProxyInstance(getClass().getClassLoader(), sessionIfcs,new CloseSuppressingInvocationHandler(session));}//-------------------------------------------------------------------------// Convenience methods for loading individual objects//-------------------------------------------------------------------------public Object get(Class entityClass, Serializable id) throws DataAccessException {return get(entityClass, id, null);}public Object get(final Class entityClass, final Serializable id, final LockMode lockMode)throws DataAccessException {return executeWithNativeSession(new HibernateCallback() {public Object doInHibernate(Session session) throws HibernateException {if (lockMode != null) {return session.get(entityClass, id, lockMode);}else {return session.get(entityClass, id);}}});}public Object get(String entityName, Serializable id) throws DataAccessException {return get(entityName, id, null);}public Object get(final String entityName, final Serializable id, final LockMode lockMode)throws DataAccessException {return executeWithNativeSession(new HibernateCallback() {public Object doInHibernate(Session session) throws HibernateException {if (lockMode != null) {return session.get(entityName, id, lockMode);}else {return session.get(entityName, id);}}});}public Object load(Class entityClass, Serializable id) throws DataAccessException {return load(entityClass, id, null);}public Object load(final Class entityClass, final Serializable id, final LockMode lockMode)throws DataAccessException {return executeWithNativeSession(new HibernateCallback() {public Object doInHibernate(Session session) throws HibernateException {if (lockMode != null) {return session.load(entityClass, id, lockMode);}else {return session.load(entityClass, id);}}});}public Object load(String entityName, Serializable id) throws DataAccessException {return load(entityName, id, null);}public Object load(final String entityName, final Serializable id, final LockMode lockMode)throws DataAccessException {return executeWithNativeSession(new HibernateCallback() {public Object doInHibernate(Session session) throws HibernateException {if (lockMode != null) {return session.load(entityName, id, lockMode);}else {return session.load(entityName, id);}}});}public List loadAll(final Class entityClass) throws DataAccessException {return (List) executeWithNativeSession(new HibernateCallback() {public Object doInHibernate(Session session) throws HibernateException {Criteria criteria = session.createCriteria(entityClass);prepareCriteria(criteria);return criteria.list();}});}public void load(final Object entity, final Serializable id) throws DataAccessException {executeWithNativeSession(new HibernateCallback() {public Object doInHibernate(Session session) throws HibernateException {session.load(entity, id);return null;}});}public void refresh(final Object entity) throws DataAccessException {refresh(entity, null);}public void refresh(final Object entity, final LockMode lockMode) throws DataAccessException {executeWithNativeSession(new HibernateCallback() {public Object doInHibernate(Session session) throws HibernateException {if (lockMode != null) {session.refresh(entity, lockMode);}else {session.refresh(entity);}return null;}});}public boolean contains(final Object entity) throws DataAccessException {Boolean result = (Boolean) executeWithNativeSession(new HibernateCallback() {public Object doInHibernate(Session session) {return (session.contains(entity) ? Boolean.TRUE : Boolean.FALSE);}});return result.booleanValue();}public void evict(final Object entity) throws DataAccessException {executeWithNativeSession(new HibernateCallback() {public Object doInHibernate(Session session) throws HibernateException {session.evict(entity);return null;}});}public void initialize(Object proxy) throws DataAccessException {try {Hibernate.initialize(proxy);}catch (HibernateException ex) {throw SessionFactoryUtils.convertHibernateAccessException(ex);}}public Filter enableFilter(String filterName) throws IllegalStateException {Session session = SessionFactoryUtils.getSession(getSessionFactory(), false);Filter filter = session.getEnabledFilter(filterName);if (filter == null) {filter = session.enableFilter(filterName);}return filter;}//-------------------------------------------------------------------------// Convenience methods for storing individual objects//-------------------------------------------------------------------------public void lock(final Object entity, final LockMode lockMode) throws DataAccessException {executeWithNativeSession(new HibernateCallback() {public Object doInHibernate(Session session) throws HibernateException {session.lock(entity, lockMode);return null;}});}public void lock(final String entityName, final Object entity, final LockMode lockMode)throws DataAccessException {executeWithNativeSession(new HibernateCallback() {public Object doInHibernate(Session session) throws HibernateException {session.lock(entityName, entity, lockMode);return null;}});}public Serializable save(final Object entity) throws DataAccessException {return (Serializable) executeWithNativeSession(new HibernateCallback() {public Object doInHibernate(Session session) throws HibernateException {checkWriteOperationAllowed(session);return session.save(entity);}});}public Serializable save(final String entityName, final Object entity) throws DataAccessException {return (Serializable) executeWithNativeSession(new HibernateCallback() {public Object doInHibernate(Session session) throws HibernateException {checkWriteOperationAllowed(session);return session.save(entityName, entity);}});}public void update(Object entity) throws DataAccessException {update(entity, null);}public void update(final Object entity, final LockMode lockMode) throws DataAccessException {executeWithNativeSession(new HibernateCallback() {public Object doInHibernate(Session session) throws HibernateException {checkWriteOperationAllowed(session);session.update(entity);if (lockMode != null) {session.lock(entity, lockMode);}return null;}});}public void update(String entityName, Object entity) throws DataAccessException {update(entityName, entity, null);}public void update(final String entityName, final Object entity, final LockMode lockMode)throws DataAccessException {executeWithNativeSession(new HibernateCallback() {public Object doInHibernate(Session session) throws HibernateException {checkWriteOperationAllowed(session);session.update(entityName, entity);if (lockMode != null) {session.lock(entity, lockMode);}return null;}});}public void saveOrUpdate(final Object entity) throws DataAccessException {executeWithNativeSession(new HibernateCallback() {public Object doInHibernate(Session session) throws HibernateException {checkWriteOperationAllowed(session);session.saveOrUpdate(entity);return null;}});}public void saveOrUpdate(final String entityName, final Object entity) throws DataAccessException {executeWithNativeSession(new HibernateCallback() {public Object doInHibernate(Session session) throws HibernateException {checkWriteOperationAllowed(session);session.saveOrUpdate(entityName, entity);return null;}});}public void saveOrUpdateAll(final Collection entities) throws DataAccessException {executeWithNativeSession(new HibernateCallback() {public Object doInHibernate(Session session) throws HibernateException {checkWriteOperationAllowed(session);for (Iterator it = entities.iterator(); it.hasNext();) {session.saveOrUpdate(it.next());}return null;}});}public void replicate(final Object entity, final ReplicationMode replicationMode)throws DataAccessException {executeWithNativeSession(new HibernateCallback() {public Object doInHibernate(Session session) throws HibernateException {checkWriteOperationAllowed(session);session.replicate(entity, replicationMode);return null;}});}public void replicate(final String entityName, final Object entity, final ReplicationMode replicationMode)throws DataAccessException {executeWithNativeSession(new HibernateCallback() {public Object doInHibernate(Session session) throws HibernateException {checkWriteOperationAllowed(session);session.replicate(entityName, entity, replicationMode);return null;}});}public void persist(final Object entity) throws DataAccessException {executeWithNativeSession(new HibernateCallback() {public Object doInHibernate(Session session) throws HibernateException {checkWriteOperationAllowed(session);session.persist(entity);return null;}});}public void persist(final String entityName, final Object entity) throws DataAccessException {executeWithNativeSession(new HibernateCallback() {public Object doInHibernate(Session session) throws HibernateException {checkWriteOperationAllowed(session);session.persist(entityName, entity);return null;}});}public Object merge(final Object entity) throws DataAccessException {return executeWithNativeSession(new HibernateCallback() {public Object doInHibernate(Session session) throws HibernateException {checkWriteOperationAllowed(session);return session.merge(entity);}});}public Object merge(final String entityName, final Object entity) throws DataAccessException {return executeWithNativeSession(new HibernateCallback() {public Object doInHibernate(Session session) throws HibernateException {checkWriteOperationAllowed(session);return session.merge(entityName, entity);}});}public void delete(Object entity) throws DataAccessException {delete(entity, null);}public void delete(final Object entity, final LockMode lockMode) throws DataAccessException {executeWithNativeSession(new HibernateCallback() {public Object doInHibernate(Session session) throws HibernateException {checkWriteOperationAllowed(session);if (lockMode != null) {session.lock(entity, lockMode);}session.delete(entity);return null;}});}public void delete(String entityName, Object entity) throws DataAccessException {delete(entityName, entity, null);}public void delete(final String entityName, final Object entity, final LockMode lockMode)throws DataAccessException {executeWithNativeSession(new HibernateCallback() {public Object doInHibernate(Session session) throws HibernateException {checkWriteOperationAllowed(session);if (lockMode != null) {session.lock(entityName, entity, lockMode);}session.delete(entityName, entity);return null;}});}public void deleteAll(final Collection entities) throws DataAccessException {executeWithNativeSession(new HibernateCallback() {public Object doInHibernate(Session session) throws HibernateException {checkWriteOperationAllowed(session);for (Iterator it = entities.iterator(); it.hasNext();) {session.delete(it.next());}return null;}});}public void flush() throws DataAccessException {executeWithNativeSession(new HibernateCallback() {public Object doInHibernate(Session session) throws HibernateException {session.flush();return null;}});}public void clear() throws DataAccessException {executeWithNativeSession(new HibernateCallback() {public Object doInHibernate(Session session) {session.clear();return null;}});}//-------------------------------------------------------------------------// Convenience finder methods for HQL strings//-------------------------------------------------------------------------public List find(String queryString) throws DataAccessException {return find(queryString, (Object[]) null);}public List find(String queryString, Object value) throws DataAccessException {return find(queryString, new Object[] {value});}public List find(final String queryString, final Object[] values) throws DataAccessException {return (List) executeWithNativeSession(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++) {queryObject.setParameter(i, values[i]);}}return queryObject.list();}});}public List findByNamedParam(String queryString, String paramName, Object value)throws DataAccessException {return findByNamedParam(queryString, new String[] {paramName}, new Object[] {value});}public List findByNamedParam(final String queryString, final String[] paramNames, final Object[] values)throws DataAccessException {if (paramNames.length != values.length) {throw new IllegalArgumentException("Length of paramNames array must match length of values array");}return (List) executeWithNativeSession(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]);}}return queryObject.list();}});}public List findByValueBean(final String queryString, final Object valueBean)throws DataAccessException {return (List) executeWithNativeSession(new HibernateCallback() {public Object doInHibernate(Session session) throws HibernateException {Query queryObject = session.createQuery(queryString);prepareQuery(queryObject);queryObject.setProperties(valueBean);return queryObject.list();}});}//-------------------------------------------------------------------------// Convenience finder methods for named queries//-------------------------------------------------------------------------public List findByNamedQuery(String queryName) throws DataAccessException {return findByNamedQuery(queryName, (Object[]) null);}public List findByNamedQuery(String queryName, Object value) throws DataAccessException {return findByNamedQuery(queryName, new Object[] {value});}public List findByNamedQuery(final String queryName, final Object[] values) throws DataAccessException {return (List) executeWithNativeSession(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++) {queryObject.setParameter(i, values[i]);}}return queryObject.list();}});}public List findByNamedQueryAndNamedParam(String queryName, String paramName, Object value)throws DataAccessException {return findByNamedQueryAndNamedParam(queryName, new String[] {paramName}, new Object[] {value});}public List findByNamedQueryAndNamedParam(final String queryName, final String[] paramNames, final Object[] values)throws DataAccessException {if (paramNames != null && values != null && paramNames.length != values.length) {throw new IllegalArgumentException("Length of paramNames array must match length of values array");}return (List) executeWithNativeSession(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]);}}return queryObject.list();}});}public List findByNamedQueryAndValueBean(final String queryName, final Object valueBean)throws DataAccessException {return (List) executeWithNativeSession(new HibernateCallback() {public Object doInHibernate(Session session) throws HibernateException {Query queryObject = session.getNamedQuery(queryName);prepareQuery(queryObject);queryObject.setProperties(valueBean);return queryObject.list();}});}//-------------------------------------------------------------------------// Convenience finder methods for detached criteria//-------------------------------------------------------------------------public List findByCriteria(DetachedCriteria criteria) throws DataAccessException {return findByCriteria(criteria, -1, -1);}public List findByCriteria(final DetachedCriteria criteria, final int firstResult, final int maxResults)throws DataAccessException {Assert.notNull(criteria, "DetachedCriteria must not be null");return (List) executeWithNativeSession(new HibernateCallback() {public Object doInHibernate(Session session) throws HibernateException {Criteria executableCriteria = criteria.getExecutableCriteria(session);prepareCriteria(executableCriteria);if (firstResult >= 0) {executableCriteria.setFirstResult(firstResult);}if (maxResults > 0) {executableCriteria.setMaxResults(maxResults);}return executableCriteria.list();}});}public List findByExample(Object exampleEntity) throws DataAccessException {return findByExample(null, exampleEntity, -1, -1);}public List findByExample(String entityName, Object exampleEntity) throws DataAccessException {return findByExample(entityName, exampleEntity, -1, -1);}public List findByExample(Object exampleEntity, int firstResult, int maxResults) throws DataAccessException {return findByExample(null, exampleEntity, firstResult, maxResults);}public List findByExample(final String entityName, final Object exampleEntity, final int firstResult, final int maxResults)throws DataAccessException {Assert.notNull(exampleEntity, "Example entity must not be null");return (List) executeWithNativeSession(new HibernateCallback() {public Object doInHibernate(Session session) throws HibernateException {Criteria executableCriteria = (entityName != null ?session.createCriteria(entityName) : session.createCriteria(exampleEntity.getClass()));executableCriteria.add(Example.create(exampleEntity));prepareCriteria(executableCriteria);if (firstResult >= 0) {executableCriteria.setFirstResult(firstResult);}if (maxResults > 0) {executableCriteria.setMaxResults(maxResults);}return executableCriteria.list();}});}//-------------------------------------------------------------------------// Convenience query methods for iteration and bulk updates/deletes//-------------------------------------------------------------------------public Iterator iterate(String queryString) throws DataAccessException {return iterate(queryString, (Object[]) null);}public Iterator iterate(String queryString, Object value) throws DataAccessException {return iterate(queryString, new Object[] {value});}public Iterator iterate(final String queryString, final Object[] values) throws DataAccessException {return (Iterator) executeWithNativeSession(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++) {queryObject.setParameter(i, values[i]);}}return queryObject.iterate();}});}public void closeIterator(Iterator it) throws DataAccessException {try {Hibernate.close(it);}catch (HibernateException ex) {throw SessionFactoryUtils.convertHibernateAccessException(ex);}}public int bulkUpdate(String queryString) throws DataAccessException {return bulkUpdate(queryString, (Object[]) null);}public int bulkUpdate(String queryString, Object value) throws DataAccessException {return bulkUpdate(queryString, new Object[] {value});}public int bulkUpdate(final String queryString, final Object[] values) throws DataAccessException {Integer updateCount = (Integer) executeWithNativeSession(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++) {queryObject.setParameter(i, values[i]);}}return new Integer(queryObject.executeUpdate());}});return updateCount.intValue();}//-------------------------------------------------------------------------// Helper methods used by the operations above//-------------------------------------------------------------------------/** * Check whether write operations are allowed on the given Session. * <p>Default implementation throws an InvalidDataAccessApiUsageException in * case of <code>FlushMode.NEVER/MANUAL. Can be overridden in subclasses. * @param session current Hibernate Session * @throws InvalidDataAccessApiUsageException if write operations are not allowed * @see #setCheckWriteOperations * @see #getFlushMode() * @see #FLUSH_EAGER * @see org.hibernate.Session#getFlushMode() * @see org.hibernate.FlushMode#NEVER * @see org.hibernate.FlushMode#MANUAL */protected void checkWriteOperationAllowed(Session session) throws InvalidDataAccessApiUsageException {if (isCheckWriteOperations() && getFlushMode() != FLUSH_EAGER &&session.getFlushMode().lessThan(FlushMode.COMMIT)) {throw new InvalidDataAccessApiUsageException("Write operations are not allowed in read-only mode (FlushMode.NEVER/MANUAL): "+"Turn your Session into FlushMode.COMMIT/AUTO or remove 'readOnly' marker from transaction definition.");}}/** * Prepare the given Query object, applying cache settings and/or * a transaction timeout. * @param queryObject the Query object to prepare * @see #setCacheQueries * @see #setQueryCacheRegion * @see SessionFactoryUtils#applyTransactionTimeout */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());}/** * Prepare the given Criteria object, applying cache settings and/or * a transaction timeout. * @param criteria the Criteria object to prepare * @see #setCacheQueries * @see #setQueryCacheRegion * @see SessionFactoryUtils#applyTransactionTimeout */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());}/** * Apply the given name parameter to the given Query object. * @param queryObject the Query object * @param paramName the name of the parameter * @param value the value of the parameter * @throws HibernateException if thrown by the Query object */protected void applyNamedParameterToQuery(Query queryObject, String paramName, Object value)throws HibernateException {if (value instanceof Collection) {queryObject.setParameterList(paramName, (Collection) value);}else if (value instanceof Object[]) {queryObject.setParameterList(paramName, (Object[]) value);}else {queryObject.setParameter(paramName, value);}}/** * Invocation handler that suppresses close calls on Hibernate Sessions. * Also prepares returned Query and Criteria objects. * @see org.hibernate.Session#close */private class CloseSuppressingInvocationHandler implements InvocationHandler {private final Session target;public CloseSuppressingInvocationHandler(Session target) {this.target = target;}public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {// Invocation on Session interface coming in...if (method.getName().equals("equals")) {// Only consider equal when proxies are identical.return (proxy == args[0] ? Boolean.TRUE : Boolean.FALSE);}else if (method.getName().equals("hashCode")) {// Use hashCode of Session proxy.return new Integer(hashCode());}else if (method.getName().equals("close")) {// Handle close method: suppress, not valid.return null;}// Invoke method on target Session.try {Object retVal = method.invoke(this.target, args);// If return value is a Query or Criteria, apply transaction timeout.// Applies to createQuery, getNamedQuery, createCriteria.if (retVal instanceof Query) {prepareQuery(((Query) retVal));}if (retVal instanceof Criteria) {prepareCriteria(((Criteria) retVal));}return retVal;}catch (InvocationTargetException ex) {throw ex.getTargetException();}}}}