[JDBC 라이브러리 구현하기 - 1단계] 홍실(홍혁준) 미션 제출합니다.

README.md

@@ -1 +1,17 @@
 # JDBC 라이브러리 구현하기
+
+- [x] UserDaoTest 통과시키기
+    - [x] user findAll 구현하기
+    - [x] user update 구현하기
+    - [x] user findByAccount 구현하기
+- [x] UserDao 리팩터링
+    - [x] 공통부분 분리
+    - [ ] JdbcTemplate 구현하기
+        - [x] 조회기능 구현
+        - [x] 쓰기기능 구현
+- [x] UserDao를 JdbcTemplate을 사용하도록 리팩터링
+    - [x] findByAccount
+    - [x] findById
+    - [x] findAll
+    - [x] update
+    - [x] insert

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

@@ -1,121 +1,66 @@
 package com.techcourse.dao;
 
 import com.techcourse.domain.User;
-import org.springframework.jdbc.core.JdbcTemplate;
+import java.util.ArrayList;
+import java.util.List;
+import javax.sql.DataSource;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
-
-import javax.sql.DataSource;
-import java.sql.Connection;
-import java.sql.PreparedStatement;
-import java.sql.ResultSet;
-import java.sql.SQLException;
-import java.util.List;
+import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.jdbc.core.Mapper;
 
 public class UserDao {
 
+    private static final Mapper<User> USER_MAPPER = (rs) -> new User(
+        rs.getLong(1),
+        rs.getString(2),
+        rs.getString(3),
+        rs.getString(4)
+    );
     private static final Logger log = LoggerFactory.getLogger(UserDao.class);
 
-    private final DataSource dataSource;
+    private final JdbcTemplate jdbcTemplate;
 
     public UserDao(final DataSource dataSource) {
-        this.dataSource = dataSource;
+        this.jdbcTemplate = new JdbcTemplate(dataSource);
     }
 
     public UserDao(final JdbcTemplate jdbcTemplate) {
-        this.dataSource = null;
+        this.jdbcTemplate = jdbcTemplate;
     }
 
     public void insert(final User user) {
         final var sql = "insert into users (account, password, email) values (?, ?, ?)";
-
-        Connection conn = null;
-        PreparedStatement pstmt = null;
-        try {
-            conn = dataSource.getConnection();
-            pstmt = conn.prepareStatement(sql);
-
-            log.debug("query : {}", sql);
-
-            pstmt.setString(1, user.getAccount());
-            pstmt.setString(2, user.getPassword());
-            pstmt.setString(3, user.getEmail());
-            pstmt.executeUpdate();
-        } catch (SQLException e) {
-            log.error(e.getMessage(), e);
-            throw new RuntimeException(e);
-        } finally {
-            try {
-                if (pstmt != null) {
-                    pstmt.close();
-                }
-            } catch (SQLException ignored) {}
-
-            try {
-                if (conn != null) {
-                    conn.close();
-                }
-            } catch (SQLException ignored) {}
-        }
+        jdbcTemplate.executeUpdate(sql,
+            user.getAccount(), user.getPassword(), user.getEmail());
     }
 
     public void update(final User user) {
-        // todo
+        final var sql = "update users set account = ?,  password = ? , email = ? where id = ?";
+        jdbcTemplate.executeUpdate(sql,
+            user.getAccount(), user.getPassword(), user.getEmail(), user.getId());
     }
 
     public List<User> findAll() {
-        // todo
-        return null;
+        final var sql = "select id, account, password, email from users";
+        return jdbcTemplate.executeQuery(sql, (rs) -> {
+            final List<User> users = new ArrayList<>();
+            while (rs.next()) {
+                users.add(USER_MAPPER.map(rs));
+            }
+            return users;
+        });
     }
 
     public User findById(final Long id) {
         final var sql = "select id, account, password, email from users where id = ?";
 
-        Connection conn = null;
-        PreparedStatement pstmt = null;
-        ResultSet rs = null;
-        try {
-            conn = dataSource.getConnection();
-            pstmt = conn.prepareStatement(sql);
-            pstmt.setLong(1, id);
-            rs = pstmt.executeQuery();
-
-            log.debug("query : {}", sql);
-
-            if (rs.next()) {
-                return new User(
-                        rs.getLong(1),
-                        rs.getString(2),
-                        rs.getString(3),
-                        rs.getString(4));
-            }
-            return null;
-        } catch (SQLException e) {
-            log.error(e.getMessage(), e);
-            throw new RuntimeException(e);
-        } finally {
-            try {
-                if (rs != null) {
-                    rs.close();
-                }
-            } catch (SQLException ignored) {}
-
-            try {
-                if (pstmt != null) {
-                    pstmt.close();
-                }
-            } catch (SQLException ignored) {}
-
-            try {
-                if (conn != null) {
-                    conn.close();
-                }
-            } catch (SQLException ignored) {}
-        }
+        return jdbcTemplate.executeQuery(sql, USER_MAPPER, id);
     }
 
     public User findByAccount(final String account) {
-        // todo
-        return null;
+        final var sql = "select id, account, password, email from users where account = ?";
+
+        return jdbcTemplate.executeQuery(sql, USER_MAPPER, account);
     }
 }

