[JDBC 라이브러리 구현하기 - 4단계] 디투(박정훈) 미션 제출합니다.

app/src/main/java/com/techcourse/dao/UserDao.java

@@ -3,6 +3,7 @@
 import com.techcourse.domain.User;
 import org.springframework.jdbc.core.JdbcTemplate;
 import org.springframework.jdbc.core.ResultSetMapper;
+import org.springframework.transaction.support.TransactionSynchronizationManager;
 
 import javax.sql.DataSource;
 import java.sql.Connection;
@@ -23,14 +24,14 @@ public UserDao(final DataSource dataSource) {
         this.jdbcTemplate = new JdbcTemplate(dataSource);
     }
 
-    public void insert(final Connection connection, final User user) {
+    public void insert(final User user) {
         final String sql = "insert into users (account, password, email) values (?, ?, ?)";
-        jdbcTemplate.update(connection, sql, user.getAccount(), user.getPassword(), user.getEmail());
+        jdbcTemplate.update(sql, user.getAccount(), user.getPassword(), user.getEmail());
     }
 
-    public void update(final Connection connection, final User user) {
+    public void update(final User user) {
         final String sql = "update users set account = ?, password = ?, email = ? where id = ?";
-        jdbcTemplate.update(connection, sql, user.getAccount(), user.getPassword(), user.getEmail(), user.getId());
+        jdbcTemplate.update(sql, user.getAccount(), user.getPassword(), user.getEmail(), user.getId());
     }
 
     public List<User> findAll() {

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

@@ -1,85 +1,39 @@
 package com.techcourse.service;
 
-import com.techcourse.config.DataSourceConfig;
 import com.techcourse.dao.UserDao;
 import com.techcourse.dao.UserHistoryDao;
 import com.techcourse.domain.User;
 import com.techcourse.domain.UserHistory;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
-import org.springframework.dao.DataAccessException;
-
-import java.sql.Connection;
-import java.sql.SQLException;
+import org.springframework.transaction.support.TransactionTemplate;
 
 public class UserService {
 
-    private static final Logger log = LoggerFactory.getLogger(UserService.class);
-
     private final UserDao userDao;
     private final UserHistoryDao userHistoryDao;
+    private final TransactionTemplate transactionTemplate;
 
-    public UserService(final UserDao userDao, final UserHistoryDao userHistoryDao) {
+    public UserService(final UserDao userDao, final UserHistoryDao userHistoryDao, final TransactionTemplate transactionTemplate) {
         this.userDao = userDao;
         this.userHistoryDao = userHistoryDao;
+        this.transactionTemplate = transactionTemplate;
     }
 
     public User findById(final long id) {
         return userDao.findById(id);
     }
 
     public void insert(final User user) {
-        Connection connection = null;
-        try {
-            connection = DataSourceConfig.getInstance().getConnection();
-            connection.setAutoCommit(false);
-            userDao.insert(connection, user);
-            connection.commit();
-        } catch (SQLException e) {
-            log.error(e.getMessage());
-            rollback(connection);
-        } finally {
-            release(connection);
-        }
+        transactionTemplate.execute(connection -> userDao.insert(user));
     }
 
     public void changePassword(final long id, final String newPassword, final String createBy) {
-        Connection connection = null;
-        try {
-            connection = DataSourceConfig.getInstance().getConnection();
-            connection.setAutoCommit(false);
+        transactionTemplate.execute(connection -> {
             final var user = findById(id);
             user.changePassword(newPassword);
-            userDao.update(connection, user);
+            userDao.update(user);
             userHistoryDao.log(connection, new UserHistory(user, createBy));
-            connection.commit();
-        } catch (SQLException e) {
-            log.error(e.getMessage());
-            rollback(connection);
-        } finally {
-            release(connection);
-        }
-    }
-
-    private void rollback(final Connection connection) {
-        if (connection != null) {
-            try {
-                connection.rollback();
-            } catch (SQLException e) {
-                log.error(e.getMessage());
-                throw new DataAccessException("rollback 에 실패했습니다.");
-            }
-        }
-    }
-
-    private void release(final Connection connection) {
-        if (connection != null) {
-            try {
-                connection.close();
-            } catch (SQLException e) {
-                log.error(e.getMessage());
-                throw new DataAccessException("자원 정리에 실패했습니다.");
-            }
-        }
+        });
     }
 }

app/src/test/java/com/techcourse/dao/UserDaoTest.java

@@ -28,7 +28,7 @@ void setup() throws SQLException {
         userDao = new UserDao(dataSource);
         connection = dataSource.getConnection();
         final var user = new User("hongsil", "486", "[email protected]");
-        userDao.insert(connection, user);
+        userDao.insert(user);
     }
 
     @Test
@@ -54,7 +54,7 @@ void findById_make_exception_when_no_result() {
     @Test
     void findByAccount() {
         final var account = "mylove_hongsil";
-        userDao.insert(connection, new User(account, "비밀번호486", "[email protected]"));
+        userDao.insert(new User(account, "비밀번호486", "[email protected]"));
         final var user = userDao.findByAccount(account);
 
         assertThat(user.getAccount()).isEqualTo(account);
@@ -63,8 +63,8 @@ void findByAccount() {
     @Test
     void findByAccount_make_exception_when_multiple_result() {
         final var user = new User("ditoo", "password", "[email protected]");
-        userDao.insert(connection, user);
-        userDao.insert(connection, user);
+        userDao.insert(user);
+        userDao.insert(user);
         assertThatThrownBy(() -> userDao.findByAccount(user.getAccount()))
                 .isInstanceOf(IncorrectResultSizeDataAccessException.class);
     }
@@ -73,7 +73,7 @@ void findByAccount_make_exception_when_multiple_result() {
     void insert() {
         final var account = "insert-gugu";
         final var user = new User(account, "password", "[email protected]");
-        userDao.insert(connection, user);
+        userDao.insert(user);
 
         final var actual = userDao.findById(2L);
 
@@ -86,7 +86,7 @@ void update() {
         final var user = userDao.findById(1L);
         user.changePassword(newPassword);
 
-        userDao.update(connection, user);
+        userDao.update(user);
 
         final var actual = userDao.findById(1L);
 

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

@@ -10,6 +10,7 @@
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Test;
+import org.springframework.transaction.support.TransactionTemplate;
 
 import javax.sql.DataSource;
 
@@ -22,22 +23,24 @@ class UserServiceTest {
 
     private JdbcTemplate jdbcTemplate;
     private UserDao userDao;
+    private TransactionTemplate transactionTemplate;
 
     @BeforeEach
-    void setUp() throws SQLException {
+    void setUp() {
         final DataSource dataSource = DataSourceConfig.getInstance();
         this.jdbcTemplate = new JdbcTemplate(dataSource);
         this.userDao = new UserDao(dataSource);
+        this.transactionTemplate = new TransactionTemplate(dataSource);
 
         DatabasePopulatorUtils.execute(DataSourceConfig.getInstance());
         final var user = new User("gugu", "password", "[email protected]");
-        userDao.insert(dataSource.getConnection(), user);
+        userDao.insert(user);
     }
 
     @Test
     void testChangePassword() {
         final var userHistoryDao = new UserHistoryDao(jdbcTemplate);
-        final var userService = new UserService(userDao, userHistoryDao);
+        final var userService = new UserService(userDao, userHistoryDao, transactionTemplate);
 
         final var newPassword = "qqqqq";
         final var createBy = "gugu";
@@ -52,7 +55,7 @@ void testChangePassword() {
     void testTransactionRollback() {
         // 트랜잭션 롤백 테스트를 위해 mock으로 교체
         final var userHistoryDao = new MockUserHistoryDao(jdbcTemplate);
-        final var userService = new UserService(userDao, userHistoryDao);
+        final var userService = new UserService(userDao, userHistoryDao, transactionTemplate);
 
         final var newPassword = "newPassword";
         final var createBy = "gugu";

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

@@ -6,6 +6,8 @@
 import org.springframework.dao.EmptyResultDataAccessException;
 import org.springframework.dao.IncorrectResultSizeDataAccessException;
 import org.springframework.dao.InvalidDataAccessApiUsageException;
+import org.springframework.jdbc.datasource.DataSourceUtils;
+import org.springframework.transaction.support.TransactionSynchronizationManager;
 
 import javax.sql.DataSource;
 import java.sql.Connection;
@@ -28,23 +30,28 @@ public JdbcTemplate(final DataSource dataSource) {
         this.dataSource = dataSource;
     }
 
-    public int update(final Connection connection, final String sql, final Object... args) {
+    public int update(final String sql, final Object... args) {
+        final Connection connection = DataSourceUtils.getConnection(dataSource);
         try (final PreparedStatement ps = createPreparedStatement(connection, sql, args)) {
             return ps.executeUpdate();
         } catch (SQLException e) {
             log.error(e.getMessage());
             throw new DataAccessException(e);
+        } finally {
+            if (!TransactionSynchronizationManager.isActualTransactionActive()) {
+                DataSourceUtils.releaseConnection(connection, dataSource);
+            }
         }
     }
 
     public <T> List<T> query(final String sql, final ResultSetMapper<T> resultSetMapper) {
-        try (final Connection connection = dataSource.getConnection();
-             final PreparedStatement ps = connection.prepareStatement(sql);
+        final Connection connection = DataSourceUtils.getConnection(dataSource);
+        try (final PreparedStatement ps = connection.prepareStatement(sql);
              final ResultSet resultSet = ps.executeQuery()
         ) {
             log.debug("query: {}", sql);
             final List<T> results = new ArrayList<>();
-            while(resultSet.next()) {
+            while (resultSet.next()) {
                 results.add(resultSetMapper.apply(resultSet));
             }
             return results;

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

@@ -32,6 +32,8 @@ public static void releaseConnection(Connection connection, DataSource dataSourc
             connection.close();
         } catch (SQLException ex) {
             throw new CannotGetJdbcConnectionException("Failed to close JDBC Connection");
+        } finally {
+            TransactionSynchronizationManager.unbindResource(dataSource);
         }
     }
 }

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

@@ -0,0 +1,9 @@
+package org.springframework.transaction.support;
+
+import java.sql.Connection;
+
+@FunctionalInterface
+public interface TransactionCallback {
+
+    void doInTransaction(Connection connection);
+}

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

@@ -1,23 +1,58 @@
 package org.springframework.transaction.support;
 
+import javax.annotation.Nullable;
 import javax.sql.DataSource;
 import java.sql.Connection;
+import java.util.HashMap;
 import java.util.Map;
 
 public abstract class TransactionSynchronizationManager {
 
     private static final ThreadLocal<Map<DataSource, Connection>> resources = new ThreadLocal<>();
+    private static final ThreadLocal<Boolean> actualTransactionActive = ThreadLocal.withInitial(() -> Boolean.FALSE);
 
     private TransactionSynchronizationManager() {}
 
-    public static Connection getResource(DataSource key) {
-        return null;
+    @Nullable
+    public static Connection getResource(final DataSource key) {
+        final Map<DataSource, Connection> map = resources.get();
+        if (map == null) {
+            return null;
+        }
+        return map.get(key);
     }
 
-    public static void bindResource(DataSource key, Connection value) {
+    public static void bindResource(final DataSource key, final Connection value) {
+        final Map<DataSource, Connection> map = resources.get();
+        if (map == null) {
+            final Map<DataSource, Connection> newMap = new HashMap<>();
+            newMap.put(key, value);
+            resources.set(newMap);
+            return;
+        }
+        map.put(key, value);
+        resources.set(map);
     }
 
-    public static Connection unbindResource(DataSource key) {
-        return null;
+    public static void unbindResource(final DataSource key) {
+        final Map<DataSource, Connection> map = resources.get();
+        if (map == null) {
+            throw new IllegalStateException("No resource for key [" + key + "] bound to thread");
+        }
+        if (map.get(key) == null) {
+            throw new IllegalStateException("No value for key [" + key + "] bound to thread");
+        }
+        map.remove(key);
+        if (map.isEmpty()) {
+            resources.remove();
+        }
+    }
+
+    public static boolean isActualTransactionActive() {
+        return actualTransactionActive.get();
+    }
+
+    public static void setActualTransactionActiveTrue() {
+        actualTransactionActive.set(true);
     }
 }

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

@@ -0,0 +1,40 @@
+package org.springframework.transaction.support;
+
+import org.springframework.dao.DataAccessException;
+import org.springframework.jdbc.datasource.DataSourceUtils;
+
+import javax.sql.DataSource;
+import java.sql.Connection;
+import java.sql.SQLException;
+
+public class TransactionTemplate {
+
+    private final DataSource dataSource;
+
+    public TransactionTemplate(final DataSource dataSource) {
+        this.dataSource = dataSource;
+    }
+
+    public void execute(final TransactionCallback transactionCallback) {
+        final Connection connection = DataSourceUtils.getConnection(dataSource);
+        try {
+            connection.setAutoCommit(false);
+            TransactionSynchronizationManager.setActualTransactionActiveTrue();
+            transactionCallback.doInTransaction(connection);
+            connection.commit();
+        } catch (SQLException e) {
+            rollback(connection);
+            throw new DataAccessException("transaction 설정에 오류가 발생했습니다.");
+        } finally {
+            DataSourceUtils.releaseConnection(connection, dataSource);
+        }
+    }
+
+    private void rollback(final Connection connection) {
+        try {
+            connection.rollback();
+        } catch (SQLException e) {
+            throw new DataAccessException("rollback 에 실패했습니다.");
+        }
+    }
+}

jdbc/src/test/java/nextstep/jdbc/JdbcTemplateTest.java

@@ -1,5 +1,19 @@
 package nextstep.jdbc;
 
+import org.junit.jupiter.api.BeforeEach;
+import org.mockito.Mockito;
+import org.springframework.jdbc.core.JdbcTemplate;
+
+import javax.sql.DataSource;
+
 class JdbcTemplateTest {
 
+    DataSource dataSource;
+    JdbcTemplate jdbcTemplate;
+
+    @BeforeEach
+    void setUp() {
+        dataSource = Mockito.mock(DataSource.class);
+        jdbcTemplate = new JdbcTemplate(dataSource);
+    }
 }