HHH-19559 light refactoring of LogicalConnectionManagedImpl

Author: gavinking

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

@@ -11,11 +11,13 @@
 import java.sql.SQLException;
 
 import org.hibernate.ResourceClosedException;
+import org.hibernate.engine.jdbc.connections.spi.JdbcConnectionAccess;
+import org.hibernate.engine.jdbc.spi.SqlExceptionHelper;
 import org.hibernate.internal.CoreLogging;
 import org.hibernate.internal.CoreMessageLogger;
 import org.hibernate.resource.jdbc.LogicalConnection;
 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;
 
@@ -70,41 +72,41 @@ private LogicalConnectionManagedImpl(JdbcSessionOwner owner, boolean closed) {
 		this.closed = closed;
 	}
 
-	private Connection acquireConnectionIfNeeded() {
-		if ( physicalConnection == null ) {
-			final JdbcEventHandler eventHandler = jdbcSessionOwner.getJdbcSessionContext().getEventHandler();
-			eventHandler.jdbcConnectionAcquisitionStart();
-			try {
-				physicalConnection = jdbcSessionOwner.getJdbcConnectionAccess().obtainConnection();
-			}
-			catch ( SQLException e ) {
-				throw jdbcSessionOwner.getSqlExceptionHelper()
-						.convert( e, "Unable to acquire JDBC Connection" );
-			}
-			finally {
-				eventHandler.jdbcConnectionAcquisitionEnd( physicalConnection );
-			}
+	private JdbcSessionContext getJdbcSessionContext() {
+		return jdbcSessionOwner.getJdbcSessionContext();
+	}
 
-			try {
-				jdbcSessionOwner.afterObtainConnection( physicalConnection );
-			}
-			catch (SQLException e) {
-				try {
-					// given the session a chance to set the schema
-					jdbcSessionOwner.getJdbcConnectionAccess().releaseConnection( physicalConnection );
-				}
-				catch (SQLException re) {
-					e.addSuppressed( re );
-				}
-				throw jdbcSessionOwner.getSqlExceptionHelper()
-						.convert( e, "Error after acquiring JDBC Connection" );
-			}
+	private JdbcConnectionAccess getJdbcConnectionAccess() {
+		return jdbcSessionOwner.getJdbcConnectionAccess();
+	}
 
-		}
+	private SqlExceptionHelper getExceptionHelper() {
+		return jdbcSessionOwner.getSqlExceptionHelper();
+	}
 
+	private Connection acquireConnectionIfNeeded() {
+		if ( physicalConnection == null ) {
+			physicalConnection = acquire();
+			afterAcquire();
+		}
 		return physicalConnection;
 	}
 
+	private void releaseConnectionIfNeeded() {
+		final Connection connection = physicalConnection;
+		if ( connection != null ) {
+			beforeRelease();
+			// Set the connection to null before releasing resources to prevent
+			// recursion into this method. Recursion can happen when we release
+			// resources and when batch statements are in progress: releasing
+			// resources aborts the batch statement, which then triggers
+			// logicalConnection.afterStatement(), which in some configurations
+			// releases the connection.
+			physicalConnection = null;
+			release( connection );
+		}
+	}
+
 	@Override
 	public boolean isOpen() {
 		return !closed;
@@ -135,7 +137,7 @@ public void afterStatement() {
 			}
 			else {
 				log.debug( "Initiating JDBC connection release from afterStatement" );
-				releaseConnection();
+				releaseConnectionIfNeeded();
 			}
 		}
 	}
@@ -145,7 +147,7 @@ public void beforeTransactionCompletion() {
 		super.beforeTransactionCompletion();
 		if ( connectionHandlingMode.getReleaseMode() == BEFORE_TRANSACTION_COMPLETION ) {
 			log.debug( "Initiating JDBC connection release from beforeTransactionCompletion" );
-			releaseConnection();
+			releaseConnectionIfNeeded();
 		}
 	}
 
@@ -158,7 +160,7 @@ public void afterTransaction() {
 			// - BEFORE_TRANSACTION_COMPLETION cases that were circumvented because a rollback occurred
 			//   (we don't get a beforeTransactionCompletion event on rollback).
 			log.debug( "Initiating JDBC connection release from afterTransaction" );
-			releaseConnection();
+			releaseConnectionIfNeeded();
 		}
 	}
 
@@ -168,7 +170,7 @@ public Connection manualDisconnect() {
 			throw new ResourceClosedException( "Logical connection is closed" );
 		}
 		final Connection connection = physicalConnection;
-		releaseConnection();
+		releaseConnectionIfNeeded();
 		return connection;
 	}
 
@@ -180,44 +182,65 @@ public void manualReconnect(Connection suppliedConnection) {
 		throw new IllegalStateException( "Cannot manually reconnect unless Connection was originally supplied by user" );
 	}
 
