Introduced HibernateTemplate for Hibernate 4 as a migration helper

Note that this variant of HibernateTemplate is stripped down in terms of Session management options and just provides a current-session style with a fallback to a temporary session-per-operation.  Furthermore, in the latter fallback mode, only read operations are supported, just like with a JPA EntityManager.

Issue: SPR-11291

spring-orm-hibernate4/src/main/java/org/springframework/orm/hibernate4/HibernateCallback.java

@@ -0,0 +1,52 @@
+/*
+ * Copyright 2002-2014 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.hibernate4;
+
+import org.hibernate.HibernateException;
+import org.hibernate.Session;
+
+/**
+ * Callback interface for Hibernate code. To be used with {@link HibernateTemplate}'s
+ * execution methods, often as anonymous classes within a method implementation.
+ * A typical implementation will call {@code Session.load/find/update} to perform
+ * some operations on persistent objects.
+ *
+ * @author Juergen Hoeller
+ * @since 4.0.1
+ * @see HibernateTemplate
+ * @see HibernateTransactionManager
+ */
+public interface HibernateCallback<T> {
+
+	/**
+	 * Gets called by {@code HibernateTemplate.execute} with an active
+	 * Hibernate {@code Session}. Does not need to care about activating
+	 * or closing the {@code Session}, or handling transactions.
+	 *
+	 * <p>Allows for returning a result object created within the callback,
+	 * i.e. a domain object or a collection of domain objects.
+	 * A thrown custom RuntimeException is treated as an application exception:
+	 * It gets propagated to the caller of the template.
+	 *
+	 * @param session active Hibernate session
+	 * @return a result object, or {@code null} if none
+	 * @throws HibernateException if thrown by the Hibernate API
+	 * @see HibernateTemplate#execute
+	 */
+	T doInHibernate(Session session) throws HibernateException;
+
+}

spring-orm-hibernate4/src/main/java/org/springframework/orm/hibernate4/HibernateOperations.java

