[🚀 사이클2 - 미션 (기물 확장 + DB 적용)] 달수 미션 제출합니다.

.gitignore

@@ -30,3 +30,4 @@ out/
 
 ### VS Code ###
 .vscode/
+src/main/resources/application.properties

build.gradle

@@ -13,6 +13,9 @@ dependencies {
     testImplementation platform('org.assertj:assertj-bom:3.27.3')
     testImplementation('org.junit.jupiter:junit-jupiter')
     testImplementation('org.assertj:assertj-core')
+
+    implementation 'com.mysql:mysql-connector-j:9.3.0'
+    testImplementation 'com.h2database:h2:2.2.224'
 }
 
 java {

init.sql

@@ -0,0 +1,20 @@
+-- 1. 게임 테이블 (메타데이터)
+CREATE TABLE game (
+                      id VARCHAR(36) PRIMARY KEY,
+                      name VARCHAR(50) NOT NULL UNIQUE,
+                      status VARCHAR(20) NOT NULL,       -- PLAYING, CHO_WIN, HAN_WIN, DRAW
+                      current_turn VARCHAR(10) NOT NULL  -- CHO, HAN
+);
+
+-- 2. 기물 상태 테이블 (1번 테이블을 참조)
+CREATE TABLE piece (
+                       id BIGINT AUTO_INCREMENT PRIMARY KEY,
+                       game_id VARCHAR(36) NOT NULL,           -- 어떤 게임판에 속해있는지 (FK)
+                       piece_name VARCHAR(20) NOT NULL,   -- CHO_SOLDIER, HAN_CHARIOT 등
+                       camp VARCHAR(3) NOT NULL,
+                       row_index INT NOT NULL,            -- Y 좌표 (0~9)
+                       column_index INT NOT NULL,         -- X 좌표 (0~8)
+
+
+                       FOREIGN KEY (game_id) REFERENCES game(id) ON DELETE CASCADE
+);

src/main/java/janggi/config/AppConfig.java

@@ -1,11 +1,58 @@
 package janggi.config;
 
 import janggi.controller.JanggiController;
+import janggi.persistence.GameRepositoryImpl;
+import janggi.persistence.dao.GameDao;
+import janggi.persistence.dao.JdbcGameDao;
+import janggi.persistence.dao.JdbcPieceDao;
+import janggi.persistence.dao.PieceDao;
+import janggi.persistence.mapper.GameMapper;
+import janggi.persistence.mapper.PieceMapper;
+import janggi.service.GameRepository;
+import janggi.service.JanggiService;
 import janggi.view.InputView;
 import janggi.view.OutputView;
 
 public class AppConfig {
+    private final ConnectionPool connectionPool = DatabaseConfig.getPool();
+
     public JanggiController janggiController() {
-        return new JanggiController(new InputView(), new OutputView());
+        return new JanggiController(inputView(), outputView(), janggiService());
+    }
+
+    public InputView inputView() {
+        return new InputView();
+    }
+
+    public OutputView outputView() {
+        return new OutputView();
+    }
+
+    public JanggiService janggiService() {
+        return new JanggiService(gameRepository(), transactionManager());
+    }
+
+    public TransactionManager transactionManager() {
+        return new TransactionManager(connectionPool);
+    }
+
+    public GameRepository gameRepository() {
+        return new GameRepositoryImpl(gameDao(), pieceDao(), gameMapper(), pieceMapper());
+    }
+
+    public GameDao gameDao() {
+        return new JdbcGameDao(connectionPool);
+    }
+
+    public PieceDao pieceDao() {
+        return new JdbcPieceDao(connectionPool);
+    }
+
+    public GameMapper gameMapper() {
+        return new GameMapper();
+    }
+
+    public PieceMapper pieceMapper() {
+        return new PieceMapper();
     }
 }

src/main/java/janggi/config/ConnectionPool.java

@@ -0,0 +1,99 @@
+package janggi.config;
+
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.SQLException;
+import java.util.concurrent.ArrayBlockingQueue;
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.TimeUnit;
+
+public class ConnectionPool {
+    private final BlockingQueue<Connection> pool;
+    private final String url;
+    private final String username;
+    private final String password;
+    private final long timeoutMillis;
+
+    private final int poolSize;
+
+    ConnectionPool(String url, String username, String password, int poolSize) {
+        this.url = url;
+        this.username = username;
+        this.password = password;
+        this.timeoutMillis = 5000;
+        this.poolSize = poolSize;
+
+        this.pool = new ArrayBlockingQueue<>(this.poolSize);
+
+        try {
+            for (int i = 0; i < this.poolSize; i++) {
+                pool.offer(createConnection());
+            }
+        } catch (SQLException e) {
+            throw new RuntimeException("커넥션 풀 초기화 실패", e);
+        }
+    }
+
+    private Connection createConnection() throws SQLException {
+        return DriverManager.getConnection(url, username, password);
+    }
+
+    public Connection getConnection() {
+        try {
+            Connection conn = pool.poll(timeoutMillis, TimeUnit.MILLISECONDS);
+            if (conn == null) {
+                throw new RuntimeException("커넥션 획득 대기 시간 초과 (Timeout)");
+            }
+
+            if (!conn.isValid(1)) {
+                try {
+                    conn.close();
+                } catch (SQLException ignored) {}
+                conn = createConnection();
+            }
+
+            return conn;
+        } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
+            throw new RuntimeException("커넥션 대기 중 인터럽트 발생", e);
+        } catch (SQLException e) {
+            throw new RuntimeException("유효하지 않은 커넥션 재설정 및 검증 실패", e);
+        }
+    }
+
+    public void release(Connection conn) {
+        if (conn != null) {
+            try {
+                if (!conn.isClosed()) {
+                    conn.setAutoCommit(true);
+                    pool.offer(conn);
+                }
+            } catch (SQLException e) {
+                try {
+                    conn.close();
+                } catch (SQLException ignored) {}
+            }
+        }
+    }
+
+    public void shutdown() {
+        Connection conn;
+        while ((conn = pool.poll()) != null) {
+            try {
+                conn.close();
+            } catch (SQLException ignored) {}
+        }
+    }
+
+    public PooledConnection getPooledConnection() {
+        return new PooledConnection(getConnection(), this);
+    }
+
+    public int getAvailableCount() {
+        return pool.size();
+    }
+
+    public int getActiveCount() {
+        return poolSize - pool.size();
+    }
+}

