clean up the internal DefaultVisitor hierarchy

by removing two obsolete abstract superclasses

Signed-off-by: Gavin King <[email protected]>

Author: gavinking

hibernate-core/src/main/java/org/hibernate/event/internal/AbstractLockUpgradeEventListener.java

@@ -50,9 +50,7 @@
  *
  * @author Steve Ebersole.
  */
-public abstract class AbstractSaveEventListener<C>
-		extends AbstractReassociateEventListener
-		implements CallbackRegistryConsumer {
+public abstract class AbstractSaveEventListener<C> implements CallbackRegistryConsumer {
 	private static final CoreMessageLogger LOG = CoreLogging.messageLogger( AbstractSaveEventListener.class );
 
 	private CallbackRegistry callbackRegistry;

hibernate-core/src/main/java/org/hibernate/event/internal/AbstractReassociateEventListener.java

@@ -14,25 +14,33 @@
 import org.hibernate.engine.internal.ForeignKeys;
 import org.hibernate.engine.spi.CascadingActions;
 import org.hibernate.engine.spi.EntityEntry;
+import org.hibernate.engine.spi.EntityKey;
 import org.hibernate.engine.spi.PersistenceContext;
 import org.hibernate.engine.spi.SessionImplementor;
+import org.hibernate.engine.spi.Status;
+import org.hibernate.event.spi.AbstractEvent;
 import org.hibernate.event.spi.EventSource;
 import org.hibernate.event.spi.LockEvent;
 import org.hibernate.event.spi.LockEventListener;
 import org.hibernate.internal.CoreMessageLogger;
 import org.hibernate.persister.entity.EntityPersister;
 
+import org.hibernate.type.TypeHelper;
 import org.jboss.logging.Logger;
 
 import java.lang.invoke.MethodHandles;
 
+import static org.hibernate.engine.internal.Versioning.getVersion;
+import static org.hibernate.loader.ast.internal.LoaderHelper.upgradeLock;
+import static org.hibernate.pretty.MessageHelper.infoString;
+
 /**
  * Defines the default lock event listeners used by hibernate to lock entities
  * in response to generated lock events.
  *
  * @author Steve Ebersole
  */
-public class DefaultLockEventListener extends AbstractLockUpgradeEventListener implements LockEventListener {
+public class DefaultLockEventListener implements LockEventListener {
 
 	private static final CoreMessageLogger LOG = Logger.getMessageLogger(
 			MethodHandles.lookup(),
@@ -100,4 +108,58 @@ private void cascadeOnLock(LockEvent event, EntityPersister persister, Object en
 		}
 	}
 
+	/**
+	 * Associates a given entity (either transient or associated with another session)
+	 * to the given session.
+	 *
+	 * @param event The event triggering the re-association
+	 * @param object The entity to be associated
+	 * @param id The id of the entity.
+	 * @param persister The entity's persister instance.
+	 *
+	 * @return An EntityEntry representing the entity within this session.
+	 */
+	protected final EntityEntry reassociate(AbstractEvent event, Object object, Object id, EntityPersister persister) {
+
+		if ( LOG.isTraceEnabled() ) {
+			LOG.tracev(
+					"Reassociating transient instance: {0}",
+					infoString( persister, id, event.getFactory() )
+			);
+		}
+
+		final EventSource source = event.getSession();
+		final EntityKey key = source.generateEntityKey( id, persister );
+		final PersistenceContext persistenceContext = source.getPersistenceContext();
+
+		persistenceContext.checkUniqueness( key, object );
+
+		//get a snapshot
+		final Object[] values = persister.getValues( object );
+		TypeHelper.deepCopy(
+				values,
+				persister.getPropertyTypes(),
+				persister.getPropertyUpdateability(),
+				values,
+				source
+		);
+
+		final EntityEntry newEntry = persistenceContext.addEntity(
+				object,
+				persister.isMutable() ? Status.MANAGED : Status.READ_ONLY,
+				values,
+				key,
+				getVersion( values, persister ),
+				LockMode.NONE,
+				true,
+				persister,
+				false
+		);
+
+		new OnLockVisitor( source, id, object ).process( object, persister );
+
+		persister.afterReassociate( object, source );
+
+		return newEntry;
+	}
 }

hibernate-core/src/main/java/org/hibernate/event/internal/AbstractSaveEventListener.java

@@ -124,9 +124,7 @@ public void onMerge(MergeEvent event, MergeContext copiedAlready) throws Hiberna
 			else if ( isPersistentAttributeInterceptable( original ) ) {
 				final PersistentAttributeInterceptor interceptor =
 						asPersistentAttributeInterceptable( original ).$$_hibernate_getInterceptor();
-				if ( interceptor instanceof EnhancementAsProxyLazinessInterceptor ) {
-					final EnhancementAsProxyLazinessInterceptor proxyInterceptor =
-							(EnhancementAsProxyLazinessInterceptor) interceptor;
+				if ( interceptor instanceof EnhancementAsProxyLazinessInterceptor proxyInterceptor ) {
 					LOG.trace( "Ignoring uninitialized enhanced-proxy" );
 					event.setResult( source.load( proxyInterceptor.getEntityName(), proxyInterceptor.getIdentifier() ) );
 				}
@@ -350,15 +348,14 @@ private static class CollectionVisitor extends WrapVisitor {
 		}
 		@Override
 		protected Object processCollection(Object collection, CollectionType collectionType) {
-			if ( collection instanceof PersistentCollection ) {
-				final PersistentCollection<?> coll = (PersistentCollection<?>) collection;
+			if ( collection instanceof PersistentCollection<?> persistentCollection ) {
 				final CollectionPersister persister =
 						getSession().getFactory().getMappingMetamodel()
 								.getCollectionDescriptor( collectionType.getRole() );
 				final CollectionEntry collectionEntry =
-						getSession().getPersistenceContextInternal().getCollectionEntry( coll );
-				if ( !coll.equalsSnapshot( persister ) ) {
-					collectionEntry.resetStoredSnapshot( coll, coll.getSnapshot( persister ) );
+						getSession().getPersistenceContextInternal().getCollectionEntry( persistentCollection );
+				if ( !persistentCollection.equalsSnapshot( persister ) ) {
+					collectionEntry.resetStoredSnapshot( persistentCollection, persistentCollection.getSnapshot( persister ) );
 				}
 			}
 			return null;

hibernate-core/src/main/java/org/hibernate/event/internal/DefaultLockEventListener.java

@@ -27,9 +27,7 @@
  * @author Eric Dalquist
  * @author Steve Ebersole
  */
-public class DefaultResolveNaturalIdEventListener
-		extends AbstractLockUpgradeEventListener
-		implements ResolveNaturalIdEventListener {
+public class DefaultResolveNaturalIdEventListener implements ResolveNaturalIdEventListener {
 
 	private static final CoreMessageLogger LOG = CoreLogging.messageLogger( DefaultResolveNaturalIdEventListener.class );
 

hibernate-core/src/main/java/org/hibernate/event/internal/DefaultMergeEventListener.java

@@ -46,7 +46,12 @@ public class LoaderHelper {
 	/**
 	 * Ensure the {@linkplain LockMode} associated with the entity in relation to a
 	 * persistence context is {@linkplain LockMode#greaterThan great or equal} to the
-	 * requested mode.
+	 * requested mode, performing a pessimistic lock upgrade on a given entity, if needed.
+	 *
+	 * @param object The entity for which to upgrade the lock.
+	 * @param entry The entity's {@link EntityEntry} instance.
+	 * @param lockOptions Contains the requested lock mode.
+	 * @param session The session which is the source of the event being processed.
 	 */
 	public static void upgradeLock(Object object, EntityEntry entry, LockOptions lockOptions, EventSource session) {
 		final LockMode requestedLockMode = lockOptions.getLockMode();