@@ -0,0 +1,798 @@
+/*
+ * Copyright 2002-2014 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.hibernate4;
+
+import java.io.Serializable;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+
+import org.hibernate.Filter;
+import org.hibernate.LockMode;
+import org.hibernate.ReplicationMode;
+import org.hibernate.criterion.DetachedCriteria;
+
+import org.springframework.dao.DataAccessException;
+
+/**
+ * Interface that specifies a basic set of Hibernate operations,
+ * implemented by {@link HibernateTemplate}. Not often used, but a useful
+ * option to enhance testability, as it can easily be mocked or stubbed.
+ *
+ * <p>Defines {@code HibernateTemplate}'s data access methods that
+ * mirror various {@link org.hibernate.Session} methods. Users are
+ * strongly encouraged to read the Hibernate {@code Session} javadocs
+ * for details on the semantics of those methods.
+ *
+ * @author Juergen Hoeller
+ * @since 4.0.1
+ * @see HibernateTemplate
+ * @see org.hibernate.Session
+ * @see HibernateTransactionManager
+ */
+public interface HibernateOperations {
+
+	/**
+	 * Execute the action specified by the given action object within a
+	 * {@link org.hibernate.Session}.
+	 * <p>Application exceptions thrown by the action object get propagated
+	 * to the caller (can only be unchecked). Hibernate exceptions are
+	 * transformed into appropriate DAO ones. Allows for returning a result
+	 * object, that is a domain object or a collection of domain objects.
+	 * <p>Note: Callback code is not supposed to handle transactions itself!
+	 * Use an appropriate transaction manager like
+	 * {@link HibernateTransactionManager}. Generally, callback code must not
+	 * touch any {@code Session} lifecycle methods, like close,
+	 * disconnect, or reconnect, to let the template do its work.
+	 * @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
+	 * @see HibernateTransactionManager
+	 * @see org.hibernate.Session
+	 */
+	<T> T execute(HibernateCallback<T> action) throws DataAccessException;
+
+
+	//-------------------------------------------------------------------------
+	// Convenience methods for loading individual objects
+	//-------------------------------------------------------------------------
+
+	/**
+	 * Return the persistent instance of the given entity class
+	 * with the given identifier, or {@code null} if not found.
+	 * <p>This method is a thin wrapper around
+	 * {@link org.hibernate.Session#get(Class, java.io.Serializable)} for convenience.
+	 * For an explanation of the exact semantics of this method, please do refer to
+	 * the Hibernate API documentation in the first instance.
+	 * @param entityClass a persistent class
+	 * @param id the identifier of the persistent instance
+	 * @return the persistent instance, or {@code null} if not found
+	 * @throws org.springframework.dao.DataAccessException in case of Hibernate errors
+	 * @see org.hibernate.Session#get(Class, java.io.Serializable)
+	 */
+	<T> T get(Class<T> entityClass, Serializable id) throws DataAccessException;
+
+	/**
+	 * Return the persistent instance of the given entity class
+	 * with the given identifier, or {@code null} if not found.
+	 * <p>Obtains the specified lock mode if the instance exists.
+	 * <p>This method is a thin wrapper around
+	 * {@link org.hibernate.Session#get(Class, java.io.Serializable, LockMode)} for convenience.
+	 * For an explanation of the exact semantics of this method, please do refer to
+	 * the Hibernate API documentation in the first instance.
+	 * @param entityClass a persistent class
+	 * @param id the identifier of the persistent instance
+	 * @param lockMode the lock mode to obtain
+	 * @return the persistent instance, or {@code null} if not found
+	 * @throws org.springframework.dao.DataAccessException in case of Hibernate errors
+	 * @see org.hibernate.Session#get(Class, java.io.Serializable, org.hibernate.LockMode)
+	 */
+	<T> T get(Class<T> entityClass, Serializable id, LockMode lockMode) throws DataAccessException;
+
+	/**
+	 * Return the persistent instance of the given entity class
+	 * with the given identifier, or {@code null} if not found.
+	 * <p>This method is a thin wrapper around
+	 * {@link org.hibernate.Session#get(String, java.io.Serializable)} for convenience.
+	 * For an explanation of the exact semantics of this method, please do refer to
+	 * the Hibernate API documentation in the first instance.
+	 * @param entityName the name of the persistent entity
+	 * @param id the identifier of the persistent instance
+	 * @return the persistent instance, or {@code null} if not found
+	 * @throws org.springframework.dao.DataAccessException in case of Hibernate errors
+	 * @see org.hibernate.Session#get(Class, java.io.Serializable)
+	 */
+	Object get(String entityName, Serializable id) throws DataAccessException;
+
+	/**
+	 * Return the persistent instance of the given entity class
+	 * with the given identifier, or {@code null} if not found.
+	 * Obtains the specified lock mode if the instance exists.
+	 * <p>This method is a thin wrapper around
+	 * {@link org.hibernate.Session#get(String, java.io.Serializable, LockMode)} for convenience.
+	 * For an explanation of the exact semantics of this method, please do refer to
+	 * the Hibernate API documentation in the first instance.
+	 * @param entityName the name of the persistent entity
+	 * @param id the identifier of the persistent instance
+	 * @param lockMode the lock mode to obtain
+	 * @return the persistent instance, or {@code null} if not found
+	 * @throws org.springframework.dao.DataAccessException in case of Hibernate errors
+	 * @see org.hibernate.Session#get(Class, java.io.Serializable, org.hibernate.LockMode)
+	 */
+	Object get(String entityName, Serializable id, LockMode lockMode) throws DataAccessException;
+
+	/**
+	 * Return the persistent instance of the given entity class
+	 * with the given identifier, throwing an exception if not found.
+	 * <p>This method is a thin wrapper around
+	 * {@link org.hibernate.Session#load(Class, java.io.Serializable)} for convenience.
+	 * For an explanation of the exact semantics of this method, please do refer to
+	 * the Hibernate API documentation in the first instance.
+	 * @param entityClass a persistent class
+	 * @param id the identifier of the persistent instance
+	 * @return the persistent instance
+	 * @throws org.springframework.orm.ObjectRetrievalFailureException if not found
+	 * @throws org.springframework.dao.DataAccessException in case of Hibernate errors
+	 * @see org.hibernate.Session#load(Class, java.io.Serializable)
+	 */
+	<T> T load(Class<T> entityClass, Serializable id) throws DataAccessException;
+
+	/**
+	 * Return the persistent instance of the given entity class
+	 * with the given identifier, throwing an exception if not found.
+	 * Obtains the specified lock mode if the instance exists.
+	 * <p>This method is a thin wrapper around
+	 * {@link org.hibernate.Session#load(Class, java.io.Serializable, LockMode)} for convenience.
+	 * For an explanation of the exact semantics of this method, please do refer to
+	 * the Hibernate API documentation in the first instance.
+	 * @param entityClass a persistent class
+	 * @param id the identifier of the persistent instance
+	 * @param lockMode the lock mode to obtain
+	 * @return the persistent instance
+	 * @throws org.springframework.orm.ObjectRetrievalFailureException if not found
+	 * @throws org.springframework.dao.DataAccessException in case of Hibernate errors
+	 * @see org.hibernate.Session#load(Class, java.io.Serializable)
+	 */
+	<T> T load(Class<T> entityClass, Serializable id, LockMode lockMode) throws DataAccessException;
+
+	/**
+	 * Return the persistent instance of the given entity class
+	 * with the given identifier, throwing an exception if not found.
+	 * <p>This method is a thin wrapper around
+	 * {@link org.hibernate.Session#load(String, java.io.Serializable)} for convenience.
+	 * For an explanation of the exact semantics of this method, please do refer to
+	 * the Hibernate API documentation in the first instance.
+	 * @param entityName the name of the persistent entity
+	 * @param id the identifier of the persistent instance
+	 * @return the persistent instance
+	 * @throws org.springframework.orm.ObjectRetrievalFailureException if not found
+	 * @throws org.springframework.dao.DataAccessException in case of Hibernate errors
+	 * @see org.hibernate.Session#load(Class, java.io.Serializable)
+	 */
+	Object load(String entityName, Serializable id) throws DataAccessException;
+
+	/**
+	 * Return the persistent instance of the given entity class
+	 * with the given identifier, throwing an exception if not found.
+	 * <p>Obtains the specified lock mode if the instance exists.
+	 * <p>This method is a thin wrapper around
+	 * {@link org.hibernate.Session#load(String, java.io.Serializable, LockMode)} for convenience.
+	 * For an explanation of the exact semantics of this method, please do refer to
+	 * the Hibernate API documentation in the first instance.
+	 * @param entityName the name of the persistent entity
+	 * @param id the identifier of the persistent instance
+	 * @param lockMode the lock mode to obtain
+	 * @return the persistent instance
+	 * @throws org.springframework.orm.ObjectRetrievalFailureException if not found
+	 * @throws org.springframework.dao.DataAccessException in case of Hibernate errors
+	 * @see org.hibernate.Session#load(Class, java.io.Serializable)
+	 */
+	Object load(String entityName, Serializable id, LockMode lockMode) throws DataAccessException;
+
+	/**
+	 * Return all persistent instances of the given entity class.
+	 * Note: Use queries or criteria for retrieving a specific subset.
+	 * @param entityClass a persistent class
+	 * @return a {@link List} containing 0 or more persistent instances
+	 * @throws org.springframework.dao.DataAccessException if there is a Hibernate error
+	 * @see org.hibernate.Session#createCriteria
+	 */
+	<T> List<T> loadAll(Class<T> entityClass) throws DataAccessException;
+
+	/**
+	 * Load the persistent instance with the given identifier
+	 * into the given object, throwing an exception if not found.
+	 * <p>This method is a thin wrapper around
+	 * {@link org.hibernate.Session#load(Object, java.io.Serializable)} for convenience.
+	 * For an explanation of the exact semantics of this method, please do refer to
+	 * the Hibernate API documentation in the first instance.
+	 * @param entity the object (of the target class) to load into
+	 * @param id the identifier of the persistent instance
+	 * @throws org.springframework.orm.ObjectRetrievalFailureException if not found
+	 * @throws org.springframework.dao.DataAccessException in case of Hibernate errors
+	 * @see org.hibernate.Session#load(Object, java.io.Serializable)
+	 */
+	void load(Object entity, Serializable id) throws DataAccessException;
+
+	/**
+	 * Re-read the state of the given persistent instance.
+	 * @param entity the persistent instance to re-read
+	 * @throws org.springframework.dao.DataAccessException in case of Hibernate errors
+	 * @see org.hibernate.Session#refresh(Object)
+	 */
+	void refresh(Object entity) throws DataAccessException;
+
+	/**
+	 * Re-read the state of the given persistent instance.
+	 * Obtains the specified lock mode for the instance.
+	 * @param entity the persistent instance to re-read
+	 * @param lockMode the lock mode to obtain
+	 * @throws org.springframework.dao.DataAccessException in case of Hibernate errors
+	 * @see org.hibernate.Session#refresh(Object, org.hibernate.LockMode)
+	 */
+	void refresh(Object entity, LockMode lockMode) throws DataAccessException;
+
+	/**
+	 * Check whether the given object is in the Session cache.
+	 * @param entity the persistence instance to check
+	 * @return whether the given object is in the Session cache
+	 * @throws org.springframework.dao.DataAccessException if there is a Hibernate error
+	 * @see org.hibernate.Session#contains
+	 */
+	boolean contains(Object entity) throws DataAccessException;
+
+	/**
+	 * Remove the given object from the {@link org.hibernate.Session} cache.
+	 * @param entity the persistent instance to evict
+	 * @throws org.springframework.dao.DataAccessException in case of Hibernate errors
+	 * @see org.hibernate.Session#evict
+	 */
+	void evict(Object entity) throws DataAccessException;
+
+	/**
+	 * Force initialization of a Hibernate proxy or persistent collection.
+	 * @param proxy a proxy for a persistent object or a persistent collection
+	 * @throws DataAccessException if we can't initialize the proxy, for example
+	 * because it is not associated with an active Session
+	 * @see org.hibernate.Hibernate#initialize
+	 */
+	void initialize(Object proxy) throws DataAccessException;
+
+	/**
+	 * Return an enabled Hibernate {@link Filter} for the given filter name.
+	 * The returned {@code Filter} instance can be used to set filter parameters.
+	 * @param filterName the name of the filter
+	 * @return the enabled Hibernate {@code Filter} (either already
+	 * enabled or enabled on the fly by this operation)
+	 * @throws IllegalStateException if we are not running within a
+	 * transactional Session (in which case this operation does not make sense)
+	 */
+	Filter enableFilter(String filterName) throws IllegalStateException;
+
+
+	//-------------------------------------------------------------------------
+	// Convenience methods for storing individual objects
+	//-------------------------------------------------------------------------
+
+	/**
+	 * Obtain the specified lock level upon the given object, implicitly
+	 * checking whether the corresponding database entry still exists.
+	 * @param entity the persistent instance to lock
+	 * @param lockMode the lock mode to obtain
+	 * @throws org.springframework.orm.ObjectOptimisticLockingFailureException if not found
+	 * @throws org.springframework.dao.DataAccessException in case of Hibernate errors
+	 * @see org.hibernate.Session#lock(Object, org.hibernate.LockMode)
+	 */
+	void lock(Object entity, LockMode lockMode) throws DataAccessException;
+
+	/**
+	 * Obtain the specified lock level upon the given object, implicitly
+	 * checking whether the corresponding database entry still exists.
+	 * @param entityName the name of the persistent entity
+	 * @param entity the persistent instance to lock
+	 * @param lockMode the lock mode to obtain
+	 * @throws org.springframework.orm.ObjectOptimisticLockingFailureException if not found
+	 * @throws org.springframework.dao.DataAccessException in case of Hibernate errors
+	 * @see org.hibernate.Session#lock(String, Object, org.hibernate.LockMode)
+	 */
+	void lock(String entityName, Object entity, LockMode lockMode) throws DataAccessException;
+
+	/**
+	 * Persist the given transient instance.
+	 * @param entity the transient instance to persist
+	 * @return the generated identifier
+	 * @throws org.springframework.dao.DataAccessException in case of Hibernate errors
+	 * @see org.hibernate.Session#save(Object)
+	 */
+	Serializable save(Object entity) throws DataAccessException;
+
+	/**
+	 * Persist the given transient instance.
+	 * @param entityName the name of the persistent entity
+	 * @param entity the transient instance to persist
+	 * @return the generated identifier
+	 * @throws org.springframework.dao.DataAccessException in case of Hibernate errors
+	 * @see org.hibernate.Session#save(String, Object)
+	 */
+	Serializable save(String entityName, Object entity) throws DataAccessException;
+
+	/**
+	 * Update the given persistent instance,
+	 * associating it with the current Hibernate {@link org.hibernate.Session}.
+	 * @param entity the persistent instance to update
+	 * @throws org.springframework.dao.DataAccessException in case of Hibernate errors
+	 * @see org.hibernate.Session#update(Object)
+	 */
+	void update(Object entity) throws DataAccessException;
+
+	/**
+	 * Update the given persistent instance,
+	 * associating it with the current Hibernate {@link org.hibernate.Session}.
+	 * <p>Obtains the specified lock mode if the instance exists, implicitly
+	 * checking whether the corresponding database entry still exists.
+	 * @param entity the persistent instance to update
+	 * @param lockMode the lock mode to obtain
+	 * @throws org.springframework.orm.ObjectOptimisticLockingFailureException if not found
+	 * @throws org.springframework.dao.DataAccessException in case of Hibernate errors
+	 * @see org.hibernate.Session#update(Object)
+	 */
+	void update(Object entity, LockMode lockMode) throws DataAccessException;
+
+	/**
+	 * Update the given persistent instance,
+	 * associating it with the current Hibernate {@link org.hibernate.Session}.
+	 * @param entityName the name of the persistent entity
+	 * @param entity the persistent instance to update
+	 * @throws org.springframework.dao.DataAccessException in case of Hibernate errors
+	 * @see org.hibernate.Session#update(String, Object)
+	 */
+	void update(String entityName, Object entity) throws DataAccessException;
+
+	/**
+	 * Update the given persistent instance,
+	 * associating it with the current Hibernate {@link org.hibernate.Session}.
+	 * <p>Obtains the specified lock mode if the instance exists, implicitly
+	 * checking whether the corresponding database entry still exists.
+	 * @param entityName the name of the persistent entity
+	 * @param entity the persistent instance to update
+	 * @param lockMode the lock mode to obtain
+	 * @throws org.springframework.orm.ObjectOptimisticLockingFailureException if not found
+	 * @throws org.springframework.dao.DataAccessException in case of Hibernate errors
+	 * @see org.hibernate.Session#update(String, Object)
+	 */
+	void update(String entityName, Object entity, LockMode lockMode) throws DataAccessException;
+
+	/**
+	 * Save or update the given persistent instance,
+	 * according to its id (matching the configured "unsaved-value"?).
+	 * Associates the instance with the current Hibernate {@link org.hibernate.Session}.
+	 * @param entity the persistent instance to save or update
+	 * (to be associated with the Hibernate {@code Session})
+	 * @throws DataAccessException in case of Hibernate errors
+	 * @see org.hibernate.Session#saveOrUpdate(Object)
+	 */
+	void saveOrUpdate(Object entity) throws DataAccessException;
+
+	/**
+	 * Save or update the given persistent instance,
+	 * according to its id (matching the configured "unsaved-value"?).
+	 * Associates the instance with the current Hibernate {@code Session}.
+	 * @param entityName the name of the persistent entity
+	 * @param entity the persistent instance to save or update
+	 * (to be associated with the Hibernate {@code Session})
+	 * @throws DataAccessException in case of Hibernate errors
+	 * @see org.hibernate.Session#saveOrUpdate(String, Object)
+	 */
+	void saveOrUpdate(String entityName, Object entity) throws DataAccessException;
+
+	/**
+	 * Persist the state of the given detached instance according to the
+	 * given replication mode, reusing the current identifier value.
+	 * @param entity the persistent object to replicate
+	 * @param replicationMode the Hibernate ReplicationMode
+	 * @throws DataAccessException in case of Hibernate errors
+	 * @see org.hibernate.Session#replicate(Object, org.hibernate.ReplicationMode)
+	 */
+	void replicate(Object entity, ReplicationMode replicationMode) throws DataAccessException;
+
+	/**
+	 * Persist the state of the given detached instance according to the
+	 * given replication mode, reusing the current identifier value.
+	 * @param entityName the name of the persistent entity
+	 * @param entity the persistent object to replicate
+	 * @param replicationMode the Hibernate ReplicationMode
+	 * @throws DataAccessException in case of Hibernate errors
+	 * @see org.hibernate.Session#replicate(String, Object, org.hibernate.ReplicationMode)
+	 */
+	void replicate(String entityName, Object entity, ReplicationMode replicationMode) throws DataAccessException;
+
+	/**
+	 * Persist the given transient instance. Follows JSR-220 semantics.
+	 * <p>Similar to {@code save}, associating the given object
+	 * with the current Hibernate {@link org.hibernate.Session}.
+	 * @param entity the persistent instance to persist
+	 * @throws org.springframework.dao.DataAccessException in case of Hibernate errors
+	 * @see org.hibernate.Session#persist(Object)
+	 * @see #save
+	 */
+	void persist(Object entity) throws DataAccessException;
+
+	/**
+	 * Persist the given transient instance. Follows JSR-220 semantics.
+	 * <p>Similar to {@code save}, associating the given object
+	 * with the current Hibernate {@link org.hibernate.Session}.
+	 * @param entityName the name of the persistent entity
+	 * @param entity the persistent instance to persist
+	 * @throws org.springframework.dao.DataAccessException in case of Hibernate errors
+	 * @see org.hibernate.Session#persist(String, Object)
+	 * @see #save
+	 */
+	void persist(String entityName, Object entity) throws DataAccessException;
+
+	/**
+	 * Copy the state of the given object onto the persistent object
+	 * with the same identifier. Follows JSR-220 semantics.
+	 * <p>Similar to {@code saveOrUpdate}, but never associates the given
+	 * object with the current Hibernate Session. In case of a new entity,
+	 * the state will be copied over as well.
+	 * <p>Note that {@code merge} will <i>not</i> update the identifiers
+	 * in the passed-in object graph (in contrast to TopLink)! Consider
+	 * registering Spring's {@code IdTransferringMergeEventListener} if
+	 * you would like to have newly assigned ids transferred to the original
+	 * object graph too.
+	 * @param entity the object to merge with the corresponding persistence instance
+	 * @return the updated, registered persistent instance
+	 * @throws org.springframework.dao.DataAccessException in case of Hibernate errors
+	 * @see org.hibernate.Session#merge(Object)
+	 * @see #saveOrUpdate
+	 */
+	<T> T merge(T entity) throws DataAccessException;
+
+	/**
+	 * Copy the state of the given object onto the persistent object
+	 * with the same identifier. Follows JSR-220 semantics.
+	 * <p>Similar to {@code saveOrUpdate}, but never associates the given
+	 * object with the current Hibernate {@link org.hibernate.Session}. In
+	 * the case of a new entity, the state will be copied over as well.
+	 * <p>Note that {@code merge} will <i>not</i> update the identifiers
+	 * in the passed-in object graph (in contrast to TopLink)! Consider
+	 * registering Spring's {@code IdTransferringMergeEventListener}
+	 * if you would like to have newly assigned ids transferred to the
+	 * original object graph too.
+	 * @param entityName the name of the persistent entity
+	 * @param entity the object to merge with the corresponding persistence instance
+	 * @return the updated, registered persistent instance
+	 * @throws org.springframework.dao.DataAccessException in case of Hibernate errors
+	 * @see org.hibernate.Session#merge(String, Object)
+	 * @see #saveOrUpdate
+	 */
+	<T> T merge(String entityName, T entity) throws DataAccessException;
+
+	/**
+	 * Delete the given persistent instance.
+	 * @param entity the persistent instance to delete
+	 * @throws org.springframework.dao.DataAccessException in case of Hibernate errors
+	 * @see org.hibernate.Session#delete(Object)
+	 */
+	void delete(Object entity) throws DataAccessException;
+
+	/**
+	 * Delete the given persistent instance.
+	 * <p>Obtains the specified lock mode if the instance exists, implicitly
+	 * checking whether the corresponding database entry still exists.
+	 * @param entity the persistent instance to delete
+	 * @param lockMode the lock mode to obtain
+	 * @throws org.springframework.orm.ObjectOptimisticLockingFailureException if not found
+	 * @throws org.springframework.dao.DataAccessException in case of Hibernate errors
+	 * @see org.hibernate.Session#delete(Object)
+	 */
+	void delete(Object entity, LockMode lockMode) throws DataAccessException;
+
+	/**
+	 * Delete the given persistent instance.
+	 * @param entityName the name of the persistent entity
+	 * @param entity the persistent instance to delete
+	 * @throws org.springframework.dao.DataAccessException in case of Hibernate errors
+	 * @see org.hibernate.Session#delete(Object)
+	 */
+	void delete(String entityName, Object entity) throws DataAccessException;
+
+	/**
+	 * Delete the given persistent instance.
+	 * <p>Obtains the specified lock mode if the instance exists, implicitly
+	 * checking whether the corresponding database entry still exists.
+	 * @param entityName the name of the persistent entity
+	 * @param entity the persistent instance to delete
+	 * @param lockMode the lock mode to obtain
+	 * @throws org.springframework.orm.ObjectOptimisticLockingFailureException if not found
+	 * @throws org.springframework.dao.DataAccessException in case of Hibernate errors
+	 * @see org.hibernate.Session#delete(Object)
+	 */
+	void delete(String entityName, Object entity, LockMode lockMode) throws DataAccessException;
+
+	/**
+	 * Delete all given persistent instances.
+	 * <p>This can be combined with any of the find methods to delete by query
+	 * in two lines of code.
+	 * @param entities the persistent instances to delete
+	 * @throws org.springframework.dao.DataAccessException in case of Hibernate errors
+	 * @see org.hibernate.Session#delete(Object)
+	 */
+	void deleteAll(Collection<?> entities) throws DataAccessException;
+
+	/**
+	 * Flush all pending saves, updates and deletes to the database.
+	 * <p>Only invoke this for selective eager flushing, for example when
+	 * JDBC code needs to see certain changes within the same transaction.
+	 * Else, it is preferable to rely on auto-flushing at transaction
+	 * completion.
+	 * @throws org.springframework.dao.DataAccessException in case of Hibernate errors
+	 * @see org.hibernate.Session#flush
+	 */
+	void flush() throws DataAccessException;
+
+	/**
+	 * Remove all objects from the {@link org.hibernate.Session} cache, and
+	 * cancel all pending saves, updates and deletes.
+	 * @throws org.springframework.dao.DataAccessException in case of Hibernate errors
+	 * @see org.hibernate.Session#clear
+	 */
+	void clear() throws DataAccessException;
+
+
+	//-------------------------------------------------------------------------
+	// Convenience finder methods for HQL strings
+	//-------------------------------------------------------------------------
+
+	/**
+	 * Execute an HQL query, binding a number of values to "?" parameters
+	 * in the query string.
+	 * @param queryString a query expressed in Hibernate's query language
+	 * @param values the values of the parameters
+	 * @return a {@link List} containing the results of the query execution
+	 * @throws org.springframework.dao.DataAccessException in case of Hibernate errors
+	 * @see org.hibernate.Session#createQuery
+	 */
+	List<Object> find(String queryString, Object... values) throws DataAccessException;
+
+	/**
+	 * Execute an HQL query, binding one value to a ":" named parameter
+	 * in the query string.
+	 * @param queryString a query expressed in Hibernate's query language
+	 * @param paramName the name of the parameter
+	 * @param value the value of the parameter
+	 * @return a {@link List} containing the results of the query execution
+	 * @throws org.springframework.dao.DataAccessException in case of Hibernate errors
+	 * @see org.hibernate.Session#getNamedQuery(String)
+	 */
+	List<Object> findByNamedParam(String queryString, String paramName, Object value)
+			throws DataAccessException;
+
+	/**
+	 * Execute an HQL query, binding a number of values to ":" named
+	 * parameters in the query string.
+	 * @param queryString a query expressed in Hibernate's query language
+	 * @param paramNames the names of the parameters
+	 * @param values the values of the parameters
+	 * @return a {@link List} containing the results of the query execution
+	 * @throws org.springframework.dao.DataAccessException in case of Hibernate errors
+	 * @see org.hibernate.Session#getNamedQuery(String)
+	 */
+	List<Object> findByNamedParam(String queryString, String[] paramNames, Object[] values)
+			throws DataAccessException;
+
+	/**
+	 * Execute an HQL query, binding the properties of the given bean to
+	 * <i>named</i> parameters in the query string.
+	 * @param queryString a query expressed in Hibernate's query language
+	 * @param valueBean the values of the parameters
+	 * @return a {@link List} containing the results of the query execution
+	 * @throws org.springframework.dao.DataAccessException in case of Hibernate errors
+	 * @see org.hibernate.Query#setProperties
+	 * @see org.hibernate.Session#createQuery
+	 */
+	List<Object> findByValueBean(String queryString, Object valueBean) throws DataAccessException;
+
+
+	//-------------------------------------------------------------------------
+	// Convenience finder methods for named queries
+	//-------------------------------------------------------------------------
+
+	/**
+	 * Execute a named query binding a number of values to "?" parameters
+	 * in the query string.
+	 * <p>A named query is defined in a Hibernate mapping file.
+	 * @param queryName the name of a Hibernate query in a mapping file
+	 * @param values the values of the parameters
+	 * @return a {@link List} containing the results of the query execution
+	 * @throws org.springframework.dao.DataAccessException in case of Hibernate errors
+	 * @see org.hibernate.Session#getNamedQuery(String)
+	 */
+	List<Object> findByNamedQuery(String queryName, Object... values) throws DataAccessException;
+
+	/**
+	 * Execute a named query, binding one value to a ":" named parameter
+	 * in the query string.
+	 * <p>A named query is defined in a Hibernate mapping file.
+	 * @param queryName the name of a Hibernate query in a mapping file
+	 * @param paramName the name of parameter
+	 * @param value the value of the parameter
+	 * @return a {@link List} containing the results of the query execution
+	 * @throws org.springframework.dao.DataAccessException in case of Hibernate errors
+	 * @see org.hibernate.Session#getNamedQuery(String)
+	 */
+	List<Object> findByNamedQueryAndNamedParam(String queryName, String paramName, Object value)
+			throws DataAccessException;
+
+	/**
+	 * Execute a named query, binding a number of values to ":" named
+	 * parameters in the query string.
+	 * <p>A named query is defined in a Hibernate mapping file.
+	 * @param queryName the name of a Hibernate query in a mapping file
+	 * @param paramNames the names of the parameters
+	 * @param values the values of the parameters
+	 * @return a {@link List} containing the results of the query execution
+	 * @throws org.springframework.dao.DataAccessException in case of Hibernate errors
+	 * @see org.hibernate.Session#getNamedQuery(String)
+	 */
+	List<Object> findByNamedQueryAndNamedParam(String queryName, String[] paramNames, Object[] values)
+			throws DataAccessException;
+
+	/**
+	 * Execute a named query, binding the properties of the given bean to
+	 * ":" named parameters in the query string.
+	 * <p>A named query is defined in a Hibernate mapping file.
+	 * @param queryName the name of a Hibernate query in a mapping file
+	 * @param valueBean the values of the parameters
+	 * @return a {@link List} containing the results of the query execution
+	 * @throws org.springframework.dao.DataAccessException in case of Hibernate errors
+	 * @see org.hibernate.Query#setProperties
+	 * @see org.hibernate.Session#getNamedQuery(String)
+	 */
+	List<Object> findByNamedQueryAndValueBean(String queryName, Object valueBean)
+			throws DataAccessException;
+
+
+	//-------------------------------------------------------------------------
+	// Convenience finder methods for detached criteria
+	//-------------------------------------------------------------------------
+
+	/**
+	 * Execute a query based on a given Hibernate criteria object.
+	 * @param criteria the detached Hibernate criteria object.
+	 * <b>Note: Do not reuse criteria objects! They need to recreated per execution,
+	 * due to the suboptimal design of Hibernate's criteria facility.</b>
+	 * @return a {@link List} containing 0 or more persistent instances
+	 * @throws org.springframework.dao.DataAccessException in case of Hibernate errors
+	 * @see org.hibernate.criterion.DetachedCriteria#getExecutableCriteria(org.hibernate.Session)
+	 */
+	List<Object> findByCriteria(DetachedCriteria criteria) throws DataAccessException;
+
+	/**
+	 * Execute a query based on the given Hibernate criteria object.
+	 * @param criteria the detached Hibernate criteria object.
+	 * <b>Note: Do not reuse criteria objects! They need to recreated per execution,
+	 * due to the suboptimal design of Hibernate's criteria facility.</b>
+	 * @param firstResult the index of the first result object to be retrieved
+	 * (numbered from 0)
+	 * @param maxResults the maximum number of result objects to retrieve
+	 * (or <=0 for no limit)
+	 * @return a {@link List} containing 0 or more persistent instances
+	 * @throws org.springframework.dao.DataAccessException in case of Hibernate errors
+	 * @see org.hibernate.criterion.DetachedCriteria#getExecutableCriteria(org.hibernate.Session)
+	 * @see org.hibernate.Criteria#setFirstResult(int)
+	 * @see org.hibernate.Criteria#setMaxResults(int)
+	 */
+	List<Object> findByCriteria(DetachedCriteria criteria, int firstResult, int maxResults) throws DataAccessException;
+
+	/**
+	 * Execute a query based on the given example entity object.
+	 * @param exampleEntity an instance of the desired entity,
+	 * serving as example for "query-by-example"
+	 * @return a {@link List} containing 0 or more persistent instances
+	 * @throws org.springframework.dao.DataAccessException in case of Hibernate errors
+	 * @see org.hibernate.criterion.Example#create(Object)
+	 */
+	List<Object> findByExample(Object exampleEntity) throws DataAccessException;
+
+	/**
+	 * Execute a query based on the given example entity object.
+	 * @param entityName the name of the persistent entity
+	 * @param exampleEntity an instance of the desired entity,
+	 * serving as example for "query-by-example"
+	 * @return a {@link List} containing 0 or more persistent instances
+	 * @throws org.springframework.dao.DataAccessException in case of Hibernate errors
+	 * @see org.hibernate.criterion.Example#create(Object)
+	 */
+	List<Object> findByExample(String entityName, Object exampleEntity) throws DataAccessException;
+
+	/**
+	 * Execute a query based on a given example entity object.
+	 * @param exampleEntity an instance of the desired entity,
+	 * serving as example for "query-by-example"
+	 * @param firstResult the index of the first result object to be retrieved
+	 * (numbered from 0)
+	 * @param maxResults the maximum number of result objects to retrieve
+	 * (or <=0 for no limit)
+	 * @return a {@link List} containing 0 or more persistent instances
+	 * @throws org.springframework.dao.DataAccessException in case of Hibernate errors
+	 * @see org.hibernate.criterion.Example#create(Object)
+	 * @see org.hibernate.Criteria#setFirstResult(int)
+	 * @see org.hibernate.Criteria#setMaxResults(int)
+	 */
+	List<Object> findByExample(Object exampleEntity, int firstResult, int maxResults) throws DataAccessException;
+
+	/**
+	 * Execute a query based on a given example entity object.
+	 * @param entityName the name of the persistent entity
+	 * @param exampleEntity an instance of the desired entity,
+	 * serving as example for "query-by-example"
+	 * @param firstResult the index of the first result object to be retrieved
+	 * (numbered from 0)
+	 * @param maxResults the maximum number of result objects to retrieve
+	 * (or <=0 for no limit)
+	 * @return a {@link List} containing 0 or more persistent instances
+	 * @throws org.springframework.dao.DataAccessException in case of Hibernate errors
+	 * @see org.hibernate.criterion.Example#create(Object)
+	 * @see org.hibernate.Criteria#setFirstResult(int)
+	 * @see org.hibernate.Criteria#setMaxResults(int)
+	 */
+	List<Object> findByExample(String entityName, Object exampleEntity, int firstResult, int maxResults)
+			throws DataAccessException;
+
+
+	//-------------------------------------------------------------------------
+	// Convenience query methods for iteration and bulk updates/deletes
+	//-------------------------------------------------------------------------
+
+	/**
+	 * Execute a query for persistent instances, binding a number of
+	 * values to "?" parameters in the query string.
+	 * <p>Returns the results as an {@link Iterator}. Entities returned are
+	 * initialized on demand. See the Hibernate API documentation for details.
+	 * @param queryString a query expressed in Hibernate's query language
+	 * @param values the values of the parameters
+	 * @return an {@link Iterator} containing 0 or more persistent instances
+	 * @throws org.springframework.dao.DataAccessException in case of Hibernate errors
+	 * @see org.hibernate.Session#createQuery
+	 * @see org.hibernate.Query#iterate
+	 */
+	Iterator<Object> iterate(String queryString, Object... values) throws DataAccessException;
+
+	/**
+	 * Immediately close an {@link Iterator} created by any of the various
+	 * {@code iterate(..)} operations, instead of waiting until the
+	 * session is closed or disconnected.
+	 * @param it the {@code Iterator} to close
+	 * @throws DataAccessException if the {@code Iterator} could not be closed
+	 * @see org.hibernate.Hibernate#close
+	 */
+	void closeIterator(Iterator<?> it) throws DataAccessException;
+
+	/**
+	 * Update/delete all objects according to the given query, binding a number of
+	 * values to "?" parameters in the query string.
+	 * @param queryString an update/delete query expressed in Hibernate's query language
+	 * @param values the values of the parameters
+	 * @return the number of instances updated/deleted
+	 * @throws org.springframework.dao.DataAccessException in case of Hibernate errors
+	 * @see org.hibernate.Session#createQuery
+	 * @see org.hibernate.Query#executeUpdate
+	 */
+	int bulkUpdate(String queryString, Object... values) throws DataAccessException;
+
+}