src/main/java/janggi/config/DatabaseConfig.java

@@ -0,0 +1,42 @@
+package janggi.config;
+
+import java.io.InputStream;
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.SQLException;
+import java.util.Properties;
+
+public class DatabaseConfig {
+    private static final Properties properties = new Properties();
+    private static final ConnectionPool connectionPool;
+
+    static {
+        try (InputStream input = DatabaseConfig.class.getResourceAsStream("/application.properties")) {
+            if (input == null) {
+                throw new RuntimeException("application.properties 파일을 찾을 수 없습니다.");
+            }
+            properties.load(input);
+        } catch (Exception e) {
+            throw new RuntimeException("JDBC 초기화 실패", e);
+        }
+
+        connectionPool = new ConnectionPool(
+                properties.getProperty("db.url"),
+                properties.getProperty("db.id"),
+                properties.getProperty("db.password"),
+                5
+        );
+    }
+
+    public static void shutdown() {
+        connectionPool.shutdown();
+    }
+
+    public static PooledConnection getConnection() {
+        return connectionPool.getPooledConnection();
+    }
+
+    public static ConnectionPool getPool() {
+        return connectionPool;
+    }
+}

src/main/java/janggi/config/PooledConnection.java

@@ -0,0 +1,22 @@
+package janggi.config;
+
+import java.sql.Connection;
+
+public class PooledConnection implements AutoCloseable{
+    private final Connection conn;
+    private final ConnectionPool pool;
+
+    PooledConnection(Connection conn, ConnectionPool pool) {
+        this.conn = conn;
+        this.pool = pool;
+    }
+
+    public Connection getConnection() {
+        return conn;
+    }
+
+    @Override
+    public void close() {
+        pool.release(conn);
+    }
+}

src/main/java/janggi/config/TransactionCallback.java

@@ -0,0 +1,9 @@
+package janggi.config;
+
+import java.sql.Connection;
+import java.sql.SQLException;
+
+@FunctionalInterface
+public interface TransactionCallback<T> {
+    T run(Connection conn) throws SQLException;
+}

src/main/java/janggi/config/TransactionManager.java

@@ -0,0 +1,28 @@
+package janggi.config;
+
+import java.sql.Connection;
+import java.sql.SQLException;
+
+public class TransactionManager {
+    private final ConnectionPool pool;
+
+    public TransactionManager(ConnectionPool pool) {
+        this.pool = pool;
+    }
+
+    public <T> T execute(TransactionCallback<T> callback) {
+        PooledConnection pooledConn = pool.getPooledConnection();
+        Connection conn = pooledConn.getConnection();
+        try {
+            conn.setAutoCommit(false);
+            T result = callback.run(conn);
+            conn.commit();
+            return result;
+        } catch (Exception e) {
+            try { conn.rollback(); } catch (SQLException ignored) {}
+            throw new RuntimeException("트랜잭션 실행 중 오류가 발생했습니다.", e);
+        } finally {
+            pooledConn.close();
+        }
+    }
+}