HHH-19536 Rework all state belonging to LazyAttributeLoadingInterceptor to allow upfront processing

Author: Sanne

hibernate-core/src/main/java/org/hibernate/bytecode/enhance/spi/interceptor/LazyAttributeLoadingInterceptor.java

@@ -28,28 +28,23 @@
  * @author Steve Ebersole
  */
 public class LazyAttributeLoadingInterceptor extends AbstractInterceptor implements BytecodeLazyAttributeInterceptor {
-	private final Object identifier;
-	private final String entityName;
 
-	//N.B. this Set needs to be treated as immutable
-	private Set<String> lazyFields;
+	private final Object identifier;
+	private EntityRelatedState entityMeta;
 	private Set<String> initializedLazyFields;
-	private Set<String> mutableLazyFields;
 
 	public LazyAttributeLoadingInterceptor(
-			String entityName,
+			EntityRelatedState entityMeta,
 			Object identifier,
-			Set<String> lazyFields,
 			SharedSessionContractImplementor session) {
-		this.entityName = entityName;
 		this.identifier = identifier;
-		this.lazyFields = lazyFields;
+		this.entityMeta = entityMeta;
 		setSession( session );
 	}
 
 	@Override
 	public String getEntityName() {
-		return entityName;
+		return entityMeta.entityName;
 	}
 
 	@Override
@@ -130,23 +125,23 @@ public boolean isAttributeLoaded(String fieldName) {
 	}
 
 	private boolean isLazyAttribute(String fieldName) {
-		return lazyFields.contains( fieldName );
+		return entityMeta.lazyFields.contains( fieldName );
 	}
 
 	private boolean isInitializedLazyField(String fieldName) {
 		return initializedLazyFields != null && initializedLazyFields.contains( fieldName );
 	}
 
 	public boolean hasAnyUninitializedAttributes() {
-		if ( lazyFields.isEmpty() ) {
+		if ( entityMeta.lazyFields.isEmpty() ) {
 			return false;
 		}
 
 		if ( initializedLazyFields == null ) {
 			return true;
 		}
 
-		for ( String fieldName : lazyFields ) {
+		for ( String fieldName : entityMeta.lazyFields ) {
 			if ( !initializedLazyFields.contains( fieldName ) ) {
 				return true;
 			}
@@ -157,7 +152,7 @@ public boolean hasAnyUninitializedAttributes() {
 
 	@Override
 	public String toString() {
-		return getClass().getSimpleName() + "(entityName=" + getEntityName() + " ,lazyFields=" + lazyFields + ')';
+		return getClass().getSimpleName() + "(entityName=" + getEntityName() + " ,lazyFields=" + entityMeta.lazyFields + ')';
 	}
 
 	private void takeCollectionSizeSnapshot(Object target, String fieldName, Object value) {
@@ -197,14 +192,43 @@ public Set<String> getInitializedLazyAttributeNames() {
 	}
 
 	public void addLazyFieldByGraph(String fieldName) {
-		if ( mutableLazyFields == null ) {
-			mutableLazyFields = new HashSet<>( lazyFields );
-			lazyFields = mutableLazyFields;
+		if ( entityMeta.shared ) {
+			//We need to make a defensive copy first to not affect other entities of the same type;
+			//as we create a copy we lose some of the efficacy of using a separate class to track this state,
+			//but this is a corner case so we prefer to optimise for the common case.
+			entityMeta = entityMeta.toNonSharedMutableState();
 		}
-		mutableLazyFields.add( fieldName );
+		entityMeta.lazyFields.add( fieldName );
 	}
 
 	public void clearInitializedLazyFields() {
 		initializedLazyFields = null;
 	}
+
+	/**
+	 * This is an helper object to group all state which relates to a particular entity type,
+	 * and which is needed for this interceptor.
+	 * Grouping such state allows for upfront construction as a per-entity singleton:
+	 * this reduces processing work on creation of an interceptor instance and is more
+	 * efficient from a point of view of memory usage and memory layout.
+	 */
+	public static class EntityRelatedState {
+		private final String entityName;
+		private final Set<String> lazyFields;
+		private final boolean shared;
+
+		public EntityRelatedState(String entityName, Set<String> lazyFields) {
+			this.entityName = entityName;
+			this.lazyFields = lazyFields; //N.B. this is an immutable, compact set
+			this.shared = true;
+		}
+		private EntityRelatedState(String entityName, Set<String> lazyFields, boolean shared) {
+			this.entityName = entityName;
+			this.lazyFields = lazyFields;
+			this.shared = shared;
+		}
+		private EntityRelatedState toNonSharedMutableState() {
+			return new EntityRelatedState( entityName, new HashSet<>( lazyFields ), false );
+		}
+	}
 }

hibernate-core/src/main/java/org/hibernate/bytecode/internal/BytecodeEnhancementMetadataPojoImpl.java

@@ -72,6 +72,7 @@ public static BytecodeEnhancementMetadata from(
 	private final CompositeType nonAggregatedCidMapper;
 	private final boolean enhancedForLazyLoading;
 	private final LazyAttributesMetadata lazyAttributesMetadata;
+	private final LazyAttributeLoadingInterceptor.EntityRelatedState loadingInterceptorState;
 
 	BytecodeEnhancementMetadataPojoImpl(
 			String entityName,
@@ -89,6 +90,8 @@ public static BytecodeEnhancementMetadata from(
 		this.identifierAttributeNames = identifierAttributeNames;
 		this.enhancedForLazyLoading = enhancedForLazyLoading;
 		this.lazyAttributesMetadata = lazyAttributesMetadata;
+		this.loadingInterceptorState = new LazyAttributeLoadingInterceptor.EntityRelatedState(
+				getEntityName(), lazyAttributesMetadata.getLazyAttributeNames() );
 	}
 
 	@Override
@@ -217,9 +220,8 @@ public LazyAttributeLoadingInterceptor injectInterceptor(
 			);
 		}
 		final LazyAttributeLoadingInterceptor interceptor = new LazyAttributeLoadingInterceptor(
-				getEntityName(),
+				this.loadingInterceptorState,
 				identifier,
-				lazyAttributesMetadata.getLazyAttributeNames(),
 				session
 		);
 

hibernate-core/src/main/java/org/hibernate/metamodel/internal/AbstractEntityInstantiatorPojo.java

@@ -23,6 +23,7 @@ public abstract class AbstractEntityInstantiatorPojo extends AbstractPojoInstant
 	private final EntityMetamodel entityMetamodel;
 	private final Class<?> proxyInterface;
 	private final boolean applyBytecodeInterception;
+	private final LazyAttributeLoadingInterceptor.EntityRelatedState loadingInterceptorState;
 
 	public AbstractEntityInstantiatorPojo(
 			EntityMetamodel entityMetamodel,
@@ -34,17 +35,25 @@ public AbstractEntityInstantiatorPojo(
 		//TODO this PojoEntityInstantiator appears to not be reused ?!
 		this.applyBytecodeInterception =
 				isPersistentAttributeInterceptableType( persistentClass.getMappedClass() );
+		if ( applyBytecodeInterception ) {
+			this.loadingInterceptorState = new LazyAttributeLoadingInterceptor.EntityRelatedState(
+					entityMetamodel.getName(),
+					entityMetamodel.getBytecodeEnhancementMetadata()
+						.getLazyAttributesMetadata()
+						.getLazyAttributeNames()
+			);
+		}
+		else {
+			this.loadingInterceptorState = null;
+		}
 	}
 
 	protected Object applyInterception(Object entity) {
 		if ( applyBytecodeInterception ) {
 			asPersistentAttributeInterceptable( entity )
 					.$$_hibernate_setInterceptor( new LazyAttributeLoadingInterceptor(
-							entityMetamodel.getName(),
+							loadingInterceptorState,
 							null,
-							entityMetamodel.getBytecodeEnhancementMetadata()
-									.getLazyAttributesMetadata()
-									.getLazyAttributeNames(),
 							null
 					) );
 		}

hibernate-core/src/main/java/org/hibernate/metamodel/internal/EntityInstantiatorPojoStandard.java

@@ -25,21 +25,30 @@
 public class EntityInstantiatorPojoStandard extends AbstractEntityInstantiatorPojo {
 	private static final CoreMessageLogger LOG = CoreLogging.messageLogger( EntityInstantiatorPojoStandard.class );
 
-	private final EntityMetamodel entityMetamodel;
 	private final Class<?> proxyInterface;
 	private final boolean applyBytecodeInterception;
-
+	private final LazyAttributeLoadingInterceptor.EntityRelatedState loadingInterceptorState;
 	private final Constructor<?> constructor;
 
 	public EntityInstantiatorPojoStandard(
 			EntityMetamodel entityMetamodel,
 			PersistentClass persistentClass,
 			JavaType<?> javaType) {
 		super( entityMetamodel, persistentClass, javaType );
-		this.entityMetamodel = entityMetamodel;
 		proxyInterface = persistentClass.getProxyInterface();
 		constructor = isAbstract() ? null : resolveConstructor( getMappedPojoClass() );
 		applyBytecodeInterception = isPersistentAttributeInterceptableType( persistentClass.getMappedClass() );
+		if ( applyBytecodeInterception ) {
+			this.loadingInterceptorState = new LazyAttributeLoadingInterceptor.EntityRelatedState(
+					entityMetamodel.getName(),
+					entityMetamodel.getBytecodeEnhancementMetadata()
+							.getLazyAttributesMetadata()
+							.getLazyAttributeNames()
+			);
+		}
+		else {
+			this.loadingInterceptorState = null;
+		}
 	}
 
 	protected static Constructor<?> resolveConstructor(Class<?> mappedPojoClass) {
@@ -62,11 +71,8 @@ protected Object applyInterception(Object entity) {
 		if ( applyBytecodeInterception ) {
 			asPersistentAttributeInterceptable( entity )
 					.$$_hibernate_setInterceptor( new LazyAttributeLoadingInterceptor(
-							entityMetamodel.getName(),
+							loadingInterceptorState,
 							null,
-							entityMetamodel.getBytecodeEnhancementMetadata()
-									.getLazyAttributesMetadata()
-									.getLazyAttributeNames(),
 							null
 					) );
 		}