spring-orm-hibernate4/src/main/java/org/springframework/orm/hibernate4/support/HibernateDaoSupport.java

@@ -0,0 +1,132 @@
+/*
+ * Copyright 2002-2014 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.hibernate4.support;
+
+import org.hibernate.Session;
+import org.hibernate.SessionFactory;
+
+import org.springframework.dao.DataAccessResourceFailureException;
+import org.springframework.dao.support.DaoSupport;
+import org.springframework.orm.hibernate4.HibernateTemplate;
+
+/**
+ * Convenient super class for Hibernate-based data access objects.
+ *
+ * <p>Requires a {@link org.hibernate.SessionFactory} to be set, providing a
+ * {@link org.springframework.orm.hibernate4.HibernateTemplate} based on it to
+ * subclasses through the {@link #getHibernateTemplate()} method.
+ * Can alternatively be initialized directly with a HibernateTemplate,
+ * in order to reuse the latter's settings such as the SessionFactory,
+ * exception translator, flush mode, etc.
+ *
+ * <p>This class will create its own HibernateTemplate instance if a SessionFactory
+ * is passed in. The "allowCreate" flag on that HibernateTemplate will be "true"
+ * by default. A custom HibernateTemplate instance can be used through overriding
+ * {@link #createHibernateTemplate}.
+ *
+ * <p><b>NOTE: Hibernate access code can also be coded in plain Hibernate style.
+ * Hence, for newly started projects, consider adopting the standard Hibernate
+ * style of coding data access objects instead, based on
+ * {@link org.hibernate.SessionFactory#getCurrentSession()}.
+ * This HibernateTemplate primarily exists as a migration helper for Hibernate 3
+ * based data access code, to benefit from bug fixes in Hibernate 4.x.</b>
+ *
+ * @author Juergen Hoeller
+ * @since 4.0.1
+ * @see #setSessionFactory
+ * @see #getHibernateTemplate
+ * @see org.springframework.orm.hibernate4.HibernateTemplate
+ */
+public abstract class HibernateDaoSupport extends DaoSupport {
+
+	private HibernateTemplate hibernateTemplate;
+
+
+	/**
+	 * Set the Hibernate SessionFactory to be used by this DAO.
+	 * Will automatically create a HibernateTemplate for the given SessionFactory.
+	 * @see #createHibernateTemplate
+	 * @see #setHibernateTemplate
+	 */
+	public final void setSessionFactory(SessionFactory sessionFactory) {
+		if (this.hibernateTemplate == null || sessionFactory != this.hibernateTemplate.getSessionFactory()) {
+			this.hibernateTemplate = createHibernateTemplate(sessionFactory);
+		}
+	}
+
+	/**
+	 * Create a HibernateTemplate for the given SessionFactory.
+	 * Only invoked if populating the DAO with a SessionFactory reference!
+	 * <p>Can be overridden in subclasses to provide a HibernateTemplate instance
+	 * with different configuration, or a custom HibernateTemplate subclass.
+	 * @param sessionFactory the Hibernate SessionFactory to create a HibernateTemplate for
+	 * @return the new HibernateTemplate instance
+	 * @see #setSessionFactory
+	 */
+	protected HibernateTemplate createHibernateTemplate(SessionFactory sessionFactory) {
+		return new HibernateTemplate(sessionFactory);
+	}
+
+	/**
+	 * Return the Hibernate SessionFactory used by this DAO.
+	 */
+	public final SessionFactory getSessionFactory() {
+		return (this.hibernateTemplate != null ? this.hibernateTemplate.getSessionFactory() : null);
+	}
+
+	/**
+	 * Set the HibernateTemplate for this DAO explicitly,
+	 * as an alternative to specifying a SessionFactory.
+	 * @see #setSessionFactory
+	 */
+	public final void setHibernateTemplate(HibernateTemplate hibernateTemplate) {
+		this.hibernateTemplate = hibernateTemplate;
+	}
+
+	/**
+	 * Return the HibernateTemplate for this DAO,
+	 * pre-initialized with the SessionFactory or set explicitly.
+	 * <p><b>Note: The returned HibernateTemplate is a shared instance.</b>
+	 * You may introspect its configuration, but not modify the configuration
+	 * (other than from within an {@link #initDao} implementation).
+	 * Consider creating a custom HibernateTemplate instance via
+	 * {@code new HibernateTemplate(getSessionFactory())}, in which case
+	 * you're allowed to customize the settings on the resulting instance.
+	 */
+	public final HibernateTemplate getHibernateTemplate() {
+	  return this.hibernateTemplate;
+	}
+
+	@Override
+	protected final void checkDaoConfig() {
+		if (this.hibernateTemplate == null) {
+			throw new IllegalArgumentException("'sessionFactory' or 'hibernateTemplate' is required");
+		}
+	}
+
+
+	/**
+	 * Conveniently obtain the current Hibernate Session.
+	 * @return the Hibernate Session
+	 * @throws DataAccessResourceFailureException if the Session couldn't be created
+	 * @see org.hibernate.SessionFactory#getCurrentSession()
+	 */
+	protected final Session currentSession() throws DataAccessResourceFailureException {
+		return getSessionFactory().getCurrentSession();
+	}
+
+}