-	private void releaseConnection() {
-		final Connection localVariableConnection = physicalConnection;
-		if ( localVariableConnection != null ) {
+	private Connection acquire() {
+		final var eventHandler = getJdbcSessionContext().getEventHandler();
+		eventHandler.jdbcConnectionAcquisitionStart();
+		try {
+			return getJdbcConnectionAccess().obtainConnection();
+		}
+		catch ( SQLException e ) {
+			throw getExceptionHelper().convert( e, "Unable to acquire JDBC Connection" );
+		}
+		finally {
+			eventHandler.jdbcConnectionAcquisitionEnd( physicalConnection );
+		}
+	}
+
+	private void release(Connection connection) {
+		final var eventHandler = getJdbcSessionContext().getEventHandler();
+		try {
 			try {
-				// give the session a chance to change the schema back to null
-				jdbcSessionOwner.beforeReleaseConnection( physicalConnection );
+				getResourceRegistry().releaseResources();
+				if ( !connection.isClosed() ) {
+					getExceptionHelper().logAndClearWarnings( connection );
+				}
 			}
-			catch (SQLException e) {
-				log.warn( "Error before releasing JDBC connection", e );
+			finally {
+				eventHandler.jdbcConnectionReleaseStart();
+				getJdbcConnectionAccess().releaseConnection( connection );
 			}
+		}
+		catch (SQLException e) {
+			throw getExceptionHelper().convert( e, "Unable to release JDBC Connection" );
+		}
+		finally {
+			eventHandler.jdbcConnectionReleaseEnd();
+		}
+	}
 
-			final JdbcEventHandler eventHandler = jdbcSessionOwner.getJdbcSessionContext().getEventHandler();
-			// We need to set the connection to null before we release resources,
-			// in order to prevent recursion into this method.
-			// Recursion can happen when we release resources and when batch statements are in progress:
-			// when releasing resources, we'll abort the batch statement,
-			// which will trigger "logicalConnection.afterStatement()",
-			// which in some configurations will release the connection.
-			physicalConnection = null;
+	private void afterAcquire() {
+		try {
+			// give the session a chance to set the schema
+			jdbcSessionOwner.afterObtainConnection( physicalConnection );
+		}
+		catch (SQLException e) {
 			try {
-				try {
-					getResourceRegistry().releaseResources();
-					if ( !localVariableConnection.isClosed() ) {
-						jdbcSessionOwner.getSqlExceptionHelper().logAndClearWarnings( localVariableConnection );
-					}
-				}
-				finally {
-					eventHandler.jdbcConnectionReleaseStart();
-					jdbcSessionOwner.getJdbcConnectionAccess().releaseConnection( localVariableConnection );
-				}
+				getJdbcConnectionAccess().releaseConnection( physicalConnection );
 			}
-			catch (SQLException e) {
-				throw jdbcSessionOwner.getSqlExceptionHelper()
-						.convert( e, "Unable to release JDBC Connection" );
-			}
-			finally {
-				eventHandler.jdbcConnectionReleaseEnd();
+			catch (SQLException re) {
+				e.addSuppressed( re );
 			}
+			throw getExceptionHelper().convert( e, "Error after acquiring JDBC Connection" );
+		}
+	}
+
+	private void beforeRelease() {
+		try {
+			// give the session a chance to change the schema back to null
+			jdbcSessionOwner.beforeReleaseConnection( physicalConnection );
+		}
+		catch (SQLException e) {
+			log.warn( "Error before releasing JDBC connection", e );
 		}
 	}
 
@@ -237,7 +260,7 @@ public Connection close() {
 			getResourceRegistry().releaseResources();
 			log.closingLogicalConnection();
 			try {
-				releaseConnection();
+				releaseConnectionIfNeeded();
 			}
 			finally {
 				// no matter what
@@ -260,8 +283,9 @@ protected Connection getConnectionForTransactionManagement() {
 
 	@Override
 	public void begin() {
-		initiallyAutoCommit = !doConnectionsFromProviderHaveAutoCommitDisabled()
-				&& determineInitialAutoCommitMode( getConnectionForTransactionManagement() );
+		initiallyAutoCommit =
+				!doConnectionsFromProviderHaveAutoCommitDisabled()
+						&& determineInitialAutoCommitMode( getConnectionForTransactionManagement() );
 		super.begin();
 	}
 
@@ -274,6 +298,6 @@ protected void afterCompletion() {
 
 	@Override
 	protected boolean doConnectionsFromProviderHaveAutoCommitDisabled() {
-		return jdbcSessionOwner.getJdbcSessionContext().doesConnectionProviderDisableAutoCommit();
+		return getJdbcSessionContext().doesConnectionProviderDisableAutoCommit();
 	}
 }