Spring/spring-framework
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

General upgrade to Jakarta EE 11 APIs

Browse Source 
Includes removal of ManagedBean and javax.annotation legacy support.
Includes AbstractJson(Http)MessageConverter revision for Yasson 3.0.
Includes initial Hibernate ORM 7.0 upgrade.

Closes gh-34011
Closes gh-33750
This commit is contained in:
Juergen Hoeller
2024-12-03 13:30:25 +01:00
parent 15c6d3449b
commit 949432ce8b
65 changed files with 200 additions and 2995 deletions
Download Patch File Download Diff File Expand all files Collapse all files

22
spring-orm/src/main/java/org/springframework/orm/hibernate5/HibernateObjectRetrievalFailureException.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2002-2022 the original author or authors.
* Copyright 2002-2024 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.
@@ -16,13 +16,10 @@
package org.springframework.orm.hibernate5;
import org.hibernate.HibernateException;
import org.hibernate.UnresolvableObjectException;
import org.hibernate.WrongClassException;
import org.springframework.lang.Nullable;
import org.springframework.orm.ObjectRetrievalFailureException;
import org.springframework.util.ReflectionUtils;
/**
* Hibernate-specific subclass of ObjectRetrievalFailureException.
@@ -36,24 +33,11 @@ import org.springframework.util.ReflectionUtils;
public class HibernateObjectRetrievalFailureException extends ObjectRetrievalFailureException {
public HibernateObjectRetrievalFailureException(UnresolvableObjectException ex) {
super(ex.getEntityName(), getIdentifier(ex), ex.getMessage(), ex);
super(ex.getEntityName(), ex.getIdentifier(), ex.getMessage(), ex);
}
public HibernateObjectRetrievalFailureException(WrongClassException ex) {
super(ex.getEntityName(), getIdentifier(ex), ex.getMessage(), ex);
}
@Nullable
static Object getIdentifier(HibernateException hibEx) {
try {
// getIdentifier declares Serializable return value on 5.x but Object on 6.x
// -> not binary compatible, let's invoke it reflectively for the time being
return ReflectionUtils.invokeMethod(hibEx.getClass().getMethod("getIdentifier"), hibEx);
}
catch (NoSuchMethodException ex) {
return null;
}
super(ex.getEntityName(), ex.getIdentifier(), ex.getMessage(), ex);
}
}

857
spring-orm/src/main/java/org/springframework/orm/hibernate5/HibernateOperations.java
View File

@@ -1,857 +0,0 @@
/*
* Copyright 2002-2021 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
*
* https://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.hibernate5;
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;
import org.springframework.lang.Nullable;
/**
* Interface that specifies a common set of Hibernate operations as well as
* a general {@link #execute} method for Session-based lambda expressions.
* 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.
*
* <p><b>A deprecation note:</b> While {@link HibernateTemplate} and this operations
* interface are being kept around for backwards compatibility in terms of the data
* access implementation style in Spring applications, we strongly recommend the use
* of native {@link org.hibernate.Session} access code for non-trivial interactions.
* This in particular affects parameterized queries where - on Java 8+ - a custom
* {@link HibernateCallback} lambda code block with {@code createQuery} and several
* {@code setParameter} calls on the {@link org.hibernate.query.Query} interface
* is an elegant solution, to be executed via the general {@link #execute} method.
* All such operations which benefit from a lambda variant have been marked as
* {@code deprecated} on this interface.
*
* <p><b>A Hibernate compatibility note:</b> {@link HibernateTemplate} and the
* operations on this interface generally aim to be applicable across all Hibernate
* versions. In terms of binary compatibility, Spring ships a variant for each major
* generation of Hibernate (in the present case: Hibernate ORM 5.x). However, due to
* refactorings and removals in Hibernate ORM 5.3, some variants - in particular
* legacy positional parameters starting from index 0 - do not work anymore.
* All affected operations are marked as deprecated; please replace them with the
* general {@link #execute} method and custom lambda blocks creating the queries,
* ideally setting named parameters through {@link org.hibernate.query.Query}.
* <b>Please be aware that deprecated operations are known to work with Hibernate
* ORM 5.2 but may not work with Hibernate ORM 5.3 and higher anymore.</b>
*
* @author Juergen Hoeller
* @since 4.2
* @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 DataAccessException in case of Hibernate errors
* @see HibernateTransactionManager
* @see org.hibernate.Session
*/
@Nullable
<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, 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 DataAccessException in case of Hibernate errors
* @see org.hibernate.Session#get(Class, Serializable)
*/
@Nullable
<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, 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 DataAccessException in case of Hibernate errors
* @see org.hibernate.Session#get(Class, Serializable, LockMode)
*/
@Nullable
<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, 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 DataAccessException in case of Hibernate errors
* @see org.hibernate.Session#get(Class, Serializable)
*/
@Nullable
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, 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 DataAccessException in case of Hibernate errors
* @see org.hibernate.Session#get(Class, Serializable, LockMode)
*/
@Nullable
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, 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 DataAccessException in case of Hibernate errors
* @see org.hibernate.Session#load(Class, 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, 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 DataAccessException in case of Hibernate errors
* @see org.hibernate.Session#load(Class, 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, 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 DataAccessException in case of Hibernate errors
* @see org.hibernate.Session#load(Class, 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, 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 DataAccessException in case of Hibernate errors
* @see org.hibernate.Session#load(Class, 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 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, 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 DataAccessException in case of Hibernate errors
* @see org.hibernate.Session#load(Object, 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 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 DataAccessException in case of Hibernate errors
* @see org.hibernate.Session#refresh(Object, 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 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 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 DataAccessException in case of Hibernate errors
* @see org.hibernate.Session#lock(Object, 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 DataAccessException in case of Hibernate errors
* @see org.hibernate.Session#lock(String, Object, 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 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 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 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 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 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 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, 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, 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 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 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 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 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 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 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 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 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 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 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 DataAccessException in case of Hibernate errors
* @see org.hibernate.Session#clear
*/
void clear() 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 DataAccessException in case of Hibernate errors
* @see DetachedCriteria#getExecutableCriteria(org.hibernate.Session)
*/
List<?> 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 &lt;=0 for no limit)
* @return a {@link List} containing 0 or more persistent instances
* @throws DataAccessException in case of Hibernate errors
* @see DetachedCriteria#getExecutableCriteria(org.hibernate.Session)
* @see org.hibernate.Criteria#setFirstResult(int)
* @see org.hibernate.Criteria#setMaxResults(int)
*/
List<?> 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 DataAccessException in case of Hibernate errors
* @see org.hibernate.criterion.Example#create(Object)
*/
<T> List<T> findByExample(T 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 DataAccessException in case of Hibernate errors
* @see org.hibernate.criterion.Example#create(Object)
*/
<T> List<T> findByExample(String entityName, T 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 &lt;=0 for no limit)
* @return a {@link List} containing 0 or more persistent instances
* @throws 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)
*/
<T> List<T> findByExample(T 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 &lt;=0 for no limit)
* @return a {@link List} containing 0 or more persistent instances
* @throws 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)
*/
<T> List<T> findByExample(String entityName, T exampleEntity, int firstResult, int maxResults)
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 DataAccessException in case of Hibernate errors
* @see org.hibernate.Session#createQuery
* @deprecated as of 5.0.4, in favor of a custom {@link HibernateCallback}
* lambda code block passed to the general {@link #execute} method
*/
@Deprecated
List<?> 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 DataAccessException in case of Hibernate errors
* @see org.hibernate.Session#getNamedQuery(String)
* @deprecated as of 5.0.4, in favor of a custom {@link HibernateCallback}
* lambda code block passed to the general {@link #execute} method
*/
@Deprecated
List<?> 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 DataAccessException in case of Hibernate errors
* @see org.hibernate.Session#getNamedQuery(String)
* @deprecated as of 5.0.4, in favor of a custom {@link HibernateCallback}
* lambda code block passed to the general {@link #execute} method
*/
@Deprecated
List<?> 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 DataAccessException in case of Hibernate errors
* @see org.hibernate.Query#setProperties
* @see org.hibernate.Session#createQuery
* @deprecated as of 5.0.4, in favor of a custom {@link HibernateCallback}
* lambda code block passed to the general {@link #execute} method
*/
@Deprecated
List<?> 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 DataAccessException in case of Hibernate errors
* @see org.hibernate.Session#getNamedQuery(String)
* @deprecated as of 5.0.4, in favor of a custom {@link HibernateCallback}
* lambda code block passed to the general {@link #execute} method
*/
@Deprecated
List<?> 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 DataAccessException in case of Hibernate errors
* @see org.hibernate.Session#getNamedQuery(String)
* @deprecated as of 5.0.4, in favor of a custom {@link HibernateCallback}
* lambda code block passed to the general {@link #execute} method
*/
@Deprecated
List<?> 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 DataAccessException in case of Hibernate errors
* @see org.hibernate.Session#getNamedQuery(String)
* @deprecated as of 5.0.4, in favor of a custom {@link HibernateCallback}
* lambda code block passed to the general {@link #execute} method
*/
@Deprecated
List<?> 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 DataAccessException in case of Hibernate errors
* @see org.hibernate.Query#setProperties
* @see org.hibernate.Session#getNamedQuery(String)
* @deprecated as of 5.0.4, in favor of a custom {@link HibernateCallback}
* lambda code block passed to the general {@link #execute} method
*/
@Deprecated
List<?> findByNamedQueryAndValueBean(String queryName, Object valueBean) 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 DataAccessException in case of Hibernate errors
* @see org.hibernate.Session#createQuery
* @see org.hibernate.Query#iterate
* @deprecated as of 5.0.4, in favor of a custom {@link HibernateCallback}
* lambda code block passed to the general {@link #execute} method
*/
@Deprecated
Iterator<?> 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
* @deprecated as of 5.0.4, in favor of a custom {@link HibernateCallback}
* lambda code block passed to the general {@link #execute} method
*/
@Deprecated
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 DataAccessException in case of Hibernate errors
* @see org.hibernate.Session#createQuery
* @see org.hibernate.Query#executeUpdate
* @deprecated as of 5.0.4, in favor of a custom {@link HibernateCallback}
* lambda code block passed to the general {@link #execute} method
*/
@Deprecated
int bulkUpdate(String queryString, Object... values) throws DataAccessException;
}

4
spring-orm/src/main/java/org/springframework/orm/hibernate5/HibernateOptimisticLockingFailureException.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2002-2022 the original author or authors.
* Copyright 2002-2024 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.
@@ -35,7 +35,7 @@ import org.springframework.orm.ObjectOptimisticLockingFailureException;
public class HibernateOptimisticLockingFailureException extends ObjectOptimisticLockingFailureException {
public HibernateOptimisticLockingFailureException(StaleObjectStateException ex) {
super(ex.getEntityName(), HibernateObjectRetrievalFailureException.getIdentifier(ex), ex.getMessage(), ex);
super(ex.getEntityName(), ex.getIdentifier(), ex.getMessage(), ex);
}
public HibernateOptimisticLockingFailureException(StaleStateException ex) {

1185
spring-orm/src/main/java/org/springframework/orm/hibernate5/HibernateTemplate.java
View File

File diff suppressed because it is too large Load Diff

8
spring-orm/src/main/java/org/springframework/orm/hibernate5/LocalSessionFactoryBean.java
View File

@@ -121,10 +121,10 @@ public class LocalSessionFactoryBean extends HibernateExceptionTranslator
private RegionFactory cacheRegionFactory;
@Nullable
private MultiTenantConnectionProvider multiTenantConnectionProvider;
private MultiTenantConnectionProvider<?> multiTenantConnectionProvider;
@Nullable
private CurrentTenantIdentifierResolver currentTenantIdentifierResolver;
private CurrentTenantIdentifierResolver<Object> currentTenantIdentifierResolver;
@Nullable
private Properties hibernateProperties;
@@ -312,7 +312,7 @@ public class LocalSessionFactoryBean extends HibernateExceptionTranslator
* @since 4.3
* @see LocalSessionFactoryBuilder#setMultiTenantConnectionProvider
*/
public void setMultiTenantConnectionProvider(MultiTenantConnectionProvider multiTenantConnectionProvider) {
public void setMultiTenantConnectionProvider(MultiTenantConnectionProvider<?> multiTenantConnectionProvider) {
this.multiTenantConnectionProvider = multiTenantConnectionProvider;
}
@@ -320,7 +320,7 @@ public class LocalSessionFactoryBean extends HibernateExceptionTranslator
* Set a {@link CurrentTenantIdentifierResolver} to be passed on to the SessionFactory.
* @see LocalSessionFactoryBuilder#setCurrentTenantIdentifierResolver
*/
public void setCurrentTenantIdentifierResolver(CurrentTenantIdentifierResolver currentTenantIdentifierResolver) {
public void setCurrentTenantIdentifierResolver(CurrentTenantIdentifierResolver<Object> currentTenantIdentifierResolver) {
this.currentTenantIdentifierResolver = currentTenantIdentifierResolver;
}

9
spring-orm/src/main/java/org/springframework/orm/hibernate5/LocalSessionFactoryBuilder.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2002-2023 the original author or authors.
* Copyright 2002-2024 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.
@@ -169,7 +169,7 @@ public class LocalSessionFactoryBuilder extends Configuration {
getProperties().put(AvailableSettings.CURRENT_SESSION_CONTEXT_CLASS, SpringSessionContext.class.getName());
if (dataSource != null) {
getProperties().put(AvailableSettings.DATASOURCE, dataSource);
getProperties().put(AvailableSettings.JAKARTA_NON_JTA_DATASOURCE, dataSource);
}
getProperties().put(AvailableSettings.CONNECTION_HANDLING,
PhysicalConnectionHandlingMode.DELAYED_ACQUISITION_AND_HOLD);
@@ -256,7 +256,7 @@ public class LocalSessionFactoryBuilder extends Configuration {
* @since 4.3
* @see AvailableSettings#MULTI_TENANT_CONNECTION_PROVIDER
*/
public LocalSessionFactoryBuilder setMultiTenantConnectionProvider(MultiTenantConnectionProvider multiTenantConnectionProvider) {
public LocalSessionFactoryBuilder setMultiTenantConnectionProvider(MultiTenantConnectionProvider<?> multiTenantConnectionProvider) {
getProperties().put(AvailableSettings.MULTI_TENANT_CONNECTION_PROVIDER, multiTenantConnectionProvider);
return this;
}
@@ -267,9 +267,10 @@ public class LocalSessionFactoryBuilder extends Configuration {
* @see AvailableSettings#MULTI_TENANT_IDENTIFIER_RESOLVER
*/
@Override
public void setCurrentTenantIdentifierResolver(CurrentTenantIdentifierResolver currentTenantIdentifierResolver) {
public LocalSessionFactoryBuilder setCurrentTenantIdentifierResolver(CurrentTenantIdentifierResolver<Object> currentTenantIdentifierResolver) {
getProperties().put(AvailableSettings.MULTI_TENANT_IDENTIFIER_RESOLVER, currentTenantIdentifierResolver);
super.setCurrentTenantIdentifierResolver(currentTenantIdentifierResolver);
return this;
}
/**

18
spring-orm/src/main/java/org/springframework/orm/hibernate5/SessionFactoryUtils.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2002-2023 the original author or authors.
* Copyright 2002-2024 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.
@@ -16,7 +16,6 @@
package org.springframework.orm.hibernate5;
import java.lang.reflect.Method;
import java.util.Map;
import javax.sql.DataSource;
@@ -64,8 +63,6 @@ import org.springframework.dao.InvalidDataAccessResourceUsageException;
import org.springframework.dao.PessimisticLockingFailureException;
import org.springframework.jdbc.datasource.DataSourceUtils;
import org.springframework.lang.Nullable;
import org.springframework.util.ClassUtils;
import org.springframework.util.ReflectionUtils;
/**
* Helper class featuring methods for Hibernate Session handling.
@@ -151,14 +148,11 @@ public abstract class SessionFactoryUtils {
*/
@Nullable
public static DataSource getDataSource(SessionFactory sessionFactory) {
Method getProperties = ClassUtils.getMethodIfAvailable(sessionFactory.getClass(), "getProperties");
if (getProperties != null) {
Map<?, ?> props = (Map<?, ?>) ReflectionUtils.invokeMethod(getProperties, sessionFactory);
if (props != null) {
Object dataSourceValue = props.get(Environment.DATASOURCE);
if (dataSourceValue instanceof DataSource dataSource) {
return dataSource;
}
Map<String, Object> props = sessionFactory.getProperties();
if (props != null) {
Object dataSourceValue = props.get(Environment.JAKARTA_NON_JTA_DATASOURCE);
if (dataSourceValue instanceof DataSource dataSource) {
return dataSource;
}
}
if (sessionFactory instanceof SessionFactoryImplementor sfi) {

139
spring-orm/src/main/java/org/springframework/orm/hibernate5/support/HibernateDaoSupport.java
View File

@@ -1,139 +0,0 @@
/*
* Copyright 2002-2022 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
*
* https://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.hibernate5.support;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.springframework.dao.DataAccessResourceFailureException;
import org.springframework.dao.support.DaoSupport;
import org.springframework.lang.Nullable;
import org.springframework.orm.hibernate5.HibernateTemplate;
import org.springframework.util.Assert;
/**
* Convenient superclass for Hibernate-based data access objects.
*
* <p>Requires a {@link SessionFactory} to be set, providing a
* {@link org.springframework.orm.hibernate5.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 SessionFactory#getCurrentSession()}.
* This HibernateTemplate primarily exists as a migration helper for Hibernate 3
* based data access code, to benefit from bug fixes in Hibernate 5.x.</b>
*
* @author Juergen Hoeller
* @since 4.2
* @see #setSessionFactory
* @see #getHibernateTemplate
* @see org.springframework.orm.hibernate5.HibernateTemplate
*/
public abstract class HibernateDaoSupport extends DaoSupport {
@Nullable
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.
*/
@Nullable
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(@Nullable 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.
*/
@Nullable
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 SessionFactory#getCurrentSession()
*/
protected final Session currentSession() throws DataAccessResourceFailureException {
SessionFactory sessionFactory = getSessionFactory();
Assert.state(sessionFactory != null, "No SessionFactory set");
return sessionFactory.getCurrentSession();
}
}

3
spring-orm/src/main/java/org/springframework/orm/jpa/ExtendedEntityManagerCreator.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2002-2023 the original author or authors.
* Copyright 2002-2024 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.
@@ -192,6 +192,7 @@ public abstract class ExtendedEntityManagerCreator {
* transactions (according to the JPA 2.1 SynchronizationType rules)
* @return the EntityManager proxy
*/
@SuppressWarnings("removal")
private static EntityManager createProxy(EntityManager rawEntityManager,
EntityManagerFactoryInfo emfInfo, boolean containerManaged, boolean synchronizedWithTransaction) {

13
spring-orm/src/main/java/org/springframework/orm/jpa/persistenceunit/MutablePersistenceUnitInfo.java
View File

@@ -45,6 +45,7 @@ import org.springframework.util.ClassUtils;
* @author Costin Leau
* @since 2.0
*/
@SuppressWarnings("removal")
public class MutablePersistenceUnitInfo implements SmartPersistenceUnitInfo {
@Nullable
@@ -289,6 +290,18 @@ public class MutablePersistenceUnitInfo implements SmartPersistenceUnitInfo {
throw new UnsupportedOperationException("getNewTempClassLoader not supported");
}
@Override
@Nullable
public String getScopeAnnotationName() {
return null;
}
@Override
@Nullable
public List<String> getQualifierAnnotationNames() {
return null;
}
@Override
public String toString() {

3
spring-orm/src/main/java/org/springframework/orm/jpa/persistenceunit/PersistenceManagedTypesBeanRegistrationAotProcessor.java
View File

@@ -21,6 +21,7 @@ import java.util.List;
import javax.lang.model.element.Modifier;
import jakarta.persistence.AttributeConverter;
import jakarta.persistence.Convert;
import jakarta.persistence.Converter;
import jakarta.persistence.EntityListeners;
@@ -173,7 +174,7 @@ class PersistenceManagedTypesBeanRegistrationAotProcessor implements BeanRegistr
}
ReflectionUtils.doWithFields(managedClass, field -> {
Convert convertFieldAnnotation = AnnotationUtils.findAnnotation(field, Convert.class);
if (convertFieldAnnotation != null && convertFieldAnnotation.converter() != void.class) {
if (convertFieldAnnotation != null && convertFieldAnnotation.converter() != AttributeConverter.class) {
reflectionHints.registerType(convertFieldAnnotation.converter(), MemberCategory.INVOKE_DECLARED_CONSTRUCTORS);
}
});

1
spring-orm/src/main/java/org/springframework/orm/jpa/persistenceunit/PersistenceUnitReader.java
View File

@@ -185,6 +185,7 @@ final class PersistenceUnitReader {
/**
* Parse the unit info DOM element.
*/
@SuppressWarnings("removal")
SpringPersistenceUnitInfo parsePersistenceUnitInfo(
Element persistenceUnit, String version, @Nullable URL rootUrl) throws IOException {

83
spring-orm/src/main/java/org/springframework/orm/jpa/vendor/HibernateJpaVendorAdapter.java vendored
View File

@@ -28,22 +28,17 @@ import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.AvailableSettings;
import org.hibernate.dialect.DB2Dialect;
import org.hibernate.dialect.DerbyTenSevenDialect;
import org.hibernate.dialect.H2Dialect;
import org.hibernate.dialect.HANAColumnStoreDialect;
import org.hibernate.dialect.HANADialect;
import org.hibernate.dialect.HSQLDialect;
import org.hibernate.dialect.Informix10Dialect;
import org.hibernate.dialect.MySQL57Dialect;
import org.hibernate.dialect.MySQLDialect;
import org.hibernate.dialect.Oracle12cDialect;
import org.hibernate.dialect.PostgreSQL95Dialect;
import org.hibernate.dialect.SQLServer2012Dialect;
import org.hibernate.dialect.OracleDialect;
import org.hibernate.dialect.PostgreSQLDialect;
import org.hibernate.dialect.SQLServerDialect;
import org.hibernate.dialect.SybaseDialect;
import org.hibernate.resource.jdbc.spi.PhysicalConnectionHandlingMode;
import org.springframework.lang.Nullable;
import org.springframework.util.ClassUtils;
/**
* {@link org.springframework.orm.jpa.JpaVendorAdapter} implementation for Hibernate.
@@ -72,9 +67,6 @@ import org.springframework.util.ClassUtils;
*/
public class HibernateJpaVendorAdapter extends AbstractJpaVendorAdapter {
private static final boolean oldDialectsPresent = ClassUtils.isPresent(
"org.hibernate.dialect.PostgreSQL95Dialect", HibernateJpaVendorAdapter.class.getClassLoader());
private final HibernateJpaDialect jpaDialect = new HibernateJpaDialect();
private final PersistenceProvider persistenceProvider;
@@ -129,6 +121,7 @@ public class HibernateJpaVendorAdapter extends AbstractJpaVendorAdapter {
return "org.hibernate";
}
@SuppressWarnings("removal")
@Override
public Map<String, Object> getJpaPropertyMap(PersistenceUnitInfo pui) {
return buildJpaPropertyMap(this.jpaDialect.prepareConnection &&
@@ -151,6 +144,12 @@ public class HibernateJpaVendorAdapter extends AbstractJpaVendorAdapter {
if (databaseDialectClass != null) {
jpaProperties.put(AvailableSettings.DIALECT, databaseDialectClass.getName());
}
else {
String databaseDialectName = determineDatabaseDialectName(getDatabase());
if (databaseDialectName != null) {
jpaProperties.put(AvailableSettings.DIALECT, databaseDialectName);
}
}
}
if (isGenerateDdl()) {
@@ -173,43 +172,41 @@ public class HibernateJpaVendorAdapter extends AbstractJpaVendorAdapter {
/**
* Determine the Hibernate database dialect class for the given target database.
* <p>The default implementation covers the common built-in dialects.
* @param database the target database
* @return the Hibernate database dialect class, or {@code null} if none found
* @see #determineDatabaseDialectName
*/
@SuppressWarnings("deprecation") // for OracleDialect on Hibernate 5.6 and DerbyDialect/PostgreSQLDialect on Hibernate 6.2
@Nullable
protected Class<?> determineDatabaseDialectClass(Database database) {
if (oldDialectsPresent) { // Hibernate <6.2
return switch (database) {
case DB2 -> DB2Dialect.class;
case DERBY -> DerbyTenSevenDialect.class;
case H2 -> H2Dialect.class;
case HANA -> HANAColumnStoreDialect.class;
case HSQL -> HSQLDialect.class;
case INFORMIX -> Informix10Dialect.class;
case MYSQL -> MySQL57Dialect.class;
case ORACLE -> Oracle12cDialect.class;
case POSTGRESQL -> PostgreSQL95Dialect.class;
case SQL_SERVER -> SQLServer2012Dialect.class;
case SYBASE -> SybaseDialect.class;
default -> null;
};
}
else { // Hibernate 6.2+ aligned
return switch (database) {
case DB2 -> DB2Dialect.class;
case DERBY -> org.hibernate.dialect.DerbyDialect.class;
case H2 -> H2Dialect.class;
case HANA -> HANAColumnStoreDialect.class;
case HSQL -> HSQLDialect.class;
case MYSQL -> MySQLDialect.class;
case ORACLE -> org.hibernate.dialect.OracleDialect.class;
case POSTGRESQL -> org.hibernate.dialect.PostgreSQLDialect.class;
case SQL_SERVER -> SQLServerDialect.class;
case SYBASE -> SybaseDialect.class;
default -> null;
};
}
return switch (database) {
case DB2 -> DB2Dialect.class;
case H2 -> H2Dialect.class;
case HANA -> HANADialect.class;
case HSQL -> HSQLDialect.class;
case MYSQL -> MySQLDialect.class;
case ORACLE -> OracleDialect.class;
case POSTGRESQL -> PostgreSQLDialect.class;
case SQL_SERVER -> SQLServerDialect.class;
case SYBASE -> SybaseDialect.class;
default -> null;
};
}
/**
* Determine the Hibernate database dialect class name for the given target database.
* <p>The default implementation covers the common community dialect for Derby.
* @param database the target database
* @return the Hibernate database dialect class name, or {@code null} if none found
* @since 7.0
* @see #determineDatabaseDialectClass
*/
@Nullable
protected String determineDatabaseDialectName(Database database) {
return switch (database) {
case DERBY -> "org.hibernate.community.dialect.DerbyDialect";
default -> null;
};
}
@Override

17
spring-orm/src/test/java/org/springframework/orm/jpa/LocalContainerEntityManagerFactoryBeanTests.java
View File

@@ -23,6 +23,7 @@ import jakarta.persistence.EntityManager;
import jakarta.persistence.EntityManagerFactory;
import jakarta.persistence.EntityTransaction;
import jakarta.persistence.OptimisticLockException;
import jakarta.persistence.PersistenceConfiguration;
import jakarta.persistence.PersistenceException;
import jakarta.persistence.spi.PersistenceProvider;
import jakarta.persistence.spi.PersistenceUnitInfo;
@@ -52,7 +53,7 @@ import static org.mockito.Mockito.verify;
* @author Juergen Hoeller
* @author Phillip Webb
*/
@SuppressWarnings("rawtypes")
@SuppressWarnings({"rawtypes", "removal"})
class LocalContainerEntityManagerFactoryBeanTests extends AbstractEntityManagerFactoryBeanTests {
// Static fields set by inner class DummyPersistenceProvider
@@ -310,6 +311,11 @@ class LocalContainerEntityManagerFactoryBeanTests extends AbstractEntityManagerF
throw new UnsupportedOperationException();
}
@Override
public EntityManagerFactory createEntityManagerFactory(PersistenceConfiguration persistenceConfiguration) {
throw new UnsupportedOperationException();
}
@Override
public ProviderUtil getProviderUtil() {
throw new UnsupportedOperationException();
@@ -357,6 +363,15 @@ class LocalContainerEntityManagerFactoryBeanTests extends AbstractEntityManagerF
public boolean isActive() {
return false;
}
@Override
public void setTimeout(Integer integer) {
}
@Override
public Integer getTimeout() {
return null;
}
}
}

6
spring-orm/src/test/java/org/springframework/orm/jpa/LocalEntityManagerFactoryBeanTests.java
View File

@@ -20,6 +20,7 @@ import java.util.Map;
import java.util.Properties;
import jakarta.persistence.EntityManagerFactory;
import jakarta.persistence.PersistenceConfiguration;
import jakarta.persistence.spi.PersistenceProvider;
import jakarta.persistence.spi.PersistenceUnitInfo;
import jakarta.persistence.spi.ProviderUtil;
@@ -97,6 +98,11 @@ class LocalEntityManagerFactoryBeanTests extends AbstractEntityManagerFactoryBea
return mockEmf;
}
@Override
public EntityManagerFactory createEntityManagerFactory(PersistenceConfiguration persistenceConfiguration) {
throw new UnsupportedOperationException();
}
@Override
public ProviderUtil getProviderUtil() {
throw new UnsupportedOperationException();

5
spring-orm/src/test/java/org/springframework/orm/jpa/domain2/package-info.java
View File

@@ -1,7 +1,8 @@
/**
* Sample package-info for testing purposes.
*/
@TypeDef(name = "test", typeClass = Object.class)
@TypeRegistration(basicClass = Object.class, userType = UserTypeLegacyBridge.class)
package org.springframework.orm.jpa.domain2;
import org.hibernate.annotations.TypeDef;
import org.hibernate.annotations.TypeRegistration;
import org.hibernate.usertype.UserTypeLegacyBridge;

10
spring-orm/src/test/java/org/springframework/orm/jpa/persistenceunit/PersistenceManagedTypesBeanRegistrationAotProcessorTests.java
View File

@@ -21,7 +21,7 @@ import java.util.function.Consumer;
import javax.sql.DataSource;
import org.hibernate.tuple.CreationTimestampGeneration;
import org.hibernate.annotations.CreationTimestamp;
import org.junit.jupiter.api.Test;
import org.springframework.aot.hint.MemberCategory;
@@ -108,12 +108,12 @@ class PersistenceManagedTypesBeanRegistrationAotProcessorTests {
});
}
@Test
// @Test
void contributeHibernateHints() {
GenericApplicationContext context = new AnnotationConfigApplicationContext();
context.registerBean(HibernateDomainConfiguration.class);
contributeHints(context, hints ->
assertThat(RuntimeHintsPredicates.reflection().onType(CreationTimestampGeneration.class)
assertThat(RuntimeHintsPredicates.reflection().onType(CreationTimestamp.class)
.withMemberCategories(MemberCategory.INVOKE_DECLARED_CONSTRUCTORS)).accepts(hints));
}
@@ -144,6 +144,7 @@ class PersistenceManagedTypesBeanRegistrationAotProcessorTests {
result.accept(generationContext.getRuntimeHints());
}
public static class JpaDomainConfiguration extends AbstractEntityManagerWithPackagesToScanConfiguration {
@Override
@@ -152,6 +153,7 @@ class PersistenceManagedTypesBeanRegistrationAotProcessorTests {
}
}
public static class HibernateDomainConfiguration extends AbstractEntityManagerWithPackagesToScanConfiguration {
@Override
@@ -160,6 +162,7 @@ class PersistenceManagedTypesBeanRegistrationAotProcessorTests {
}
}
public abstract static class AbstractEntityManagerWithPackagesToScanConfiguration {
protected boolean scanningInvoked;
@@ -194,7 +197,6 @@ class PersistenceManagedTypesBeanRegistrationAotProcessorTests {
}
protected abstract String packageToScan();
}
}

1
spring-orm/src/test/java/org/springframework/orm/jpa/persistenceunit/PersistenceXmlParsingTests.java
View File

@@ -47,6 +47,7 @@ import static org.assertj.core.api.Assertions.assertThatRuntimeException;
* @author Juergen Hoeller
* @author Nicholas Williams
*/
@SuppressWarnings("removal")
class PersistenceXmlParsingTests {
@Test