changelog.txt

@@ -3,6 +3,23 @@ Hibernate 6 Changelog
 
 Note: Please refer to JIRA to learn more about each issue.
 
+Changes in 6.6.12.Final (March 30, 2025)
+------------------------------------------------------------------------------------------------------------------------
+
+https://hibernate.atlassian.net/projects/HHH/versions/32945
+
+** Bug
+    * [HHH-19109] - Hibernate Data Repositories are @RequestScoped
+    * [HHH-19059] - Bytecode enhancement fails when inherited fields are mapped using property access in subclass
+    * [HHH-19017] - Class Cast Exception for PersistentAttributeInterceptable
+    * [HHH-18920] - Enum parameters in Jakarta Data repository method return type constructor are not properly matched
+    * [HHH-18745] - Unnecessary joins when use TREAT operator 
+    * [HHH-14694] - Use stable proxy names to avoid managing proxy state and memory leaks
+
+** Task
+    * [HHH-19230] - Ensure that thread local for org.hibernate.bytecode.enhance.internal.bytebuddy.SafeCacheProvider + OverridingClassFileLocator are completely cleared
+
+
 Changes in 6.6.11.Final (March 16, 2025)
 ------------------------------------------------------------------------------------------------------------------------
 

gradle/version.properties

@@ -1 +1 @@
-hibernateVersion=6.6.11.Final
+hibernateVersion=6.6.12.Final

hibernate-core/src/main/java/org/hibernate/bytecode/enhance/internal/bytebuddy/EnhancerCacheProvider.java

@@ -0,0 +1,66 @@
+/*
+ * Hibernate, Relational Persistence for Idiomatic Java
+ *
+ * License: GNU Lesser General Public License (LGPL), version 2.1 or later.
+ * See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
+ */
+package org.hibernate.bytecode.enhance.internal.bytebuddy;
+
+import net.bytebuddy.dynamic.ClassFileLocator;
+import net.bytebuddy.pool.TypePool;
+
+/**
+ * A simple cache provider that allows overriding the resolution for the class that is currently being enhanced.
+ */
+final class EnhancerCacheProvider extends TypePool.CacheProvider.Simple {
+
+	private final ThreadLocal<EnhancementState> enhancementState = new ThreadLocal<>();
+
+	@Override
+	public TypePool.Resolution find(final String name) {
+		final EnhancementState enhancementState = getEnhancementState();
+		if ( enhancementState != null && enhancementState.getClassName().equals( name ) ) {
+			return enhancementState.getTypePoolResolution();
+		}
+		return super.find( name );
+	}
+
+	EnhancementState getEnhancementState() {
+		return enhancementState.get();
+	}
+
+	void setEnhancementState(EnhancementState state) {
+		enhancementState.set( state );
+	}
+
+	void removeEnhancementState() {
+		enhancementState.remove();
+	}
+
+	static final class EnhancementState {
+		private final String className;
+		private final ClassFileLocator.Resolution classFileResolution;
+		private TypePool.Resolution typePoolResolution;
+
+		public EnhancementState(String className, ClassFileLocator.Resolution classFileResolution) {
+			this.className = className;
+			this.classFileResolution = classFileResolution;
+		}
+
+		public String getClassName() {
+			return className;
+		}
+
+		public ClassFileLocator.Resolution getClassFileResolution() {
+			return classFileResolution;
+		}
+
+		public TypePool.Resolution getTypePoolResolution() {
+			return typePoolResolution;
+		}
+
+		public void setTypePoolResolution(TypePool.Resolution typePoolResolution) {
+			this.typePoolResolution = typePoolResolution;
+		}
+	}
+}

hibernate-core/src/main/java/org/hibernate/bytecode/enhance/internal/bytebuddy/EnhancerClassFileLocator.java

