JDBC 라이브러리 구현하기 - 2단계] 채채(신채원) 미션 제출합니다.

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

@@ -6,6 +6,7 @@
 
 import javax.sql.DataSource;
 import java.util.List;
+import java.util.Optional;
 
 public class UserDao {
 
@@ -42,12 +43,12 @@ public List<User> findAll() {
         return jdbcTemplate.queryForList(sql, USER_MAPPER);
     }
 
-    public User findById(final Long id) {
+    public Optional<User> findById(final Long id) {
         final String sql = "select id, account, password, email from users where id = ?";
         return jdbcTemplate.queryForObject(sql, USER_MAPPER, id);
     }
 
-    public User findByAccount(final String account) {
+    public Optional<User> findByAccount(final String account) {
         final String sql = "select id, account, password, email from users where account = ?";
         return jdbcTemplate.queryForObject(sql, USER_MAPPER, account);
     }

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

@@ -16,7 +16,8 @@ public UserService(final UserDao userDao, final UserHistoryDao userHistoryDao) {
     }
 
     public User findById(final long id) {
-        return userDao.findById(id);
+        return userDao.findById(id)
+                .orElseThrow(() -> new RuntimeException("존재하지 않는 회원입니다."));
     }
 
     public void insert(final User user) {

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

@@ -2,83 +2,72 @@
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+import org.springframework.dao.DataAccessException;
 
 import javax.sql.DataSource;
 import java.sql.Connection;
 import java.sql.PreparedStatement;
-import java.sql.ResultSet;
 import java.sql.SQLException;
-import java.util.ArrayList;
 import java.util.List;
+import java.util.Optional;
 
 public class JdbcTemplate {
 
     private static final Logger log = LoggerFactory.getLogger(JdbcTemplate.class);
 
     private final DataSource dataSource;
+    private final StatementExecutor statementExecutor;
 
     public JdbcTemplate(final DataSource dataSource) {
+        this(dataSource, new StatementExecutor());
+    }
+
+    public JdbcTemplate(final DataSource dataSource,
+                        final StatementExecutor statementExecutor) {
         this.dataSource = dataSource;
+        this.statementExecutor = statementExecutor;
     }
 
-    public void update(final String sql,
-                       final Object... parameters) {
-        try (final Connection connection = dataSource.getConnection();
-             final PreparedStatement preparedStatement = getPreparedStatement(sql, connection, parameters)) {
-            log.debug("query : {}", sql);
-            for (int i = 0; i < parameters.length; i++) {
-                preparedStatement.setObject(i + 1, parameters[i]);
-            }
-            preparedStatement.executeUpdate();
-        } catch (SQLException e) {
-            log.error(e.getMessage(), e);
-            throw new RuntimeException(e);
+    public void update(final String sql, final Object... parameters) {
+        query(sql, PreparedStatement::executeUpdate, parameters);
+    }
+
+    public <T> Optional<T> queryForObject(final String sql, final ResultSetMapper<T> rowMapper, final Object... parameters) {
+        final List<T> results = query(sql, statement -> statementExecutor.execute(statement, rowMapper), parameters);
+        if (results.size() > 1) {
+            throw new DataAccessException("2개 이상의 결과를 반환할 수 없습니다.");
         }
+        if (results.isEmpty()) {
+            return Optional.empty();
+        }
+
+        return Optional.ofNullable(results.iterator().next());
     }
 
-    public <T> T queryForObject(final String sql,
-                                final ResultSetMapper<T> rowMapper,
-                                final Object... parameters) {
+    public <T> List<T> queryForList(final String sql, final ResultSetMapper<T> rowMapper, final Object... parameters) {
+        return query(sql, statement -> statementExecutor.execute(statement, rowMapper), parameters);
+    }
+
+    private <T> T query(final String sql,
+                        final PreparedStatementCallback<T> preparedStatementCallback,
+                        final Object... parameters) {
         try (final Connection connection = dataSource.getConnection();
-             final PreparedStatement preparedStatement = getPreparedStatement(sql, connection, parameters);
-             final ResultSet resultSet = preparedStatement.executeQuery()) {
-            log.debug("query : {}", sql);
-            if (resultSet.next()) {
-                return rowMapper.apply(resultSet);
-            }
-            return null;
-        } catch (SQLException e) {
+             final PreparedStatement preparedStatement = statementCreate(connection, sql, parameters)) {
+            return preparedStatementCallback.execute(preparedStatement);
+        } catch (final SQLException e) {
             log.error(e.getMessage(), e);
-            throw new RuntimeException(e);
+            throw new DataAccessException(e);
         }
     }
 
-    private PreparedStatement getPreparedStatement(final String sql,
-                                                   final Connection connection,
-                                                   final Object[] parameters) throws SQLException {
+    private PreparedStatement statementCreate(final Connection connection,
+                                              final String sql,
+                                              final Object[] parameters) throws SQLException {
         final PreparedStatement preparedStatement = connection.prepareStatement(sql);
         for (int i = 0; i < parameters.length; i++) {
             preparedStatement.setObject(i + 1, parameters[i]);
         }
         return preparedStatement;
     }
-
-    public <T> List<T> queryForList(final String sql,
-                                    final ResultSetMapper<T> rowMapper,
-                                    final Object... parameters) {
-        try (final Connection connection = dataSource.getConnection();
-             final PreparedStatement preparedStatement = getPreparedStatement(sql, connection, parameters);
-             final ResultSet resultSet = preparedStatement.executeQuery()) {
-            log.debug("query : {}", sql);
-            final List<T> result = new ArrayList<>();
-            while (resultSet.next()) {
-                result.add(rowMapper.apply(resultSet));
-            }
-            return result;
-        } catch (SQLException e) {
-            log.error(e.getMessage(), e);
-            throw new RuntimeException(e);
-        }
-    }
 }
 

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

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

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

@@ -0,0 +1,20 @@
+package org.springframework.jdbc.core;
+
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.List;
+
+public class StatementExecutor {
+
+    public <T> List<T> execute(final PreparedStatement preparedStatement,
+                               final ResultSetMapper<T> rowMapper) throws SQLException {
+        final ResultSet resultSet = preparedStatement.executeQuery();
+        final List<T> results = new ArrayList<>();
+        while (resultSet.next()) {
+            results.add(rowMapper.apply(resultSet));
+        }
+        return results;
+    }
+}