tiny refactoring in proxy interceptors

Author: gavinking

hibernate-core/src/main/java/org/hibernate/proxy/AbstractLazyInitializer.java

@@ -10,11 +10,11 @@
 import org.hibernate.SessionException;
 import org.hibernate.boot.spi.SessionFactoryOptions;
 import org.hibernate.engine.spi.EntityKey;
+import org.hibernate.engine.spi.SessionFactoryImplementor;
 import org.hibernate.engine.spi.SharedSessionContractImplementor;
 import org.hibernate.internal.CoreLogging;
 import org.hibernate.internal.CoreMessageLogger;
 import org.hibernate.internal.SessionFactoryRegistry;
-import org.hibernate.metamodel.spi.MappingMetamodelImplementor;
 import org.hibernate.persister.entity.EntityPersister;
 
 /**
@@ -25,6 +25,7 @@
  * @author Gavin King
  */
 public abstract class AbstractLazyInitializer implements LazyInitializer {
+
 	private static final CoreMessageLogger LOG = CoreLogging.messageLogger( AbstractLazyInitializer.class );
 
 	private final String entityName;
@@ -77,20 +78,22 @@ public final Object getIdentifier() {
 		return id;
 	}
 
-	private MappingMetamodelImplementor getMappingMetamodel() {
-		return session.getFactory().getMappingMetamodel();
+	private SessionFactoryImplementor getFactory() {
+		return session.getFactory();
 	}
 
-	private EntityPersister getEntityDescriptor() {
-		return getMappingMetamodel().getEntityDescriptor( entityName );
+	public EntityPersister getEntityDescriptor() {
+		return getFactory().getMappingMetamodel().getEntityDescriptor( entityName );
 	}
 
 	private SessionFactoryOptions getSessionFactoryOptions() {
-		return session.getFactory().getSessionFactoryOptions();
+		return getFactory().getSessionFactoryOptions();
 	}
 
 	private boolean isInitializeProxyWhenAccessingIdentifier() {
-		return session != null && getSessionFactoryOptions().getJpaCompliance().isJpaProxyComplianceEnabled();
+		return session != null
+			&& getSessionFactoryOptions().getJpaCompliance()
+					   .isJpaProxyComplianceEnabled();
 	}
 
 	@Override
@@ -208,8 +211,10 @@ protected void permissiveInitialization() {
 				session.getPersistenceContext().setDefaultReadOnly( true );
 				session.setHibernateFlushMode( FlushMode.MANUAL );
 
-				final boolean isJTA = session.getTransactionCoordinator().getTransactionCoordinatorBuilder().isJta();
-
+				final boolean isJTA =
+						session.getTransactionCoordinator()
+								.getTransactionCoordinatorBuilder()
+								.isJta();
 				if ( !isJTA ) {
 					// Explicitly handle the transactions only if we're not in
 					// a JTA environment.  A lazy loading temporary session can
@@ -262,8 +267,7 @@ else if ( session.isOpenOrWaitingForAutoClose() && session.isConnected() ) {
 	 */
 	public final void initializeWithoutLoadIfPossible() {
 		if ( !initialized && session != null && session.isOpenOrWaitingForAutoClose() ) {
-			final var entityDescriptor = getMappingMetamodel().getEntityDescriptor( getEntityName() );
-			final var key = session.generateEntityKey( getInternalIdentifier(), entityDescriptor );
+			final var key = session.generateEntityKey( getInternalIdentifier(), getEntityDescriptor() );
 			final Object entity = session.getPersistenceContextInternal().getEntity( key );
 			if ( entity != null ) {
 				setImplementation( entity );
@@ -279,16 +283,15 @@ protected void prepareForPossibleLoadingOutsideTransaction() {
 		if ( session != null ) {
 			allowLoadOutsideTransaction =
 					getSessionFactoryOptions().isInitializeLazyStateOutsideTransactionsEnabled();
-
 			if ( sessionFactoryUuid == null ) {
 				// we're going to need the UUID even if the SessionFactory configuration doesn't
 				// allow any operations on it, as we need it to match deserialized objects with
 				// the originating SessionFactory: at very least it's useful to actually get
 				// such configuration, so to know if such operation isn't allowed or configured otherwise.
-				sessionFactoryUuid = session.getFactory().getUuid();
+				sessionFactoryUuid = getFactory().getUuid();
 			}
 			if ( sessionFactoryName == null ) {
-				sessionFactoryName = session.getFactory().getName();
+				sessionFactoryName = getFactory().getName();
 			}
 		}
 	}
@@ -312,10 +315,9 @@ protected final boolean isConnectedToSession() {
 
 	private Object getProxyOrNull() {
 		final var entityKey = generateEntityKeyOrNull( getInternalIdentifier(), session, getEntityName() );
-		if ( entityKey != null && session != null && session.isOpenOrWaitingForAutoClose() ) {
-			return session.getPersistenceContextInternal().getProxy( entityKey );
-		}
-		return null;
+		return entityKey != null && session != null && session.isOpenOrWaitingForAutoClose()
+				? session.getPersistenceContextInternal().getProxy( entityKey )
+				: null;
 	}
 
 	@Override
@@ -344,7 +346,7 @@ public String getImplementationEntityName() {
 		}
 		if ( getEntityDescriptor().hasSubclasses() ) {
 			initialize();
-			return session.getFactory().bestGuessEntityName( target );
+			return getFactory().bestGuessEntityName( target );
 		}
 		return entityName;
 	}

hibernate-core/src/main/java/org/hibernate/proxy/map/MapProxy.java

@@ -21,77 +21,77 @@
 @SuppressWarnings("rawtypes")
 public class MapProxy implements HibernateProxy, Map, Serializable {
 
-	private final MapLazyInitializer li;
+	private final MapLazyInitializer lazyInitializer;
 
 	private Object replacement;
 
-	MapProxy(MapLazyInitializer li) {
-		this.li = li;
+	MapProxy(MapLazyInitializer lazyInitializer) {
+		this.lazyInitializer = lazyInitializer;
 	}
 
 	@Override
 	public LazyInitializer getHibernateLazyInitializer() {
-		return li;
+		return lazyInitializer;
 	}
 
 	@Override
 	public int size() {
-		return li.getMap().size();
+		return lazyInitializer.getMap().size();
 	}
 
 	@Override
 	public void clear() {
-		li.getMap().clear();
+		lazyInitializer.getMap().clear();
 	}
 
 	@Override
 	public boolean isEmpty() {
-		return li.getMap().isEmpty();
+		return lazyInitializer.getMap().isEmpty();
 	}
 
 	@Override
 	public boolean containsKey(Object key) {
-		return li.getMap().containsKey(key);
+		return lazyInitializer.getMap().containsKey(key);
 	}
 
 	@Override
 	public boolean containsValue(Object value) {
-		return li.getMap().containsValue(value);
+		return lazyInitializer.getMap().containsValue(value);
 	}
 
 	@Override
 	public Collection<?> values() {
-		return li.getMap().values();
+		return lazyInitializer.getMap().values();
 	}
 
 	@Override @SuppressWarnings("unchecked")
 	public void putAll(Map map) {
-		li.getMap().putAll(map);
+		lazyInitializer.getMap().putAll(map);
 	}
 
 	@Override
 	public Set<?> entrySet() {
-		return li.getMap().entrySet();
+		return lazyInitializer.getMap().entrySet();
 	}
 
 	@Override
 	public Set<?> keySet() {
-		return li.getMap().keySet();
+		return lazyInitializer.getMap().keySet();
 	}
 
 	@Override
 	public Object get(Object key) {
-		return li.getMap().get(key);
+		return lazyInitializer.getMap().get(key);
 	}
 
 	@Override
 	public Object remove(Object key) {
-		return li.getMap().remove(key);
+		return lazyInitializer.getMap().remove(key);
 	}
 
 	@Override @SuppressWarnings("unchecked")
 	public Object put(Object key, Object value) {
-		return li.getMap().put(key, value);
+		return lazyInitializer.getMap().put(key, value);
 	}
 
 	@Serial
@@ -101,30 +101,30 @@ public Object writeReplace() {
 		 * If the target has already been loaded somewhere, just not set on the proxy,
 		 * then use it to initialize the proxy so that we will serialize that instead of the proxy.
 		 */
-		li.initializeWithoutLoadIfPossible();
+		lazyInitializer.initializeWithoutLoadIfPossible();
 
-		if ( li.isUninitialized() ) {
+		if ( lazyInitializer.isUninitialized() ) {
 			if ( replacement == null ) {
-				li.prepareForPossibleLoadingOutsideTransaction();
+				lazyInitializer.prepareForPossibleLoadingOutsideTransaction();
 				replacement = serializableProxy();
 			}
 			return replacement;
 		}
 		else {
-			return li.getImplementation();
+			return lazyInitializer.getImplementation();
 		}
 	}
 
 	private Object serializableProxy() {
 		return new SerializableMapProxy(
-				li.getEntityName(),
-				li.getInternalIdentifier(),
-				li.isReadOnlySettingAvailable()
-						? Boolean.valueOf( li.isReadOnly() )
-						: li.isReadOnlyBeforeAttachedToSession(),
-				li.getSessionFactoryUuid(),
-				li.getSessionFactoryName(),
-				li.isAllowLoadOutsideTransaction()
+				lazyInitializer.getEntityName(),
+				lazyInitializer.getInternalIdentifier(),
+				lazyInitializer.isReadOnlySettingAvailable()
+						? Boolean.valueOf( lazyInitializer.isReadOnly() )
+						: lazyInitializer.isReadOnlyBeforeAttachedToSession(),
+				lazyInitializer.getSessionFactoryUuid(),
+				lazyInitializer.getSessionFactoryName(),
+				lazyInitializer.isAllowLoadOutsideTransaction()
 		);
 	}
 

hibernate-core/src/main/java/org/hibernate/proxy/pojo/BasicLazyInitializer.java

@@ -105,7 +105,6 @@ private Object getReplacement() {
 		else {
 			return getTarget();
 		}
-
 	}
 
 	@Override
@@ -118,16 +117,12 @@ public Class<?> getImplementationClass() {
 		if ( !isUninitialized() ) {
 			return getImplementation().getClass();
 		}
+		else if ( getSession() == null ) {
+			throw new LazyInitializationException( "could not retrieve real entity class ["
+							+ getEntityName() + "#" + getInternalIdentifier() + "] - no Session" );
+		}
 		else {
-			final var session = getSession();
-			if ( session == null ) {
-				throw new LazyInitializationException( "could not retrieve real entity class ["
-								+ getEntityName() + "#" + getInternalIdentifier() + "] - no Session" );
-			}
-			final var entityDescriptor =
-					session.getFactory().getMappingMetamodel()
-							.getEntityDescriptor( getEntityName() );
-			return entityDescriptor.hasSubclasses()
+			return getEntityDescriptor().hasSubclasses()
 					? getImplementation().getClass()
 					: persistentClass;
 		}

hibernate-core/src/main/java/org/hibernate/proxy/pojo/bytebuddy/ByteBuddyInterceptor.java

@@ -16,7 +16,10 @@
 import static org.hibernate.internal.CoreLogging.messageLogger;
 import static org.hibernate.internal.util.ReflectHelper.isPublic;
 
-public class ByteBuddyInterceptor extends BasicLazyInitializer implements ProxyConfiguration.Interceptor {
+public class ByteBuddyInterceptor
+		extends BasicLazyInitializer
+		implements ProxyConfiguration.Interceptor {
+
 	private static final CoreMessageLogger LOG = messageLogger( ByteBuddyInterceptor.class );
 
 	private final Class<?>[] interfaces;