Handle: unconditionally close Connection

Right now, we check if a connection is closed before closing it.

However, this isn't good enough: even if the server closed the connection,
we might have borrowed this from a pool, which needs to know we've returned it.

Connection.close is specified to no-op if called more than once, so it's safe to just do it regardless.

Fixes #2446

core/src/main/java/org/jdbi/v3/core/ConnectionFactory.java

@@ -45,6 +45,7 @@ default void closeConnection(Connection conn) throws SQLException {
 
     /**
      * Returns a {@link Cleanable} that will close the connection and release all necessary resources.
+     * Like {@link Connection#close()}, the Cleanable should no-op if called more than once.
      *
      * @param conn A {@link Connection} object.
      * @return A {@link Cleanable} instance. Calling the {@link Cleanable#close()} method will close the connection and release all resources.

core/src/main/java/org/jdbi/v3/core/Handle.java

@@ -115,12 +115,8 @@ private Handle(Jdbi jdbi,
         this.transactionHandler = transactionHandler.specialize(this);
         this.forceEndTransactions = !transactionHandler.isInTransaction(this);
 
-        addCleanable(() -> {
-            // shut down statement builder
-            if (checkConnectionIsLive()) {
-                statementBuilder.close(connection);
-            }
-        });
+        addCleanable(() ->
+            statementBuilder.close(connection));
     }
 
     /**
@@ -897,52 +893,43 @@ private void notifyHandleClosed() {
     private void cleanConnection(boolean doForceEndTransactions) {
 
         final ThrowableSuppressor throwableSuppressor = new ThrowableSuppressor();
-        final boolean connectionIsLive = checkConnectionIsLive();
 
         boolean wasInTransaction = false;
 
-        if (connectionIsLive && doForceEndTransactions) {
-            wasInTransaction = throwableSuppressor.suppressAppend(this::isInTransaction, false);
+        if (doForceEndTransactions) {
+            wasInTransaction = throwableSuppressor.suppressAppend(() -> {
+                if (connection.isClosed()) {
+                    return false;
+                }
+                return isInTransaction();
+            }, false);
         }
 
         if (wasInTransaction) {
             throwableSuppressor.suppressAppend(this::rollback);
         }
 
-        if (connectionIsLive) {
-            try {
-                connectionCleaner.close();
-            } catch (SQLException e) {
-                CloseException ce = new CloseException("Unable to close Connection", e);
-                throwableSuppressor.attachToThrowable(ce);
-                throw ce;
-            }
-
-            throwableSuppressor.throwIfNecessary(t -> new CloseException("Failed to clear transaction status on close", t));
-
-            if (wasInTransaction) {
-                TransactionException te = new TransactionException("Improper transaction handling detected: A Handle with an open "
-                        + "transaction was closed. Transactions must be explicitly committed or rolled back "
-                        + "before closing the Handle. "
-                        + "Jdbi has rolled back this transaction automatically. "
-                        + "This check may be disabled by calling getConfig(Handles.class).setForceEndTransactions(false).");
-
-                throwableSuppressor.attachToThrowable(te); // any exception present is not the cause but just collateral.
-                throw te;
-            }
-        } else {
-            throwableSuppressor.throwIfNecessary(t -> new CloseException("Failed to clear transaction status on close", t));
-        }
-    }
-
-    private boolean checkConnectionIsLive() {
         try {
-            return !connection.isClosed();
+            connectionCleaner.close();
         } catch (SQLException e) {
-            // if the connection state can not be determined, assume that the
-            // connection is closed and ignore the exception
-            return false;
+            CloseException ce = new CloseException("Unable to close Connection", e);
+            throwableSuppressor.attachToThrowable(ce);
+            throw ce;
+        }
+
+        throwableSuppressor.throwIfNecessary(t -> new CloseException("Failed to clear transaction status on close", t));
+
+        if (wasInTransaction) {
+            TransactionException te = new TransactionException("Improper transaction handling detected: A Handle with an open "
+                    + "transaction was closed. Transactions must be explicitly committed or rolled back "
+                    + "before closing the Handle. "
+                    + "Jdbi has rolled back this transaction automatically. "
+                    + "This check may be disabled by calling getConfig(Handles.class).setForceEndTransactions(false).");
+
+            throwableSuppressor.attachToThrowable(te); // any exception present is not the cause but just collateral.
+            throw te;
         }
+        throwableSuppressor.throwIfNecessary(t -> new CloseException("Failed to clear transaction status on close", t));
     }
 
     @Override