[JDBC 라이브러리 구현 3,4단계] 리오(오영택) 미션 제출합니다.

app/src/main/java/com/techcourse/service/TxUserService.java

@@ -3,6 +3,8 @@
 import com.techcourse.domain.User;
 import org.springframework.transaction.support.TransactionTemplate;
 
+import java.util.concurrent.atomic.AtomicReference;
+
 public class TxUserService implements UserService {
 
     private final UserService userService;
@@ -15,7 +17,9 @@ public TxUserService(UserService userService, TransactionTemplate transactionTem
 
     @Override
     public User findById(long id) {
-        return userService.findById(id);
+        AtomicReference<User> user = new AtomicReference<>();
+        transactionTemplate.execute(() -> user.set(userService.findById(id)));
+        return user.get();
     }
 
     @Override

app/src/main/java/com/techcourse/support/jdbc/init/DatabasePopulatorUtils.java

@@ -19,7 +19,6 @@ public static void execute(DataSource dataSource) {
             URL url = DatabasePopulatorUtils.class.getClassLoader().getResource("schema.sql");
             File file = new File(url.getFile());
             String sql = Files.readString(file.toPath());
-
             JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
             jdbcTemplate.execute(sql);
         } catch (IOException | NullPointerException e) {

app/src/test/java/com/techcourse/service/AppUserServiceTest.java

@@ -21,7 +21,6 @@ class AppUserServiceTest {
     void setUp() {
         this.jdbcTemplate = new JdbcTemplate(DataSourceConfig.getInstance());
         this.userDao = new UserDao(jdbcTemplate);
-
         DatabasePopulatorUtils.execute(DataSourceConfig.getInstance());
         userDao.deleteAll();
 

app/src/test/java/com/techcourse/service/MockUserHistoryDao.java

@@ -2,7 +2,7 @@
 
 import com.techcourse.dao.UserHistoryDao;
 import com.techcourse.domain.UserHistory;
-import org.springframework.dao.DataAccessException;
+import org.springframework.DataAccessException;
 import org.springframework.jdbc.core.JdbcTemplate;
 
 public class MockUserHistoryDao extends UserHistoryDao {
@@ -13,6 +13,7 @@ public MockUserHistoryDao(final JdbcTemplate jdbcTemplate) {
 
     @Override
     public void log(final UserHistory userHistory) {
+        System.out.println("asdf");
         throw new DataAccessException();
     }
 }

app/src/test/java/com/techcourse/service/TxUserServiceTest.java

@@ -6,7 +6,7 @@
 import com.techcourse.support.jdbc.init.DatabasePopulatorUtils;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
-import org.springframework.jdbc.CannotGetJdbcConnectionException;
+import org.springframework.DataAccessException;
 import org.springframework.jdbc.core.JdbcTemplate;
 import org.springframework.transaction.support.TransactionTemplate;
 
@@ -25,13 +25,15 @@ class TxUserServiceTest {
     @BeforeEach
     void setUp() {
         DataSource dataSource = DataSourceConfig.getInstance();
+
+        DatabasePopulatorUtils.execute(dataSource);
         this.jdbcTemplate = new JdbcTemplate(dataSource);
         this.userDao = new UserDao(jdbcTemplate);
         this.transactionTemplate = new TransactionTemplate(dataSource);
 
-        DatabasePopulatorUtils.execute(dataSource);
         userDao.deleteAll();
 
+
         final var user = new User("gugu", "password", "[email protected]");
         userDao.insert(user);
         this.user = userDao.findByAccount("gugu");
@@ -46,8 +48,8 @@ void testTransactionRollback() {
         final var newPassword = "newPassword";
         final var createBy = "gugu";
 
-        assertThrows(CannotGetJdbcConnectionException.class,
-                () -> userService.changePassword(1L, newPassword, createBy));
+        assertThrows(DataAccessException.class,
+                () -> userService.changePassword(user.getId(), newPassword, createBy));
 
         final var actual = userService.findById(user.getId());
 

jdbc/src/main/java/org/springframework/dao/DataAccessException.java → jdbc/src/main/java/org/springframework/DataAccessException.java

@@ -1,4 +1,4 @@
-package org.springframework.dao;
+package org.springframework;
 
 public class DataAccessException extends RuntimeException {
 

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

@@ -2,14 +2,11 @@
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
-import org.springframework.dao.DataAccessException;
+import org.springframework.DataAccessException;
+import org.springframework.jdbc.datasource.DataSourceUtils;
 
 import javax.sql.DataSource;
-import java.sql.Connection;
-import java.sql.PreparedStatement;
-import java.sql.ResultSet;
-import java.sql.SQLException;
-import java.sql.Statement;
+import java.sql.*;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Optional;
@@ -25,25 +22,27 @@ public JdbcTemplate(DataSource dataSource) {
     }
 
     public void update(String sql, Object... values) {
-        try (
-                Connection connection = dataSource.getConnection();
-                PreparedStatement pstmt = connection.prepareStatement(sql);
-        ) {
-            log.debug("query : {}", sql);
+        Connection connection = DataSourceUtils.getConnection(dataSource);
 
+        try {
+            PreparedStatement pstmt = connection.prepareStatement(sql);
+            log.debug("query : {}", sql);
             setValues(pstmt, values);
             pstmt.executeUpdate();
         } catch (SQLException e) {
             log.error(e.getMessage(), e);
             throw new DataAccessException(e);
+        } finally {
+            DataSourceUtils.releaseConnection(connection);
         }
     }
 
     public <T> List<T> query(String sql, RowMapper<T> rowMapper, Object... values) {
-        try (
-                Connection connection = dataSource.getConnection();
-                PreparedStatement pstmt = connection.prepareStatement(sql);
-        ) {
+        Connection connection = DataSourceUtils.getConnection(dataSource);
+
+        try {
+            PreparedStatement pstmt = connection.prepareStatement(sql);
+
             log.debug("query : {}", sql);
 
             setValues(pstmt, values);
@@ -57,6 +56,8 @@ public <T> List<T> query(String sql, RowMapper<T> rowMapper, Object... values) {
         } catch (SQLException e) {
             log.error(e.getMessage(), e);
             throw new DataAccessException(e);
+        } finally {
+            DataSourceUtils.releaseConnection(connection);
         }
     }
 
@@ -74,16 +75,19 @@ public <T> Optional<T> queryForObject(String sql, RowMapper<T> rowMapper, Object
     }
 
     public void execute(String sql) {
-        try (
-                Connection connection = dataSource.getConnection();
-                Statement stmt = connection.createStatement();
-        ) {
+        Connection connection = DataSourceUtils.getConnection(dataSource);
+
+        try {
+            Statement stmt = connection.createStatement();
+
             log.debug("query : {}", sql);
 
             stmt.execute(sql);
         } catch (SQLException e) {
             log.error(e.getMessage(), e);
             throw new DataAccessException(e);
+        } finally {
+            DataSourceUtils.releaseConnection(connection);
         }
     }
 

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

@@ -11,28 +11,29 @@ public abstract class DataSourceUtils {
 
     private DataSourceUtils() {}
 
-    public static Connection getConnection(DataSource dataSource) throws CannotGetJdbcConnectionException {
-        Connection connection = TransactionSynchronizationManager.getConnection(dataSource);
-        if (connection != null) {
-            return connection;
+    public static Connection getConnection(DataSource dataSource) {
+        if (TransactionSynchronizationManager.isInTransaction()) {
+            return TransactionSynchronizationManager.getConnection(dataSource);
         }
-
+        
         try {
-            connection = dataSource.getConnection();
-            TransactionSynchronizationManager.bindConnection(dataSource, connection);
-            return connection;
-        } catch (SQLException ex) {
-            throw new CannotGetJdbcConnectionException("Failed to obtain JDBC Connection", ex);
+            return dataSource.getConnection();
+        } catch (SQLException e) {
+            throw new CannotGetJdbcConnectionException(e.getMessage());
         }
     }
 
-    public static void releaseConnection(Connection connection, DataSource dataSource) {
+    public static void releaseConnection(Connection connection) {
         try {
-            connection.close();
-        } catch (SQLException ex) {
+            releaseIfNotInTransaction(connection);
+        } catch (SQLException e) {
             throw new CannotGetJdbcConnectionException("Failed to close JDBC Connection");
-        } finally {
-            TransactionSynchronizationManager.unbindConnection(dataSource);
+        }
+    }
+
+    private static void releaseIfNotInTransaction(Connection connection) throws SQLException {
+        if (!TransactionSynchronizationManager.isInTransaction()) {
+            connection.close();
         }
     }
 }

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

@@ -1,6 +1,6 @@
 package org.springframework.transaction.support;
 
-import org.springframework.jdbc.CannotGetJdbcConnectionException;
+import org.springframework.DataAccessException;
 
 import javax.sql.DataSource;
 import java.sql.Connection;
@@ -10,13 +10,14 @@
 public abstract class TransactionSynchronizationManager {
 
     private static final ThreadLocal<Map<DataSource, Connection>> resources = new ThreadLocal<>();
+    private static final ThreadLocal<Boolean> isInTransaction = ThreadLocal.withInitial(() -> false);
 
     private TransactionSynchronizationManager() {}
 
     public static Connection getConnection(DataSource dataSource) {
         Map<DataSource, Connection> dataSourceAndConnection = resources.get();
-        if (dataSourceAndConnection == null) {
-            throw new CannotGetJdbcConnectionException("DataSource에 binding된 Connection이 없습니다.");
+        if (dataSourceAndConnection == null || dataSourceAndConnection.get(dataSource) == null) {
+            throw new DataAccessException("DataSource에 binding된 Connection이 없습니다.");
         }
 
         return dataSourceAndConnection.get(dataSource);
@@ -31,14 +32,33 @@ public static void bindConnection(DataSource dataSource, Connection connection)
         resources.get().put(dataSource, connection);
     }
 
-    public static Connection unbindConnection(DataSource dataSource) {
+    public static Connection unbindConnection(Connection connection, DataSource dataSource) {
         if (resources.get() == null || !resources.get().containsKey(dataSource)) {
             throw new IllegalArgumentException("등록된 DataSource가 없습니다.");
         }
 
         Map<DataSource, Connection> resource = resources.get();
-        Connection connection = resource.get(dataSource);
+        Connection bindedConnection = resource.get(dataSource);
+        validateConnection(connection, bindedConnection);
         resources.remove();
         return connection;
     }
+
+    private static void validateConnection(Connection connection, Connection bindedConnection) {
+        if (connection != bindedConnection) {
+            throw new IllegalArgumentException("잘못된 Connection입니다.");
+        }
+    }
+
+    public static boolean isInTransaction() {
+        return isInTransaction.get();
+    }
+
+    public static void setInTransaction(boolean inTransaction) {
+        if (inTransaction && isInTransaction()) {
+            throw new IllegalStateException("이미 트랜잭션이 진행중입니다.");
+        }
+        isInTransaction.remove();
+        isInTransaction.set(inTransaction);
+    }
 }

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

@@ -1,7 +1,6 @@
 package org.springframework.transaction.support;
 
-import org.springframework.dao.DataAccessException;
-import org.springframework.jdbc.datasource.DataSourceUtils;
+import org.springframework.DataAccessException;
 
 import javax.sql.DataSource;
 import java.sql.Connection;
@@ -16,23 +15,23 @@ public TransactionTemplate(DataSource dataSource) {
     }
 
     public void execute(Runnable runnable) {
-        Connection connection = DataSourceUtils.getConnection(dataSource);
-        begin(connection);
+        Connection connection = begin();
         try {
             runnable.run();
-
             commit(connection);
         } catch (Exception e) {
             rollback(connection);
-        } finally {
-            DataSourceUtils.releaseConnection(connection, dataSource);
+            throw new DataAccessException(e);
         }
     }
 
-
-    private void begin(Connection connection) {
+    private Connection begin() {
         try {
+            TransactionSynchronizationManager.setInTransaction(true);
+            Connection connection = dataSource.getConnection();
             connection.setAutoCommit(false);
+            TransactionSynchronizationManager.bindConnection(dataSource, connection);
+            return connection;
         } catch (SQLException e) {
             throw new DataAccessException(e);
         }
@@ -41,6 +40,7 @@ private void begin(Connection connection) {
     private void commit(Connection connection) {
         try {
             connection.commit();
+            release(connection);
         } catch (SQLException e) {
             throw new DataAccessException(e);
         }
@@ -49,6 +49,17 @@ private void commit(Connection connection) {
     private void rollback(Connection connection) {
         try {
             connection.rollback();
+            release(connection);
+        } catch (SQLException e) {
+            throw new DataAccessException(e);
+        }
+    }
+
+    private void release(Connection connection) {
+        try {
+            TransactionSynchronizationManager.setInTransaction(false);
+            Connection unbindedConnection = TransactionSynchronizationManager.unbindConnection(connection, dataSource);
+            unbindedConnection.close();
         } catch (SQLException e) {
             throw new DataAccessException(e);
         }