[JDBC 라이브러리 구현하기 - 3단계] 도이(유도영) 미션 제출합니다.

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

@@ -1,9 +1,11 @@
 package com.techcourse.dao;
 
 import com.techcourse.domain.User;
+import java.sql.Connection;
 import java.util.List;
 import org.springframework.jdbc.core.JdbcTemplate;
 import org.springframework.jdbc.core.RowMapper;
+import org.springframework.jdbc.core.TransactionManager;
 
 public class UserDao {
 
@@ -14,24 +16,45 @@ public class UserDao {
                     resultSet.getString(3),
                     resultSet.getString(4)
             );
+
+    private final TransactionManager transactionManager;
     private final JdbcTemplate jdbcTemplate;
 
-    public UserDao(JdbcTemplate jdbcTemplate) {
+    public UserDao(final TransactionManager transactionManager, final JdbcTemplate jdbcTemplate) {
+        this.transactionManager = transactionManager;
         this.jdbcTemplate = jdbcTemplate;
     }
 
     public void insert(final User user) {
         final var sql = "insert into users (account, password, email) values (?, ?, ?)";
-        jdbcTemplate.executeUpdate(sql,
-                user.getAccount(),
-                user.getPassword(),
-                user.getEmail()
-        );
+        transactionManager.save(
+                (connection, entity) -> jdbcTemplate.executeUpdate(
+                        connection,
+                        sql,
+                        user.getAccount(),
+                        user.getPassword(),
+                        user.getEmail()
+                ), user);
     }
 
     public void update(final User user) {
         final var sql = "update users set account = ?, password = ?, email = ? where id = ?";
-        jdbcTemplate.executeUpdate(sql,
+        transactionManager.save(
+                (connection, entity) -> jdbcTemplate.executeUpdate(
+                        connection,
+                        sql,
+                        user.getAccount(),
+                        user.getPassword(),
+                        user.getEmail(),
+                        user.getId()
+                ), user);
+    }
+
+    public void update(final Connection connection, final User user) {
+        final var sql = "update users set account = ?, password = ?, email = ? where id = ?";
+        jdbcTemplate.executeUpdate(
+                connection,
+                sql,
                 user.getAccount(),
                 user.getPassword(),
                 user.getEmail(),
@@ -41,16 +64,20 @@ public void update(final User user) {
 
     public List<User> findAll() {
         final var sql = "select id, account, password, email from users";
-        return jdbcTemplate.executeQueryForList(sql, USER_ROW_MAPPER);
+        return transactionManager.find((connection, parameters) ->
+                jdbcTemplate.executeQueryForList(connection, sql, USER_ROW_MAPPER));
     }
 
     public User findById(final Long id) {
         final var sql = "select id, account, password, email from users where id = ?";
-        return jdbcTemplate.executeQueryForObject(sql, USER_ROW_MAPPER, id);
+        return transactionManager.find(
+                (connection, parameters) ->
+                        jdbcTemplate.executeQueryForObject(connection, sql, USER_ROW_MAPPER, parameters), id);
     }
 
     public User findByAccount(final String account) {
         final var sql = "select id, account, password, email from users where account = ?";
-        return jdbcTemplate.executeQueryForObject(sql, USER_ROW_MAPPER, account);
+        return transactionManager.find((connection, parameters) ->
+                jdbcTemplate.executeQueryForObject(connection, sql, USER_ROW_MAPPER, parameters), account);
     }
 }

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

@@ -1,24 +1,46 @@
 package com.techcourse.dao;
 
 import com.techcourse.domain.UserHistory;
+import java.sql.Connection;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.jdbc.core.TransactionManager;
 
 public class UserHistoryDao {
 
     private static final Logger log = LoggerFactory.getLogger(UserHistoryDao.class);
 
+    private final TransactionManager transactionManager;
     private final JdbcTemplate jdbcTemplate;
 
-    public UserHistoryDao(JdbcTemplate jdbcTemplate) {
+    public UserHistoryDao(final TransactionManager transactionManager, final JdbcTemplate jdbcTemplate) {
+        this.transactionManager = transactionManager;
         this.jdbcTemplate = jdbcTemplate;
     }
 
     public void log(final UserHistory userHistory) {
         final var sql = "insert into user_history (user_id, account, password, email, created_at, created_by) values (?, ?, ?, ?, ?, ?)";
         log.info("query: {}", sql);
-        jdbcTemplate.executeUpdate(sql,
+        transactionManager.save(
+                (connection, entity) -> jdbcTemplate.executeUpdate(
+                        connection,
+                        sql,
+                        userHistory.getUserId(),
+                        userHistory.getAccount(),
+                        userHistory.getPassword(),
+                        userHistory.getEmail(),
+                        userHistory.getCreatedAt(),
+                        userHistory.getCreateBy()
+                ), userHistory);
+    }
+
+    public void log(final Connection connection, final UserHistory userHistory) {
+        final var sql = "insert into user_history (user_id, account, password, email, created_at, created_by) values (?, ?, ?, ?, ?, ?)";
+        log.info("query: {}", sql);
+        jdbcTemplate.executeUpdate(
+                connection,
+                sql,
                 userHistory.getUserId(),
                 userHistory.getAccount(),
                 userHistory.getPassword(),

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

@@ -4,13 +4,19 @@
 import com.techcourse.dao.UserHistoryDao;
 import com.techcourse.domain.User;
 import com.techcourse.domain.UserHistory;
+import org.springframework.jdbc.core.TransactionManager;
 
 public class UserService {
 
+    private final TransactionManager transactionManager;
     private final UserDao userDao;
     private final UserHistoryDao userHistoryDao;
 
-    public UserService(final UserDao userDao, final UserHistoryDao userHistoryDao) {
+    public UserService(
+            final TransactionManager transactionManager,
+            final UserDao userDao,
+            final UserHistoryDao userHistoryDao) {
+        this.transactionManager = transactionManager;
         this.userDao = userDao;
         this.userHistoryDao = userHistoryDao;
     }
@@ -26,7 +32,11 @@ public void insert(final User user) {
     public void changePassword(final long id, final String newPassword, final String createBy) {
         final var user = findById(id);
         user.changePassword(newPassword);
-        userDao.update(user);
-        userHistoryDao.log(new UserHistory(user, createBy));
+        transactionManager.save(
+                (connection, entity) -> {
+                    userDao.update(connection, entity);
+                    userHistoryDao.log(connection, new UserHistory(entity, createBy));
+                },
+                user);
     }
 }

app/src/main/resources/schema.sql

@@ -1,3 +1,6 @@
+drop table if exists users;
+drop table if exists user_history;
+
 create table if not exists users (
     id bigint auto_increment,
     account varchar(100) not null,

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

@@ -4,11 +4,12 @@
 
 import com.techcourse.config.DataSourceConfig;
 import com.techcourse.domain.User;
-import com.techcourse.support.jdbc.init.PooledDataSourceConnectionManager;
 import com.techcourse.support.jdbc.init.DatabasePopulatorUtils;
+import com.techcourse.support.jdbc.init.PooledDataSourceConnectionManager;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.jdbc.core.TransactionManager;
 
 class UserDaoTest {
 
@@ -17,8 +18,7 @@ class UserDaoTest {
     @BeforeEach
     void setup() {
         DatabasePopulatorUtils.execute(DataSourceConfig.getInstance());
-
-        userDao = new UserDao(new JdbcTemplate(new PooledDataSourceConnectionManager()));
+        userDao = new UserDao(new TransactionManager(new PooledDataSourceConnectionManager()), new JdbcTemplate());
         final var user = new User("gugu", "password", "[email protected]");
         userDao.insert(user);
     }

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

@@ -2,17 +2,19 @@
 
 import com.techcourse.dao.UserHistoryDao;
 import com.techcourse.domain.UserHistory;
+import java.sql.Connection;
 import org.springframework.dao.DataAccessException;
 import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.jdbc.core.TransactionManager;
 
 public class MockUserHistoryDao extends UserHistoryDao {
 
-    public MockUserHistoryDao(final JdbcTemplate jdbcTemplate) {
-        super(jdbcTemplate);
+    public MockUserHistoryDao(final TransactionManager transactionManager, final JdbcTemplate jdbcTemplate) {
+        super(transactionManager, jdbcTemplate);
     }
 
     @Override
-    public void log(final UserHistory userHistory) {
+    public void log(final Connection connection, final UserHistory userHistory) {
         throw new DataAccessException();
     }
 }

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

@@ -7,24 +7,25 @@
 import com.techcourse.dao.UserDao;
 import com.techcourse.dao.UserHistoryDao;
 import com.techcourse.domain.User;
-import com.techcourse.support.jdbc.init.PooledDataSourceConnectionManager;
 import com.techcourse.support.jdbc.init.DatabasePopulatorUtils;
+import com.techcourse.support.jdbc.init.PooledDataSourceConnectionManager;
 import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Test;
 import org.springframework.dao.DataAccessException;
 import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.jdbc.core.TransactionManager;
 
-@Disabled
 class UserServiceTest {
 
+    private TransactionManager transactionManager;
     private JdbcTemplate jdbcTemplate;
     private UserDao userDao;
 
     @BeforeEach
     void setUp() {
-        this.jdbcTemplate = new JdbcTemplate(new PooledDataSourceConnectionManager());
-        this.userDao = new UserDao(jdbcTemplate);
+        this.transactionManager = new TransactionManager(new PooledDataSourceConnectionManager());
+        this.jdbcTemplate = new JdbcTemplate();
+        this.userDao = new UserDao(transactionManager, jdbcTemplate);
 
         DatabasePopulatorUtils.execute(DataSourceConfig.getInstance());
         final var user = new User("gugu", "password", "[email protected]");
@@ -33,8 +34,8 @@ void setUp() {
 
     @Test
     void testChangePassword() {
-        final var userHistoryDao = new UserHistoryDao(jdbcTemplate);
-        final var userService = new UserService(userDao, userHistoryDao);
+        final var userHistoryDao = new UserHistoryDao(transactionManager, jdbcTemplate);
+        final var userService = new UserService(transactionManager, userDao, userHistoryDao);
 
         final var newPassword = "qqqqq";
         final var createBy = "gugu";
@@ -48,8 +49,8 @@ void testChangePassword() {
     @Test
     void testTransactionRollback() {
         // 트랜잭션 롤백 테스트를 위해 mock으로 교체
-        final var userHistoryDao = new MockUserHistoryDao(jdbcTemplate);
-        final var userService = new UserService(userDao, userHistoryDao);
+        final var userHistoryDao = new MockUserHistoryDao(transactionManager, jdbcTemplate);
+        final var userService = new UserService(transactionManager, userDao, userHistoryDao);
 
         final var newPassword = "newPassword";
         final var createBy = "gugu";

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

@@ -14,32 +14,29 @@ public class JdbcTemplate {
 
     private static final Logger log = LoggerFactory.getLogger(JdbcTemplate.class);
 
-    private final ConnectionManager connectionManager;
-
-    public JdbcTemplate(final ConnectionManager connectionManager) {
-        this.connectionManager = connectionManager;
-    }
-
-    public int executeUpdate(final String query, final Object... parameters) {
-        return execute(query, (connection, preparedStatement) -> preparedStatement.executeUpdate(), parameters);
+    public int executeUpdate(final Connection connection, final String query, final Object... parameters) {
+        PreparedStatementCallback<Integer> preparedStatementCallback = PreparedStatement::executeUpdate;
+        return execute(connection, query, preparedStatementCallback, parameters);
     }
 
     public <T> T executeQueryForObject(
+            final Connection connection,
             final String query,
             final RowMapper<T> rowMapper,
             final Object... parameters
     ) {
-        final ResultSetExtractor<T> resultSetExtractor = resultSet -> {
-            if (resultSet.next()) {
-                return rowMapper.mapRow(resultSet);
-            }
+        final var results = executeQueryForList(connection, query, rowMapper, parameters);
+        if (results.isEmpty()) {
             return null;
-        };
-
-        return executeQuery(query, resultSetExtractor, parameters);
+        }
+        if (results.size() > 1) {
+            throw new SqlQueryException(query, "cannot map for single result");
+        }
+        return results.get(0);
     }
 
     public <T> List<T> executeQueryForList(
+            final Connection connection,
             final String query,
             final RowMapper<T> rowMapper,
             final Object... parameters
@@ -52,31 +49,37 @@ public <T> List<T> executeQueryForList(
             return results;
         };
 
-        return executeQuery(query, resultSetExtractor, parameters);
+        return executeQuery(connection, query, resultSetExtractor, parameters);
     }
 
     public <T> T executeQuery(
+            final Connection connection,
             final String query,
             final ResultSetExtractor<T> resultSetExtractor,
             final Object... parameters
     ) {
-        return execute(query, (connection, preparedStatement) -> {
-            try (final ResultSet resultSet = preparedStatement.executeQuery()) {
-                return resultSetExtractor.extract(resultSet);
-            }
-        }, parameters);
+        return execute(
+                connection,
+                query,
+                preparedStatement -> {
+                    try (final ResultSet resultSet = preparedStatement.executeQuery()) {
+                        return resultSetExtractor.extract(resultSet);
+                    }
+                }, parameters);
     }
 
     private <T> T execute(
+            final Connection connection,
             final String query,
-            final ConnectionCallback<T> callback,
+            final PreparedStatementCallback<T> callback,
             final Object... parameters
     ) {
-        try (final Connection connection = connectionManager.getConnection();
-             final PreparedStatement preparedStatement = connection.prepareStatement(query)) {
+        try (final Connection conn = connection;
+             final PreparedStatement preparedStatement = conn.prepareStatement(query)) {
             log.info("query: {}", query);
             setParameters(preparedStatement, parameters);
-            return callback.doInConnection(connection, preparedStatement);
+
+            return callback.doInConnection(preparedStatement);
         } catch (SQLException exception) {
             throw new SqlQueryException(exception.getMessage(), query);
         }

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

@@ -0,0 +1,11 @@
+package org.springframework.jdbc.core;
+
+import java.sql.PreparedStatement;
+import java.sql.SQLException;
+
+@FunctionalInterface
+public interface PreparedStatementCallback<T> {
+
+    T doInConnection(final PreparedStatement preparedStatement) throws SQLException;
+
+}