HHH-19559 some related refactoring

Author: gavinking

hibernate-core/src/main/java/org/hibernate/engine/jdbc/env/internal/JdbcEnvironmentInitiator.java

@@ -806,5 +806,13 @@ public boolean isActive() {
 		public SqlExceptionHelper getSqlExceptionHelper() {
 			return sqlExceptionHelper;
 		}
+
+		@Override
+		public void afterObtainConnection(Connection connection) {
+		}
+
+		@Override
+		public void beforeReleaseConnection(Connection connection) {
+		}
 	}
 }

hibernate-core/src/main/java/org/hibernate/engine/jdbc/internal/JdbcCoordinatorImpl.java

@@ -76,23 +76,20 @@ public JdbcCoordinatorImpl(
 			Connection userSuppliedConnection,
 			JdbcSessionOwner owner,
 			JdbcServices jdbcServices) {
+		this.owner = owner;
+		this.jdbcServices = jdbcServices;
 		this.isUserSuppliedConnection = userSuppliedConnection != null;
+		this.logicalConnection = createLogicalConnection( userSuppliedConnection, owner );
+	}
 
+	private static LogicalConnectionImplementor createLogicalConnection(
+			Connection userSuppliedConnection,
+			JdbcSessionOwner owner) {
 		final ResourceRegistry resourceRegistry =
 				new ResourceRegistryStandardImpl( owner.getJdbcSessionContext().getEventHandler() );
-		if ( isUserSuppliedConnection ) {
-			this.logicalConnection = new LogicalConnectionProvidedImpl( userSuppliedConnection, resourceRegistry );
-		}
-		else {
-			this.logicalConnection = new LogicalConnectionManagedImpl(
-					owner.getJdbcConnectionAccess(),
-					owner.getJdbcSessionContext(),
-					owner.getSqlExceptionHelper(),
-					resourceRegistry
-			);
-		}
-		this.owner = owner;
-		this.jdbcServices = jdbcServices;
+		return userSuppliedConnection == null
+				? new LogicalConnectionManagedImpl( owner, resourceRegistry )
+				: new LogicalConnectionProvidedImpl( userSuppliedConnection, resourceRegistry );
 	}
 
 	private JdbcCoordinatorImpl(
@@ -405,7 +402,7 @@ public JdbcResourceTransaction getResourceLocalTransaction() {
 	 */
 	@Override
 	public void serialize(ObjectOutputStream oos) throws IOException {
-		if ( ! isReadyForSerialization() ) {
+		if ( !isReadyForSerialization() ) {
 			throw new HibernateException( "Cannot serialize Session while connected" );
 		}
 		oos.writeBoolean( isUserSuppliedConnection );
@@ -423,21 +420,13 @@ public void serialize(ObjectOutputStream oos) throws IOException {
 	 * @throws IOException Trouble accessing the stream
 	 * @throws ClassNotFoundException Trouble reading the stream
 	 */
-	public static JdbcCoordinatorImpl deserialize(
-			ObjectInputStream ois,
-			JdbcSessionOwner owner) throws IOException, ClassNotFoundException {
+	public static JdbcCoordinatorImpl deserialize(ObjectInputStream ois, JdbcSessionOwner owner)
+			throws IOException, ClassNotFoundException {
 		final boolean isUserSuppliedConnection = ois.readBoolean();
-		final LogicalConnectionImplementor logicalConnection;
-		if ( isUserSuppliedConnection ) {
-			logicalConnection = LogicalConnectionProvidedImpl.deserialize( ois );
-		}
-		else {
-			logicalConnection = LogicalConnectionManagedImpl.deserialize(
-					ois,
-					owner.getJdbcConnectionAccess(),
-					owner.getJdbcSessionContext()
-			);
-		}
+		final var logicalConnection =
+				isUserSuppliedConnection
+						? LogicalConnectionProvidedImpl.deserialize( ois )
+						: LogicalConnectionManagedImpl.deserialize( ois, owner );
 		return new JdbcCoordinatorImpl( logicalConnection, isUserSuppliedConnection, owner );
 	}
 }

hibernate-core/src/main/java/org/hibernate/engine/spi/SharedSessionContractImplementor.java

@@ -4,8 +4,6 @@
  */
 package org.hibernate.engine.spi;
 
-import java.sql.Connection;
-import java.sql.SQLException;
 import java.util.Set;
 import java.util.UUID;
 import jakarta.persistence.TransactionRequiredException;
@@ -574,31 +572,4 @@ default boolean isStatelessSession() {
 	 */
 	@Incubating
 	Object loadFromSecondLevelCache(EntityPersister persister, EntityKey entityKey, Object instanceToLoad, LockMode lockMode);
-
-	/**
-	 * Called after a non-contextual JDBC connection is obtained.
-	 * <p>
-	 * Sets the schema to the schema belonging to the current tenant if:
-	 * <ol>
-	 * <li>{@value org.hibernate.cfg.MultiTenancySettings#SET_TENANT_SCHEMA} is enabled, and
-	 * <li>this session has an active tenant id.
-	 * </ol>
-	 *
-	 * @param connection A JDBC connection which was just acquired
-	 *
-	 * @since 7.1
-	 */
-	void afterObtainConnection(Connection connection) throws SQLException;
-
-	/**
-	 * Called right before non-contextual a JDBC connection is released.
-	 * <p>
-	 * Unset the schema which was set by {@link #afterObtainConnection},
-	 * if any.
-	 * .
-	 * @param connection The JDBC connection which is about to be released
-	 *
-	 * @since 7.1
-	 */
-	void beforeReleaseConnection(Connection connection) throws SQLException;
 }

hibernate-core/src/main/java/org/hibernate/internal/ContextualJdbcConnectionAccess.java

@@ -44,17 +44,13 @@ public Connection obtainConnection() throws SQLException {
 		}
 
 		final EventMonitor eventMonitor = session.getEventMonitor();
-		final DiagnosticEvent jdbcConnectionAcquisitionEvent = eventMonitor.beginJdbcConnectionAcquisitionEvent();
+		final DiagnosticEvent connectionAcquisitionEvent = eventMonitor.beginJdbcConnectionAcquisitionEvent();
 		try {
 			listener.jdbcConnectionAcquisitionStart();
 			return connectionProvider.getConnection( tenantIdentifier );
 		}
 		finally {
-			eventMonitor.completeJdbcConnectionAcquisitionEvent(
-					jdbcConnectionAcquisitionEvent,
-					session,
-					tenantIdentifier
-			);
+			eventMonitor.completeJdbcConnectionAcquisitionEvent( connectionAcquisitionEvent, session, tenantIdentifier );
 			listener.jdbcConnectionAcquisitionEnd();
 		}
 	}
@@ -66,13 +62,13 @@ public void releaseConnection(Connection connection) throws SQLException {
 		}
 
 		final EventMonitor eventMonitor = session.getEventMonitor();
-		final DiagnosticEvent jdbcConnectionReleaseEvent = eventMonitor.beginJdbcConnectionReleaseEvent();
+		final DiagnosticEvent connectionReleaseEvent = eventMonitor.beginJdbcConnectionReleaseEvent();
 		try {
 			listener.jdbcConnectionReleaseStart();
 			connectionProvider.releaseConnection( tenantIdentifier, connection );
 		}
 		finally {
-			eventMonitor.completeJdbcConnectionReleaseEvent( jdbcConnectionReleaseEvent, session, tenantIdentifier );
+			eventMonitor.completeJdbcConnectionReleaseEvent( connectionReleaseEvent, session, tenantIdentifier );
 			listener.jdbcConnectionReleaseEnd();
 		}
 	}

hibernate-core/src/main/java/org/hibernate/internal/NonContextualJdbcConnectionAccess.java

@@ -41,18 +41,14 @@ public NonContextualJdbcConnectionAccess(
 	@Override
 	public Connection obtainConnection() throws SQLException {
 		final EventMonitor eventMonitor = session.getEventMonitor();
-		final DiagnosticEvent jdbcConnectionAcquisitionEvent = eventMonitor.beginJdbcConnectionAcquisitionEvent();
+		final DiagnosticEvent connectionAcquisitionEvent = eventMonitor.beginJdbcConnectionAcquisitionEvent();
 		final Connection connection;
 		try {
 			listener.jdbcConnectionAcquisitionStart();
 			connection = connectionProvider.getConnection();
 		}
 		finally {
-			eventMonitor.completeJdbcConnectionAcquisitionEvent(
-					jdbcConnectionAcquisitionEvent,
-					session,
-					null
-			);
+			eventMonitor.completeJdbcConnectionAcquisitionEvent( connectionAcquisitionEvent, session, null );
 			listener.jdbcConnectionAcquisitionEnd();
 		}
 
@@ -81,13 +77,13 @@ public void releaseConnection(Connection connection) throws SQLException {
 		}
 
 		final EventMonitor eventMonitor = session.getEventMonitor();
-		final DiagnosticEvent jdbcConnectionReleaseEvent = eventMonitor.beginJdbcConnectionReleaseEvent();
+		final DiagnosticEvent connectionReleaseEvent = eventMonitor.beginJdbcConnectionReleaseEvent();
 		try {
 			listener.jdbcConnectionReleaseStart();
 			connectionProvider.closeConnection( connection );
 		}
 		finally {
-			eventMonitor.completeJdbcConnectionReleaseEvent( jdbcConnectionReleaseEvent, session, null );
+			eventMonitor.completeJdbcConnectionReleaseEvent( connectionReleaseEvent, session, null );
 			listener.jdbcConnectionReleaseEnd();
 		}
 	}

hibernate-core/src/main/java/org/hibernate/resource/jdbc/internal/LogicalConnectionManagedImpl.java

@@ -20,6 +20,7 @@
 import org.hibernate.resource.jdbc.ResourceRegistry;
 import org.hibernate.resource.jdbc.spi.JdbcEventHandler;
 import org.hibernate.resource.jdbc.spi.JdbcSessionContext;
+import org.hibernate.resource.jdbc.spi.JdbcSessionOwner;
 import org.hibernate.resource.jdbc.spi.PhysicalConnectionHandlingMode;
 
 import static org.hibernate.ConnectionAcquisitionMode.IMMEDIATELY;
@@ -56,21 +57,17 @@ public LogicalConnectionManagedImpl(
 			SqlExceptionHelper sqlExceptionHelper,
 			ResourceRegistry resourceRegistry) {
 		this.jdbcConnectionAccess = jdbcConnectionAccess;
-		this.jdbcEventHandler = jdbcSessionContext.getEventHandler();
-		this.resourceRegistry = resourceRegistry;
-
-		this.connectionHandlingMode = determineConnectionHandlingMode(
-				jdbcSessionContext.getPhysicalConnectionHandlingMode(),
-				jdbcConnectionAccess );
-
 		this.sqlExceptionHelper = sqlExceptionHelper;
+		this.resourceRegistry = resourceRegistry;
+		jdbcEventHandler = jdbcSessionContext.getEventHandler();
 
+		connectionHandlingMode = determineConnectionHandlingMode( jdbcSessionContext, jdbcConnectionAccess );
 		if ( connectionHandlingMode.getAcquisitionMode() == IMMEDIATELY ) {
 			//noinspection resource
 			acquireConnectionIfNeeded();
 		}
 
-		this.providerDisablesAutoCommit = jdbcSessionContext.doesConnectionProviderDisableAutoCommit();
+		providerDisablesAutoCommit = jdbcSessionContext.doesConnectionProviderDisableAutoCommit();
 		if ( providerDisablesAutoCommit ) {
 			log.connectionProviderDisablesAutoCommitEnabled();
 		}
@@ -89,9 +86,19 @@ public LogicalConnectionManagedImpl(
 		);
 	}
 
+	public LogicalConnectionManagedImpl(JdbcSessionOwner owner, ResourceRegistry resourceRegistry) {
+		this(
+				owner.getJdbcConnectionAccess(),
+				owner.getJdbcSessionContext(),
+				owner.getSqlExceptionHelper(),
+				resourceRegistry
+		);
+	}
+
 	private PhysicalConnectionHandlingMode determineConnectionHandlingMode(
-			PhysicalConnectionHandlingMode connectionHandlingMode,
+			JdbcSessionContext jdbcSessionContext,
 			JdbcConnectionAccess jdbcConnectionAccess) {
+		final var connectionHandlingMode = jdbcSessionContext.getPhysicalConnectionHandlingMode();
 		return connectionHandlingMode.getReleaseMode() == AFTER_STATEMENT
 			&& !jdbcConnectionAccess.supportsAggressiveRelease()
 				? DELAYED_ACQUISITION_AND_RELEASE_AFTER_TRANSACTION
@@ -175,7 +182,7 @@ public void beforeTransactionCompletion() {
 	public void afterTransaction() {
 		super.afterTransaction();
 		if ( connectionHandlingMode.getReleaseMode() != ON_CLOSE ) {
-			// NOTE : we check for !ON_CLOSE here (rather than AFTER_TRANSACTION) to also catch:
+			// NOTE: we check for !ON_CLOSE here (rather than AFTER_TRANSACTION) to also catch:
 			// - AFTER_STATEMENT cases that were circumvented due to held resources
 			// - BEFORE_TRANSACTION_COMPLETION cases that were circumvented because a rollback occurred
 			//   (we don't get a beforeTransactionCompletion event on rollback).
@@ -241,11 +248,17 @@ public void serialize(ObjectOutputStream oos) throws IOException {
 	public static LogicalConnectionManagedImpl deserialize(
 			ObjectInputStream ois,
 			JdbcConnectionAccess jdbcConnectionAccess,
-			JdbcSessionContext jdbcSessionContext) throws IOException {
+			JdbcSessionContext jdbcSessionContext)
+			throws IOException {
 		final boolean isClosed = ois.readBoolean();
 		return new LogicalConnectionManagedImpl( jdbcConnectionAccess, jdbcSessionContext, isClosed );
 	}
 
+	public static LogicalConnectionManagedImpl deserialize(ObjectInputStream ois, JdbcSessionOwner owner)
+			throws IOException {
+		return deserialize( ois, owner.getJdbcConnectionAccess(), owner.getJdbcSessionContext() );
+	}
+
 	@Override
 	public Connection close() {
 		if ( !closed ) {

hibernate-core/src/main/java/org/hibernate/resource/jdbc/spi/JdbcSessionOwner.java

@@ -10,6 +10,9 @@
 import org.hibernate.event.monitor.spi.EventMonitor;
 import org.hibernate.resource.transaction.spi.TransactionCoordinator;
 
+import java.sql.Connection;
+import java.sql.SQLException;
+
 import static java.lang.reflect.InvocationHandler.invokeDefault;
 import static java.lang.reflect.Proxy.newProxyInstance;
 
@@ -78,6 +81,33 @@ default SqlExceptionHelper getSqlExceptionHelper() {
 		return getJdbcSessionContext().getJdbcServices().getSqlExceptionHelper();
 	}
 
+	/**
+	 * Called after a managed JDBC connection is obtained.
+	 * <p>
+	 * Sets the schema to the schema belonging to the current tenant if:
+	 * <ol>
+	 * <li>{@value org.hibernate.cfg.MultiTenancySettings#SET_TENANT_SCHEMA} is enabled, and
+	 * <li>this session has an active tenant id.
+	 * </ol>
+	 *
+	 * @param connection A JDBC connection which was just acquired
+	 *
+	 * @since 7.1
+	 */
+	void afterObtainConnection(Connection connection) throws SQLException;
+
+	/**
+	 * Called right before a managed JDBC connection is released.
+	 * <p>
+	 * Unset the schema which was set by {@link #afterObtainConnection},
+	 * if any.
+	 * .
+	 * @param connection The JDBC connection which is about to be released
+	 *
+	 * @since 7.1
+	 */
+	void beforeReleaseConnection(Connection connection) throws SQLException;
+
 	/**
 	 * Obtain a reference to the {@link EventMonitor}.
 	 *

hibernate-jfr/src/main/java/org/hibernate/event/jfr/internal/JfrEventMonitor.java

@@ -780,10 +780,7 @@ public void completeCollectionRemoveEvent(
 	}
 
 	private String getSessionIdentifier(SharedSessionContractImplementor session) {
-		if ( session == null ) {
-			return null;
-		}
-		return session.getSessionIdentifier().toString();
+		return session == null ? null : session.getSessionIdentifier().toString();
 	}
 
 	private String getEntityName(EntityPersister persister) {