Review and rationalize memory layout of AbstractInterceptor

Sanne · Sanne · commit 6bad486ab55c · 2025-06-22T20:25:22.000+01:00
diff --git a/hibernate-core/src/main/java/org/hibernate/bytecode/enhance/spi/interceptor/AbstractInterceptor.java b/hibernate-core/src/main/java/org/hibernate/bytecode/enhance/spi/interceptor/AbstractInterceptor.java
@@ -10,11 +10,9 @@
  * @author Steve Ebersole
  */
 public abstract class AbstractInterceptor implements SessionAssociableInterceptor {
-	private final String entityName;
 
-	private transient SharedSessionContractImplementor session;
-	private boolean allowLoadOutsideTransaction;
-	private String sessionFactoryUuid;
+	private final String entityName;
+	private SessionAssociationMarkers sessionAssociation;
 
 	public AbstractInterceptor(String entityName) {
 		this.entityName = entityName;
@@ -26,33 +24,46 @@ public String getEntityName() {
 
 	@Override
 	public SharedSessionContractImplementor getLinkedSession() {
-		return session;
+		return this.sessionAssociation != null ? this.sessionAssociation.session : null;
 	}
 
 	@Override
 	public void setSession(SharedSessionContractImplementor session) {
-		this.session = session;
-		if ( session != null && !allowLoadOutsideTransaction ) {
-			this.allowLoadOutsideTransaction = session.getFactory().getSessionFactoryOptions().isInitializeLazyStateOutsideTransactionsEnabled();
-			if ( this.allowLoadOutsideTransaction ) {
-				this.sessionFactoryUuid = session.getFactory().getUuid();
-			}
+		if ( session != null ) {
+			this.sessionAssociation = session.getSessionAssociationMarkers();
+		}
+		else {
+			unsetSession();
 		}
 	}
 
 	@Override
 	public void unsetSession() {
-		this.session = null;
+		if ( this.sessionAssociation != null ) {
+			//We shouldn't mutate the original instance as it's shared across multiple entities,
+			//but we can get a version of it which represents the same state except it doesn't have the session set:
+			this.sessionAssociation = this.sessionAssociation.deAssociatedCopy();
+		}
 	}
 
 	@Override
 	public boolean allowLoadOutsideTransaction() {
-		return allowLoadOutsideTransaction;
+		if ( this.sessionAssociation != null ) {
+			return this.sessionAssociation.allowLoadOutsideTransaction;
+		}
+		else {
+			return false;
+		}
 	}
 
 	@Override
 	public String getSessionFactoryUuid() {
-		return sessionFactoryUuid;
+		if ( this.sessionAssociation != null ) {
+			return this.sessionAssociation.sessionFactoryUuid;
+		}
+		else {
+			return null;
+		}
 	}
 
 	/**
diff --git a/hibernate-core/src/main/java/org/hibernate/bytecode/enhance/spi/interceptor/SessionAssociationMarkers.java b/hibernate-core/src/main/java/org/hibernate/bytecode/enhance/spi/interceptor/SessionAssociationMarkers.java
@@ -0,0 +1,76 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ * Copyright Red Hat Inc. and Hibernate Authors
+ */
+package org.hibernate.bytecode.enhance.spi.interceptor;
+
+import org.hibernate.engine.spi.SharedSessionContractImplementor;
+
+/**
+ * Contains the state necessary to properly implement SessionAssociableInterceptor;
+ * this allows reuse of this particular object across multiple interceptor instances
+ * and keeps them from getting too allocation-intensive.
+ * It also allows for a very elegant, simple way for the Session to clear references
+ * to itself on close.
+ */
+public final class SessionAssociationMarkers {
+
+	private static final SessionAssociationMarkers NON_ASSOCIATED = new SessionAssociationMarkers();
+
+	final boolean allowLoadOutsideTransaction;
+	final String sessionFactoryUuid;
+	transient SharedSessionContractImplementor session; //TODO by resetting this one field on Session#close we might be able to avoid iterating on all managed instances to de-associate them? Only if we guarantee all managed types use this.
+
+	public SessionAssociationMarkers(final SharedSessionContractImplementor session) {
+		this.allowLoadOutsideTransaction = session.getFactory().getSessionFactoryOptions()
+				.isInitializeLazyStateOutsideTransactionsEnabled();
+		if ( this.allowLoadOutsideTransaction ) {
+			this.sessionFactoryUuid = session.getFactory().getUuid();
+		}
+		else {
+			this.sessionFactoryUuid = null;
+		}
+		this.session = session;
+	}
+
+	/**
+	 * Constructor for the singleton representing non-associated
+	 * state.
+	 */
+	private SessionAssociationMarkers() {
+		this.allowLoadOutsideTransaction = false;
+		this.sessionFactoryUuid = null;
+		this.session = null;
+	}
+
+	/**
+	 * Copying constructor for when we're allowed to load outside of transactions
+	 * and need to transparently reassociated to the SessionFactory having the
+	 * specified UUID.
+	 * @param sessionFactoryUuid
+	 */
+	private SessionAssociationMarkers(String sessionFactoryUuid) {
+		this.allowLoadOutsideTransaction = true;
+		this.sessionFactoryUuid = sessionFactoryUuid;
+		this.session = null;
+	}
+
+	public SessionAssociationMarkers deAssociatedCopy() {
+		if ( allowLoadOutsideTransaction ) {
+			return new SessionAssociationMarkers( sessionFactoryUuid );
+		}
+		else {
+			return NON_ASSOCIATED;
+		}
+	}
+
+	/**
+	 * Careful as this mutates the state of this instance, which is possibly
+	 * used by multiple managed entities.
+	 * Removes the reference to the session; useful on Session close.
+	 */
+	public void sessionClosed() {
+		this.session = null;
+	}
+
+}
diff --git a/hibernate-core/src/main/java/org/hibernate/engine/spi/SessionDelegatorBaseImpl.java b/hibernate-core/src/main/java/org/hibernate/engine/spi/SessionDelegatorBaseImpl.java
@@ -40,6 +40,7 @@
 import org.hibernate.Transaction;
 import org.hibernate.UnknownProfileException;
 import org.hibernate.action.spi.AfterTransactionCompletionProcess;
+import org.hibernate.bytecode.enhance.spi.interceptor.SessionAssociationMarkers;
 import org.hibernate.cache.spi.CacheTransactionSynchronization;
 import org.hibernate.collection.spi.PersistentCollection;
 import org.hibernate.engine.jdbc.LobCreator;
@@ -1237,6 +1238,11 @@ public Object loadFromSecondLevelCache(EntityPersister persister, EntityKey enti
 		return delegate.loadFromSecondLevelCache( persister, entityKey, instanceToLoad, lockMode );
 	}
 
+	@Override
+	public SessionAssociationMarkers getSessionAssociationMarkers() {
+		return delegate.getSessionAssociationMarkers();
+	}
+
 	@Override
 	public boolean isIdentifierRollbackEnabled() {
 		return delegate.isIdentifierRollbackEnabled();
diff --git a/hibernate-core/src/main/java/org/hibernate/engine/spi/SharedSessionContractImplementor.java b/hibernate-core/src/main/java/org/hibernate/engine/spi/SharedSessionContractImplementor.java
@@ -17,6 +17,7 @@
 import org.hibernate.LockOptions;
 import org.hibernate.StatelessSession;
 import org.hibernate.action.spi.AfterTransactionCompletionProcess;
+import org.hibernate.bytecode.enhance.spi.interceptor.SessionAssociationMarkers;
 import org.hibernate.dialect.Dialect;
 import org.hibernate.event.spi.EventSource;
 import org.hibernate.query.Query;
@@ -572,4 +573,15 @@ default boolean isStatelessSession() {
 	 */
 	@Incubating
 	Object loadFromSecondLevelCache(EntityPersister persister, EntityKey entityKey, Object instanceToLoad, LockMode lockMode);
+
+	/**
+	 * Wrap all state that lazy loading interceptors might need to
+	 * manage association with this session, or to handle lazy loading
+	 * after detachment via the UUID of the SessionFactory.
+	 * N.B. this captures the current Session, however it can get
+	 * updated to a null session (for detached entities) or updated to
+	 * a different Session.
+	 */
+	@Incubating
+	SessionAssociationMarkers getSessionAssociationMarkers();
 }
diff --git a/hibernate-core/src/main/java/org/hibernate/engine/spi/SharedSessionDelegatorBaseImpl.java b/hibernate-core/src/main/java/org/hibernate/engine/spi/SharedSessionDelegatorBaseImpl.java
@@ -20,6 +20,7 @@
 import org.hibernate.SharedSessionContract;
 import org.hibernate.Transaction;
 import org.hibernate.action.spi.AfterTransactionCompletionProcess;
+import org.hibernate.bytecode.enhance.spi.interceptor.SessionAssociationMarkers;
 import org.hibernate.cache.spi.CacheTransactionSynchronization;
 import org.hibernate.collection.spi.PersistentCollection;
 import org.hibernate.engine.jdbc.LobCreator;
@@ -693,6 +694,11 @@ public Object loadFromSecondLevelCache(EntityPersister persister, EntityKey enti
 		return delegate.loadFromSecondLevelCache( persister, entityKey, instanceToLoad, lockMode );
 	}
 
+	@Override
+	public SessionAssociationMarkers getSessionAssociationMarkers() {
+		return delegate.getSessionAssociationMarkers();
+	}
+
 	@Override
 	public boolean isIdentifierRollbackEnabled() {
 		return delegate.isIdentifierRollbackEnabled();
diff --git a/hibernate-core/src/main/java/org/hibernate/internal/AbstractSharedSessionContract.java b/hibernate-core/src/main/java/org/hibernate/internal/AbstractSharedSessionContract.java
@@ -26,6 +26,7 @@
 import org.hibernate.UnknownEntityTypeException;
 import org.hibernate.binder.internal.TenantIdBinder;
 import org.hibernate.boot.spi.SessionFactoryOptions;
+import org.hibernate.bytecode.enhance.spi.interceptor.SessionAssociationMarkers;
 import org.hibernate.cache.spi.CacheTransactionSynchronization;
 import org.hibernate.context.spi.CurrentTenantIdentifierResolver;
 import org.hibernate.dialect.Dialect;
@@ -179,6 +180,7 @@ public abstract class AbstractSharedSessionContract implements SharedSessionCont
 
 	//Lazily initialized
 	private transient ExceptionConverter exceptionConverter;
+	private transient SessionAssociationMarkers sessionAssociationMarkers;
 
 	public AbstractSharedSessionContract(SessionFactoryImpl factory, SessionCreationOptions options) {
 		this.factory = factory;
@@ -476,6 +478,11 @@ public void close() {
 				removeSharedSessionTransactionObserver( transactionCoordinator );
 			}
 
+			if ( sessionAssociationMarkers != null ) {
+				sessionAssociationMarkers.sessionClosed();
+				sessionAssociationMarkers = null;
+			}
+
 			try {
 				if ( shouldCloseJdbcCoordinatorOnClose( isTransactionCoordinatorShared ) ) {
 					jdbcCoordinator.close();
@@ -1586,6 +1593,14 @@ public FormatMapper getJsonFormatMapper() {
 		return factoryOptions.getJsonFormatMapper();
 	}
 
+	@Override
+	public SessionAssociationMarkers getSessionAssociationMarkers() {
+		if ( this.sessionAssociationMarkers == null ) {
+			this.sessionAssociationMarkers = new SessionAssociationMarkers( this );
+		}
+		return sessionAssociationMarkers;
+	}
+
 	@Serial
 	private void writeObject(ObjectOutputStream oos) throws IOException {
 		if ( log.isTraceEnabled() ) {