@@ -0,0 +1,40 @@
+/*
+ * Hibernate, Relational Persistence for Idiomatic Java
+ *
+ * License: GNU Lesser General Public License (LGPL), version 2.1 or later.
+ * See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
+ */
+package org.hibernate.bytecode.enhance.internal.bytebuddy;
+
+import net.bytebuddy.dynamic.ClassFileLocator;
+
+import java.io.IOException;
+
+/**
+ * A delegating ClassFileLocator that allows overriding the resolution for the class that is currently being enhanced.
+ */
+final class EnhancerClassFileLocator implements ClassFileLocator {
+
+	private final EnhancerCacheProvider cacheProvider;
+	private final ClassFileLocator delegate;
+
+	public EnhancerClassFileLocator(EnhancerCacheProvider cacheProvider, ClassFileLocator delegate) {
+		this.cacheProvider = cacheProvider;
+		this.delegate = delegate;
+	}
+
+	@Override
+	public Resolution locate(final String name) throws IOException {
+		final EnhancerCacheProvider.EnhancementState enhancementState = cacheProvider.getEnhancementState();
+		if ( enhancementState != null && enhancementState.getClassName().equals( name ) ) {
+			return enhancementState.getClassFileResolution();
+		}
+		return delegate.locate( name );
+	}
+
+	@Override
+	public void close() throws IOException {
+		delegate.close();
+	}
+
+}

hibernate-core/src/main/java/org/hibernate/bytecode/enhance/internal/bytebuddy/EnhancerImpl.java

@@ -13,6 +13,7 @@
 import jakarta.persistence.Entity;
 import jakarta.persistence.Id;
 import jakarta.persistence.MappedSuperclass;
+import jakarta.persistence.Transient;
 import jakarta.persistence.metamodel.Type;
 import net.bytebuddy.asm.Advice;
 import net.bytebuddy.description.annotation.AnnotationDescription;
@@ -74,6 +75,9 @@
 import static net.bytebuddy.matcher.ElementMatchers.isDefaultFinalizer;
 import static net.bytebuddy.matcher.ElementMatchers.isGetter;
 import static net.bytebuddy.matcher.ElementMatchers.isSetter;