spring-orm/src/main/java/org/springframework/orm/hibernate3/HibernateAccessor.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2012 the original author or authors.
+ * Copyright 2002-2014 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.
@@ -289,7 +289,7 @@ public abstract class HibernateAccessor implements InitializingBean, BeanFactory
 	 * @see org.hibernate.Session#enableFilter(String)
 	 * @see LocalSessionFactoryBean#setFilterDefinitions
 	 */
-	public void setFilterNames(String[] filterNames) {
+	public void setFilterNames(String... filterNames) {
 		this.filterNames = filterNames;
 	}
 
@@ -466,8 +466,8 @@ public abstract class HibernateAccessor implements InitializingBean, BeanFactory
 	protected void enableFilters(Session session) {
 		String[] filterNames = getFilterNames();
 		if (filterNames != null) {
-			for (int i = 0; i < filterNames.length; i++) {
-				session.enableFilter(filterNames[i]);
+			for (String filterName : filterNames) {
+				session.enableFilter(filterName);
 			}
 		}
 	}
@@ -481,8 +481,8 @@ public abstract class HibernateAccessor implements InitializingBean, BeanFactory
 	protected void disableFilters(Session session) {
 		String[] filterNames = getFilterNames();
 		if (filterNames != null) {
-			for (int i = 0; i < filterNames.length; i++) {
-				session.disableFilter(filterNames[i]);
+			for (String filterName : filterNames) {
+				session.disableFilter(filterName);
 			}
 		}
 	}

spring-orm/src/main/java/org/springframework/orm/hibernate3/HibernateInterceptor.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2012 the original author or authors.
+ * Copyright 2002-2014 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.
@@ -68,7 +68,12 @@ import org.springframework.transaction.support.TransactionSynchronizationManager
  * @see org.hibernate.SessionFactory#getCurrentSession()
  * @see HibernateTransactionManager
  * @see HibernateTemplate
+ * @deprecated as of Spring 3.2.7, in favor of either HibernateTemplate usage or
+ * native Hibernate API usage within transactions, in combination with a general
+ * {@link org.springframework.dao.annotation.PersistenceExceptionTranslationPostProcessor}.
+ * Note: This class does not have an equivalent replacement in {@code orm.hibernate4}.
  */
+@Deprecated
 public class HibernateInterceptor extends HibernateAccessor implements MethodInterceptor {
 
 	private boolean exceptionConversionEnabled = true;

spring-orm/src/main/java/org/springframework/orm/hibernate3/HibernateOperations.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2013 the original author or authors.
+ * Copyright 2002-2014 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.
@@ -90,10 +90,13 @@ public interface HibernateOperations {
 	 * {@link List}.
 	 * <p>This is a convenience method for executing Hibernate find calls or
 	 * queries within an action.
-	 * @param action calback object that specifies the Hibernate action
+	 * @param action callback object that specifies the Hibernate action
 	 * @return a List result returned by the action, or {@code null}
 	 * @throws org.springframework.dao.DataAccessException in case of Hibernate errors
+	 * @deprecated as of Spring 3.2.7, in favor of using a regular {@link #execute}
+	 * call with a generic List type declared
 	 */
+	@Deprecated
 	List<Object> executeFind(HibernateCallback<?> action) throws DataAccessException;
 
 
@@ -131,8 +134,7 @@ public interface HibernateOperations {
 	 * @throws org.springframework.dao.DataAccessException in case of Hibernate errors
 	 * @see org.hibernate.Session#get(Class, java.io.Serializable, org.hibernate.LockMode)
 	 */
-	<T> T get(Class<T> entityClass, Serializable id, LockMode lockMode)
-			throws DataAccessException;
+	<T> T get(Class<T> entityClass, Serializable id, LockMode lockMode) throws DataAccessException;
 
 	/**
 	 * Return the persistent instance of the given entity class
@@ -164,8 +166,7 @@ public interface HibernateOperations {
 	 * @throws org.springframework.dao.DataAccessException in case of Hibernate errors
 	 * @see org.hibernate.Session#get(Class, java.io.Serializable, org.hibernate.LockMode)
 	 */
-	Object get(String entityName, Serializable id, LockMode lockMode)
-			throws DataAccessException;
+	Object get(String entityName, Serializable id, LockMode lockMode) throws DataAccessException;
 
 	/**
 	 * Return the persistent instance of the given entity class
@@ -199,8 +200,7 @@ public interface HibernateOperations {
 	 * @throws org.springframework.dao.DataAccessException in case of Hibernate errors
 	 * @see org.hibernate.Session#load(Class, java.io.Serializable)
 	 */
-	<T> T load(Class<T> entityClass, Serializable id, LockMode lockMode)
-			throws DataAccessException;
+	<T> T load(Class<T> entityClass, Serializable id, LockMode lockMode) throws DataAccessException;
 
 	/**
 	 * Return the persistent instance of the given entity class
@@ -234,8 +234,7 @@ public interface HibernateOperations {
 	 * @throws org.springframework.dao.DataAccessException in case of Hibernate errors
 	 * @see org.hibernate.Session#load(Class, java.io.Serializable)
 	 */
-	Object load(String entityName, Serializable id, LockMode lockMode)
-			throws DataAccessException;
+	Object load(String entityName, Serializable id, LockMode lockMode) throws DataAccessException;
 
 	/**
 	 * Return all persistent instances of the given entity class.

spring-orm/src/main/java/org/springframework/orm/hibernate3/HibernateTemplate.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2013 the original author or authors.
+ * Copyright 2002-2014 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.
@@ -40,6 +40,7 @@ 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;
@@ -132,7 +133,7 @@ public class HibernateTemplate extends HibernateAccessor implements HibernateOpe
 
 	/**
 	 * Create a new HibernateTemplate instance.
-	 * @param sessionFactory SessionFactory to create Sessions
+	 * @param sessionFactory the SessionFactory to create Sessions with
 	 */
 	public HibernateTemplate(SessionFactory sessionFactory) {
 		setSessionFactory(sessionFactory);
@@ -141,7 +142,7 @@ public class HibernateTemplate extends HibernateAccessor implements HibernateOpe
 
 	/**
 	 * Create a new HibernateTemplate instance.
-	 * @param sessionFactory SessionFactory to create Sessions
+	 * @param sessionFactory the SessionFactory to create Sessions with
 	 * @param allowCreate if a non-transactional Session should be created when no
 	 * transactional Session can be found for the current thread
 	 */
@@ -341,6 +342,7 @@ public class HibernateTemplate extends HibernateAccessor implements HibernateOpe
 	}
 
 	@Override
+	@Deprecated
 	@SuppressWarnings("unchecked")
 	public List<Object> executeFind(HibernateCallback<?> action) throws DataAccessException {
 		Object result = doExecute(action, false, false);
@@ -1077,7 +1079,7 @@ public class HibernateTemplate extends HibernateAccessor implements HibernateOpe
 			final String queryName, final String[] paramNames, final Object[] values)
 			throws DataAccessException {
 
-		if (paramNames != null && values != null && paramNames.length != values.length) {
+		if (values != null && (paramNames == null || paramNames.length != values.length)) {
 			throw new IllegalArgumentException("Length of paramNames array must match length of values array");
 		}
 		return executeWithNativeSession(new HibernateCallback<List<Object>>() {

spring-orm/src/main/java/org/springframework/orm/hibernate3/support/HibernateDaoSupport.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2012 the original author or authors.
+ * Copyright 2002-2014 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.
@@ -46,6 +46,11 @@ import org.springframework.orm.hibernate3.SessionFactoryUtils;
  * by default. A custom HibernateTemplate instance can be used through overriding
  * {@link #createHibernateTemplate}.
  *
+ * <p><b>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>
+ *
  * @author Juergen Hoeller
  * @since 1.2
  * @see #setSessionFactory
@@ -105,8 +110,8 @@ public abstract class HibernateDaoSupport extends DaoSupport {
 	 * You may introspect its configuration, but not modify the configuration
 	 * (other than from within an {@link #initDao} implementation).
 	 * Consider creating a custom HibernateTemplate instance via
-	 * {@code new HibernateTemplate(getSessionFactory())}, in which
-	 * case you're allowed to customize the settings on the resulting instance.
+	 * {@code new HibernateTemplate(getSessionFactory())}, in which case
+	 * you're allowed to customize the settings on the resulting instance.
 	 */
 	public final HibernateTemplate getHibernateTemplate() {
 	  return this.hibernateTemplate;
@@ -136,10 +141,10 @@ public abstract class HibernateDaoSupport extends DaoSupport {
 	 * @throws DataAccessResourceFailureException if the Session couldn't be created
 	 * @throws IllegalStateException if no thread-bound Session found and allowCreate=false
 	 * @see org.springframework.orm.hibernate3.SessionFactoryUtils#getSession(SessionFactory, boolean)
+	 * @deprecated as of Spring 3.2.7, in favor of {@link HibernateTemplate} usage
 	 */
-	protected final Session getSession()
-		throws DataAccessResourceFailureException, IllegalStateException {
-
+	@Deprecated
+	protected final Session getSession() throws DataAccessResourceFailureException, IllegalStateException {
 		return getSession(this.hibernateTemplate.isAllowCreate());
 	}
 
@@ -161,9 +166,11 @@ public abstract class HibernateDaoSupport extends DaoSupport {
 	 * @throws DataAccessResourceFailureException if the Session couldn't be created
 	 * @throws IllegalStateException if no thread-bound Session found and allowCreate=false
 	 * @see org.springframework.orm.hibernate3.SessionFactoryUtils#getSession(SessionFactory, boolean)
+	 * @deprecated as of Spring 3.2.7, in favor of {@link HibernateTemplate} usage
 	 */
+	@Deprecated
 	protected final Session getSession(boolean allowCreate)
-		throws DataAccessResourceFailureException, IllegalStateException {
+			throws DataAccessResourceFailureException, IllegalStateException {
 
 		return (!allowCreate ?
 			SessionFactoryUtils.getSession(getSessionFactory(), false) :
@@ -185,7 +192,9 @@ public abstract class HibernateDaoSupport extends DaoSupport {
 	 * @param ex HibernateException that occurred
 	 * @return the corresponding DataAccessException instance
 	 * @see org.springframework.orm.hibernate3.SessionFactoryUtils#convertHibernateAccessException
+	 * @deprecated as of Spring 3.2.7, in favor of {@link HibernateTemplate} usage
 	 */
+	@Deprecated
 	protected final DataAccessException convertHibernateAccessException(HibernateException ex) {
 		return this.hibernateTemplate.convertHibernateAccessException(ex);
 	}
@@ -197,7 +206,9 @@ public abstract class HibernateDaoSupport extends DaoSupport {
 	 * {@link #getSession} and {@link #convertHibernateAccessException}.
 	 * @param session the Session to close
 	 * @see org.springframework.orm.hibernate3.SessionFactoryUtils#releaseSession
+	 * @deprecated as of Spring 3.2.7, in favor of {@link HibernateTemplate} usage
 	 */
+	@Deprecated
 	protected final void releaseSession(Session session) {
 		SessionFactoryUtils.releaseSession(session, getSessionFactory());
 	}