[JDBC 라이브러리 구현하기 - 4단계] 이리내(성채연) 미션 제출합니다.

jdbc/src/main/java/org/springframework/jdbc/ConnectionHolder.java

@@ -0,0 +1,31 @@
+package org.springframework.jdbc;
+
+import static java.util.Objects.isNull;
+
+import java.sql.Connection;
+
+public class ConnectionHolder {
+
+    private Connection connection;
+    private boolean transactionActive = false;
+
+    public ConnectionHolder(final Connection connection) {
+        this.connection = connection;
+    }
+
+    public void setTransactionActive(final boolean transactionActive) {
+        this.transactionActive = transactionActive;
+    }
+
+    public boolean isTransactionActive() {
+        return transactionActive;
+    }
+
+    public Connection getConnection() {
+        return connection;
+    }
+
+    public boolean has(final Connection connection) {
+        return this.connection == connection;
+    }
+}

jdbc/src/main/java/org/springframework/jdbc/core/JdbcTemplate.java

@@ -29,6 +29,8 @@ private <T> T execute(final PreparedStatementCallback preparedStatementCallback,
             return executionCallback.execute(pstmt);
         } catch (SQLException e) {
             throw new DataAccessException(e);
+        } finally {
+            DataSourceUtils.releaseConnection(connection, dataSource);
         }
     }
 

jdbc/src/main/java/org/springframework/jdbc/datasource/DataSourceUtils.java

@@ -1,6 +1,10 @@
 package org.springframework.jdbc.datasource;
 
+import static java.util.Objects.isNull;
+
+import org.springframework.dao.DataAccessException;
 import org.springframework.jdbc.CannotGetJdbcConnectionException;
+import org.springframework.jdbc.ConnectionHolder;
 import org.springframework.transaction.support.TransactionSynchronizationManager;
 
 import javax.sql.DataSource;
@@ -13,22 +17,57 @@ public abstract class DataSourceUtils {
     private DataSourceUtils() {}
 
     public static Connection getConnection(final DataSource dataSource) throws CannotGetJdbcConnectionException {
-        Connection connection = TransactionSynchronizationManager.getResource(dataSource);
-        if (connection != null) {
-            return connection;
+        final ConnectionHolder connectionHolder = TransactionSynchronizationManager.getResource(dataSource);
+        if (connectionHolder != null) {
+            return connectionHolder.getConnection();
         }
 
         try {
-            connection = dataSource.getConnection();
+            final Connection connection = dataSource.getConnection();
             TransactionSynchronizationManager.bindResource(dataSource, connection);
             return connection;
         } catch (SQLException ex) {
             throw new CannotGetJdbcConnectionException("Failed to obtain JDBC Connection", ex);
         }
     }
 
+    public static void startTransaction(final Connection connection, final DataSource dataSource) {
+        final ConnectionHolder connectionHolder = getConnectionHolder(connection, dataSource);
+        try{
+            connectionHolder.setTransactionActive(true);
+            connection.setAutoCommit(false);
+        }catch(SQLException e) {
+            throw new DataAccessException();
+        }
+    }
+
+    private static ConnectionHolder getConnectionHolder(final Connection connection, final DataSource dataSource) {
+        final ConnectionHolder connectionHolder = TransactionSynchronizationManager.getResource(dataSource);
+        if(isNull(connectionHolder)) {
+            throw new IllegalStateException();
+        }
+        if(!connectionHolder.has(connection)) {
+            throw new IllegalStateException();
+        }
+        return connectionHolder;
+    }
+
+    public static void finishTransaction(final Connection connection, final DataSource dataSource) {
+        final ConnectionHolder connectionHolder = getConnectionHolder(connection, dataSource);
+        try{
+            connection.commit();
+            connectionHolder.setTransactionActive(false);
+        }catch(SQLException e) {
+            throw new DataAccessException();
+        }
+    }
+
     public static void releaseConnection(final Connection connection, final DataSource dataSource) {
         try {
+            final ConnectionHolder connectionHolder = getConnectionHolder(connection, dataSource);
+            if(connectionHolder.isTransactionActive()) {
+                return;
+            }
             TransactionSynchronizationManager.unbindResource(dataSource);
             connection.close();
         } catch (SQLException ex) {

jdbc/src/main/java/org/springframework/transaction/TransactionExecutor.java

@@ -18,11 +18,11 @@ public TransactionExecutor(final DataSource dataSource) {
     public <T> T execute(final Supplier<T> supplier) {
         final Connection connection = DataSourceUtils.getConnection(dataSource);
         try {
-            connection.setAutoCommit(false);
+            DataSourceUtils.startTransaction(connection, dataSource);
             final T t = supplier.get();
-            connection.commit();
+            DataSourceUtils.finishTransaction(connection, dataSource);
             return t;
-        } catch (SQLException | DataAccessException e) {
+        } catch (DataAccessException e) {
             rollback(connection);
             throw new DataAccessException(e);
         } finally {
@@ -33,10 +33,10 @@ public <T> T execute(final Supplier<T> supplier) {
     public void execute(final Runnable runnable) {
         final Connection connection = DataSourceUtils.getConnection(dataSource);
         try {
-            connection.setAutoCommit(false);
+            DataSourceUtils.startTransaction(connection, dataSource);
             runnable.run();
-            connection.commit();
-        } catch (SQLException | DataAccessException e) {
+            DataSourceUtils.finishTransaction(connection, dataSource);
+        } catch (DataAccessException e) {
             rollback(connection);
             throw new DataAccessException(e);
         } finally {

jdbc/src/main/java/org/springframework/transaction/support/TransactionSynchronizationManager.java

@@ -5,27 +5,32 @@
 import javax.sql.DataSource;
 import java.sql.Connection;
 import java.util.Map;
+import org.springframework.jdbc.ConnectionHolder;
 
 public abstract class TransactionSynchronizationManager {
 
-    private static final ThreadLocal<Map<DataSource, Connection>> resources = ThreadLocal.withInitial(HashMap::new);
+    private static final ThreadLocal<Map<DataSource, ConnectionHolder>> resources = ThreadLocal.withInitial(HashMap::new);
 
     private TransactionSynchronizationManager() {}
 
     @Nullable
-    public static Connection getResource(final DataSource key) {
+    public static ConnectionHolder getResource(final DataSource key) {
         return getResources().getOrDefault(key, null);
     }
 
     public static void bindResource(final DataSource key, final Connection value) {
-        getResources().put(key, value);
+        final Map<DataSource, ConnectionHolder> resources = getResources();
+        if(resources.containsKey(key)){
+            throw new IllegalStateException();
+        }
+        resources.put(key, new ConnectionHolder(value));
     }
 
-    public static Connection unbindResource(final DataSource key) {
+    public static ConnectionHolder unbindResource(final DataSource key) {
         return getResources().remove(key);
     }
 
-    private static Map<DataSource, Connection> getResources() {
+    private static Map<DataSource, ConnectionHolder> getResources() {
         return resources.get();
     }
 }