jdbc/build.gradle

@@ -19,4 +19,6 @@ dependencies {
     testImplementation "org.junit.jupiter:junit-jupiter-api:5.7.2"
     testImplementation "org.mockito:mockito-core:5.4.0"
     testRuntimeOnly "org.junit.jupiter:junit-jupiter-engine:5.7.2"
+
+    implementation "com.h2database:h2:2.2.220"
 }

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

@@ -1,9 +1,14 @@
 package org.springframework.jdbc.core;
 
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
+import static java.sql.Statement.RETURN_GENERATED_KEYS;
 
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
 import javax.sql.DataSource;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 public class JdbcTemplate {
 
@@ -14,4 +19,56 @@ public class JdbcTemplate {
     public JdbcTemplate(final DataSource dataSource) {
         this.dataSource = dataSource;
     }
+
+    public Long executeUpdate(final String sql, final Object... parameters) {
+        try (final Connection connection = dataSource.getConnection();
+            final PreparedStatement pstmt = connection.prepareStatement(sql,
+                RETURN_GENERATED_KEYS)) {
+            log.debug("query : {}", sql);
+            setPreparedStatement(pstmt, parameters);
+            pstmt.executeUpdate();
+            return extractId(pstmt);
+        } catch (final SQLException e) {
+            log.error(e.getMessage(), e);
+            throw new RuntimeException(e);
+        }
+    }
+
+    private Long extractId(final PreparedStatement pstmt) throws SQLException {
+        try (final ResultSet generatedKeys = pstmt.getGeneratedKeys()) {
+            if (generatedKeys.next()) {
+                return generatedKeys.getLong(1);
+            }
+            throw new SQLException("id를 찾을 수 없습니다.");
+        }
+    }
+
+    private void setPreparedStatement(
+        final PreparedStatement pstmt,
+        final Object[] parameters
+    ) throws SQLException {
+        for (int index = 1; index <= parameters.length; index++) {
+            pstmt.setObject(index, parameters[index - 1]);
+        }
+    }
+
+    public <T> T executeQuery(
+        final String sql,
+        final Mapper<T> mapper,
+        final Object... objects) {
+
+        try (final Connection connection = dataSource.getConnection();
+            final PreparedStatement pstmt = connection.prepareStatement(sql)) {
+            setPreparedStatement(pstmt, objects);
+            final ResultSet rs = pstmt.executeQuery();
+            log.debug("query : {}", sql);
+            if (rs.next()) {
+                return mapper.map(rs);
+            }
+            return null;
+        } catch (SQLException e) {
+            log.error(e.getMessage(), e);
+            throw new RuntimeException(e);
+        }
+    }
 }

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

@@ -0,0 +1,9 @@
+package org.springframework.jdbc.core;
+
+import java.sql.ResultSet;
+import java.sql.SQLException;
+
+public interface Mapper<T> {
+
+    T map(final ResultSet resultSet) throws SQLException;
+}

jdbc/src/test/java/org/springframework/jdbc/core/JdbcTemplateTest.java

@@ -0,0 +1,73 @@
+package org.springframework.jdbc.core;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertAll;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.springframework.jdbc.core.test_supporter.DataSourceConfig;
+import org.springframework.jdbc.core.test_supporter.DatabasePopulatorUtils;
+import org.springframework.jdbc.core.test_supporter.User;
+import org.springframework.jdbc.core.test_supporter.UserDao;
+
+class JdbcTemplateTest {
+
+    private final JdbcTemplate jdbcTemplate = new JdbcTemplate(DataSourceConfig.getInstance());
+    private final UserDao userDao = new UserDao(DataSourceConfig.getInstance());
+
+    @BeforeEach
+    void setUp() {
+        DatabasePopulatorUtils.execute(DataSourceConfig.getInstance());
+    }
+
+    @Test
+    @DisplayName("execute Query로 읽는 쿼리를 실행할 수 있다.")
+    void executeQuery() {
+        final User user = new User("hong-sile", "hong", "[email protected]");
+        userDao.insert(user);
+        final String sql = "select id, account, password, email from users where id = ?";
+        final Long id = 1L;
+
+        final User actual = jdbcTemplate.executeQuery(sql, (rs) ->
+                new User(
+                    rs.getLong(1),
+                    rs.getString(2),
+                    rs.getString(3),
+                    rs.getString(4)
+                )
+            , id);
+
+        assertAll(
+            () -> assertThat(id)
+                .isEqualTo(actual.getId()),
+            () -> assertThat(actual)
+                .usingRecursiveComparison()
+                .ignoringFields("id")
+                .isEqualTo(user)
+        );
+    }
+
+    @Test
+    @DisplayName("execute로 쓰는 쿼리를 실행할 수 있다.")
+    void execute() {
+        final User user = new User("hong-sile", "hong", "[email protected]");
+        final String sql = "insert into users (account, password, email) values (?, ?, ?)";
+
+        final Long id = jdbcTemplate.executeUpdate(
+            sql,
+            user.getAccount(), user.getPassword(), user.getEmail()
+        );
+
+        final User actual = userDao.findById(id);
+
+        assertAll(
+            () -> assertThat(id)
+                .isEqualTo(actual.getId()),
+            () -> assertThat(actual)
+                .usingRecursiveComparison()
+                .ignoringFields("id")
+                .isEqualTo(user)
+        );
+    }
+}

jdbc/src/test/java/org/springframework/jdbc/core/test_supporter/DataSourceConfig.java

@@ -0,0 +1,26 @@
+package org.springframework.jdbc.core.test_supporter;
+
+import java.util.Objects;
+import org.h2.jdbcx.JdbcDataSource;
+
+public class DataSourceConfig {
+
+    private static javax.sql.DataSource INSTANCE;
+
+    public static javax.sql.DataSource getInstance() {
+        if (Objects.isNull(INSTANCE)) {
+            INSTANCE = createJdbcDataSource();
+        }
+        return INSTANCE;
+    }
+
+    private static JdbcDataSource createJdbcDataSource() {
+        final var jdbcDataSource = new JdbcDataSource();
+        jdbcDataSource.setUrl("jdbc:h2:mem:test;DB_CLOSE_DELAY=-1;");
+        jdbcDataSource.setUser("");
+        jdbcDataSource.setPassword("");
+        return jdbcDataSource;
+    }
+
+    private DataSourceConfig() {}
+}