+import static net.bytebuddy.matcher.ElementMatchers.isStatic;
+import static net.bytebuddy.matcher.ElementMatchers.named;
+import static net.bytebuddy.matcher.ElementMatchers.not;
 
 public class EnhancerImpl implements Enhancer {
 
@@ -476,21 +480,13 @@ private static boolean hasMappingAnnotation(AnnotationList annotations) {
 				|| annotations.isAnnotationPresent( Embeddable.class );
 	}
 
-	private static boolean hasPersistenceAnnotation(AnnotationList annotations) {
-		boolean found = false;
-		for ( AnnotationDescription annotation : annotations ) {
-			final String annotationName = annotation.getAnnotationType().getName();
-			if ( annotationName.startsWith( "jakarta.persistence" ) ) {
-				if ( annotationName.equals( "jakarta.persistence.Transient" ) ) {
-					// transient property so ignore it
-					return false;
-				}
-				else if ( !found && !IGNORED_PERSISTENCE_ANNOTATIONS.contains( annotationName ) ) {
-					found = true;
-				}
-			}
+	private static boolean isPersistentMethod(MethodDescription method) {
+		final AnnotationList annotations = method.getDeclaredAnnotations();
+		if ( annotations.isAnnotationPresent( Transient.class ) ) {
+			return false;
 		}
-		return found;
+
+		return annotations.stream().noneMatch( a -> IGNORED_PERSISTENCE_ANNOTATIONS.contains( a.getAnnotationType().getName() ) );
 	}
 
 	private static final Set<String> IGNORED_PERSISTENCE_ANNOTATIONS = Set.of(
@@ -503,6 +499,17 @@ else if ( !found && !IGNORED_PERSISTENCE_ANNOTATIONS.contains( annotationName )
 			"jakarta.persistence.PreUpdate"
 	);
 
+	private static boolean containsField(Generic type, String fieldName) {
+		do {
+			if ( !type.getDeclaredFields().filter( not( isStatic() ).and( named( fieldName ) ) ).isEmpty() ) {
+				return true;
+			}
+			type = type.getSuperClass();
+		}
+		while ( type != null && !type.represents( Object.class ) );
+		return false;
+	}
+
 	/**
 	 * Check whether an entity class ({@code managedCtClass}) has mismatched names between a persistent field and its
 	 * getter/setter when using {@link AccessType#PROPERTY}, which Hibernate does not currently support for enhancement.
@@ -545,61 +552,46 @@ private static boolean checkUnsupportedAttributeNaming(TypeDescription managedCt
 				.asMethodList()
 				.filter( isGetter().or( isSetter() ) );
 		for ( final MethodDescription methodDescription : methods ) {
-			if ( determineAccessType( methodDescription, defaultAccessType ) != AccessType.PROPERTY ) {
+			if ( methodDescription.getDeclaringType().represents( Object.class )
+				|| determineAccessType( methodDescription, defaultAccessType ) != AccessType.PROPERTY ) {
 				// We only need to check this for AccessType.PROPERTY
 				continue;
 			}
 
 			final String methodName = methodDescription.getActualName();
-			String methodFieldName;
+			String fieldName;
 			if ( methodName.startsWith( "get" ) || methodName.startsWith( "set" ) ) {
-				methodFieldName = methodName.substring( 3 );
+				fieldName = methodName.substring( 3 );
 			}
 			else {
 				assert methodName.startsWith( "is" );
-				methodFieldName = methodName.substring( 2 );
+				fieldName = methodName.substring( 2 );
 			}
 			// convert first field letter to lower case
-			methodFieldName = getJavaBeansFieldName( methodFieldName );
-			if ( methodFieldName != null && hasPersistenceAnnotation( methodDescription.getDeclaredAnnotations() ) ) {
-				boolean propertyNameMatchesFieldName = false;
-				for ( final FieldDescription field : methodDescription.getDeclaringType().getDeclaredFields() ) {
-					if ( !Modifier.isStatic( field.getModifiers() ) ) {
-						final AnnotatedFieldDescription annotatedField = new AnnotatedFieldDescription(
-								enhancementContext,
-								field
+			fieldName = getJavaBeansFieldName( fieldName );
+			if ( fieldName != null && isPersistentMethod( methodDescription )
+				&& !containsField( managedCtClass.asGenericType(), fieldName ) ) {
+				// We shouldn't even be in this method if using LEGACY, see top of this method.
+				switch ( strategy ) {
+					case SKIP:
+						log.debugf(
+								"Skipping enhancement of [%s] because no field named [%s] could be found for property accessor method [%s]."
+										+ " To fix this, make sure all property accessor methods have a matching field.",
+								managedCtClass.getName(),
+								fieldName,
+								methodDescription.getName()
 						);
-						if ( enhancementContext.isPersistentField( annotatedField ) ) {
-							if ( methodFieldName.equals( field.getActualName() ) ) {
-								propertyNameMatchesFieldName = true;
-								break;
-							}
-						}
-					}
-				}
-				if ( !propertyNameMatchesFieldName ) {
-					// We shouldn't even be in this method if using LEGACY, see top of this method.
-					switch ( strategy ) {
-						case SKIP:
-							log.debugf(
-									"Skipping enhancement of [%s] because no field named [%s] could be found for property accessor method [%s]."
-											+ " To fix this, make sure all property accessor methods have a matching field.",
-									managedCtClass.getName(),
-									methodFieldName,
-									methodDescription.getName()
-							);
-							return true;
-						case FAIL:
-							throw new EnhancementException( String.format(
-									"Enhancement of [%s] failed because no field named [%s] could be found for property accessor method [%s]."
-											+ " To fix this, make sure all property accessor methods have a matching field.",
-									managedCtClass.getName(),
-									methodFieldName,
-									methodDescription.getName()
-							) );
-						default:
-							throw new AssertionFailure( "Unexpected strategy at this point: " + strategy );
-					}
+						return true;
+					case FAIL:
+						throw new EnhancementException( String.format(
+								"Enhancement of [%s] failed because no field named [%s] could be found for property accessor method [%s]."
+										+ " To fix this, make sure all property accessor methods have a matching field.",
+								managedCtClass.getName(),
+								fieldName,
+								methodDescription.getName()
+						) );
+					default:
+						throw new AssertionFailure( "Unexpected strategy at this point: " + strategy );
 				}
 			}
 		}

hibernate-core/src/main/java/org/hibernate/bytecode/enhance/internal/bytebuddy/ModelTypePool.java

@@ -6,23 +6,21 @@
  */
 package org.hibernate.bytecode.enhance.internal.bytebuddy;
 
-import java.util.Objects;
-import java.util.concurrent.ConcurrentHashMap;
-
 import net.bytebuddy.dynamic.ClassFileLocator;
 import net.bytebuddy.pool.TypePool;
 
+import java.util.Objects;
+
 /**
  * A TypePool suitable for loading user's classes,
  * potentially in parallel operations.
  */
 public class ModelTypePool extends TypePool.Default implements EnhancerClassLocator {
 
-	private final ConcurrentHashMap<String, Resolution> resolutions = new ConcurrentHashMap<>();
-	private final OverridingClassFileLocator locator;
-	private final SafeCacheProvider poolCache;
+	private final EnhancerClassFileLocator locator;
+	private final EnhancerCacheProvider poolCache;
 
-	private ModelTypePool(SafeCacheProvider cacheProvider, OverridingClassFileLocator classFileLocator, CoreTypePool parent) {
+	private ModelTypePool(EnhancerCacheProvider cacheProvider, EnhancerClassFileLocator classFileLocator, CoreTypePool parent) {
 		super( cacheProvider, classFileLocator, ReaderMode.FAST, parent );
 		this.poolCache = cacheProvider;
 		this.locator = classFileLocator;
@@ -64,7 +62,7 @@ public static EnhancerClassLocator buildModelTypePool(ClassFileLocator classFile
 	 * @return
 	 */
 	public static EnhancerClassLocator buildModelTypePool(ClassFileLocator classFileLocator, CoreTypePool coreTypePool) {
-		return buildModelTypePool( classFileLocator, coreTypePool, new SafeCacheProvider() );
+		return buildModelTypePool( classFileLocator, coreTypePool, new EnhancerCacheProvider() );
 	}
 
 	/**
@@ -74,44 +72,35 @@ public static EnhancerClassLocator buildModelTypePool(ClassFileLocator classFile
 	 * @param cacheProvider
 	 * @return
 	 */
-	public static EnhancerClassLocator buildModelTypePool(ClassFileLocator classFileLocator, CoreTypePool coreTypePool, SafeCacheProvider cacheProvider) {
+	static EnhancerClassLocator buildModelTypePool(ClassFileLocator classFileLocator, CoreTypePool coreTypePool, EnhancerCacheProvider cacheProvider) {
 		Objects.requireNonNull( classFileLocator );
 		Objects.requireNonNull( coreTypePool );
 		Objects.requireNonNull( cacheProvider );
-		return new ModelTypePool( cacheProvider, new OverridingClassFileLocator( classFileLocator ), coreTypePool );
-	}
-
-	@Override
-	protected Resolution doDescribe(final String name) {
-		final Resolution resolution = resolutions.get( name );
-		if ( resolution != null ) {
-			return resolution;
-		}
-		else {
-			return resolutions.computeIfAbsent( name, super::doDescribe );
-		}
+		return new ModelTypePool( cacheProvider, new EnhancerClassFileLocator( cacheProvider, classFileLocator ), coreTypePool );
 	}
 
 	@Override
 	public void registerClassNameAndBytes(final String className, final byte[] bytes) {
-		//Very important: ensure the registered override is actually effective in case this class
-		//was already resolved in the recent past; this could have happened for example as a side effect
-		//of symbol resolution during enhancement of a different class, or very simply when attempting
-		//to re-enhanced the same class - which happens frequently in WildFly because of the class transformers
-		//being triggered concurrently by multiple parallel deployments.
-		resolutions.remove( className );
-		poolCache.remove( className );
-		locator.put( className, new ClassFileLocator.Resolution.Explicit( Objects.requireNonNull( bytes ) ) );
+		final EnhancerCacheProvider.EnhancementState currentEnhancementState = poolCache.getEnhancementState();
+		if ( currentEnhancementState != null ) {
+			throw new IllegalStateException( "Re-entrant enhancement is not supported: " + className );
+		}
+		final EnhancerCacheProvider.EnhancementState state = new EnhancerCacheProvider.EnhancementState(
+				className,
+				new ClassFileLocator.Resolution.Explicit( Objects.requireNonNull( bytes ) )
+		);
+		// Set the state first because the ClassFileLocator needs this in the doDescribe() call below
+		poolCache.setEnhancementState( state );
+		state.setTypePoolResolution( doDescribe( className ) );
 	}
 
 	@Override
-	public void deregisterClassNameAndBytes(final String className) {
-		locator.remove( className );
+	public void deregisterClassNameAndBytes(String className) {
+		poolCache.removeEnhancementState();
 	}
 
 	@Override
 	public ClassFileLocator asClassFileLocator() {
 		return locator;
 	}
-
 }