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

build.gradle

@@ -9,6 +9,10 @@ repositories {
 }
 
 dependencies {
+
+    implementation 'com.zaxxer:HikariCP:7.0.2'
+//    implementation 'ch.qos.logback:logback-classic:1.4.14'
+    implementation 'com.h2database:h2:2.2.224'
     testImplementation platform('org.junit:junit-bom:5.11.4')
     testImplementation platform('org.assertj:assertj-bom:3.27.3')
     testImplementation('org.junit.jupiter:junit-jupiter')
@@ -21,6 +25,18 @@ java {
     }
 }
 
+tasks.withType(JavaCompile) {
+    options.compilerArgs += ['--enable-preview']
+}
+
+tasks.withType(Test) {
+    jvmArgs(['--enable-preview'])
+}
+
+tasks.withType(JavaExec) {
+    jvmArgs(['--enable-preview'])
+}
+
 test {
     useJUnitPlatform()
 }

src/main/java/Application.java

@@ -1,17 +1,9 @@
+import config.JanggiConfig;
 import controller.JanggiController;
-import domain.Board;
-import domain.GameStatus;
-import domain.JanggiGame;
-import factory.JanggiBoardFactory;
 
 public class Application {
     public static void main(String[] args) {
-        JanggiBoardFactory janggiBoardFactory = new JanggiBoardFactory();
-        Board board = Board.of(janggiBoardFactory.initialBoard());
-
-        JanggiGame janggiGame = new JanggiGame(board, GameStatus.GREEN_PLAYER_TURN);
-        JanggiController janggiController = new JanggiController(janggiGame);
-
+        JanggiController janggiController = JanggiConfig.setupController();
         janggiController.run();
     }
 }

src/main/java/config/JanggiConfig.java

@@ -0,0 +1,57 @@
+package config;
+
+import com.zaxxer.hikari.HikariConfig;
+import com.zaxxer.hikari.HikariDataSource;
+import controller.JanggiController;
+import dao.JanggiGameDao;
+import dao.JanggiGameStateDao;
+import infrastructure.TransactionContext;
+import java.sql.Connection;
+import java.sql.SQLException;
+import java.sql.Statement;
+import javax.sql.DataSource;
+import repository.JanggiRepository;
+import repository.JdbcJanggiRepository;
+import service.JanggiCommandService;
+import service.JanggiQueryService;
+
+public class JanggiConfig {
+
+    public static JanggiController setupController() {
+        JanggiRepository janggiRepository = setupJanggiRepository();
+
+        JanggiCommandService janggiCommandService = new JanggiCommandService(janggiRepository);
+        JanggiQueryService janggiQueryService = new JanggiQueryService(janggiRepository);
+
+        return new JanggiController(janggiCommandService, janggiQueryService);
+    }
+
+    private static DataSource dataSource() {
+        HikariConfig config = new HikariConfig();
+        config.setJdbcUrl("jdbc:h2:file:./janggi_db;MODE=MySQL");
+        config.setUsername("root");
+        config.setPassword("password");
+        return new HikariDataSource(config);
+    }
+
+    private static JdbcJanggiRepository setupJanggiRepository() {
+        DataSource dataSource = dataSource();
+        try {
+            initSchema(dataSource);
+        } catch (SQLException e) {
+            throw new RuntimeException("스키마 초기화 실패", e);
+        }
+        TransactionContext.init(dataSource);
+        return new JdbcJanggiRepository(
+                new JanggiGameDao(),
+                new JanggiGameStateDao()
+        );
+    }
+
+    private static void initSchema(DataSource dataSource) throws SQLException {
+        try (Connection conn = dataSource.getConnection();
+             Statement stmt = conn.createStatement()) {
+            stmt.execute("RUNSCRIPT FROM 'classpath:schema.sql'");
+        }
+    }
+}

src/main/java/controller/ExecutableTask.java

@@ -1,6 +1,8 @@
 package controller;
 
+import exception.JanggiGameException;
+
 @FunctionalInterface
 interface ExecutableTask {
-    void execute() throws IllegalArgumentException;
+    void execute() throws JanggiGameException;
 }

src/main/java/controller/JanggiController.java

@@ -1,50 +1,104 @@
 package controller;
 
-import domain.JanggiGame;
 import domain.Position;
+import dto.SelectResumeOptionRequest;
 import dto.SelectPositionRequest;
+import dto.SelectSavedGameRequest;
 import exception.JanggiGameException;
+import java.util.function.Supplier;
+import service.JanggiCommandService;
+import service.JanggiQueryService;
 import view.InputView;
 import view.OutputView;
 
 public class JanggiController {
 
-    private final JanggiGame janggiGame;
+    private final JanggiCommandService commandService;
+    private final JanggiQueryService queryService;
 
-    public JanggiController(JanggiGame janggiGame) {
-        this.janggiGame = janggiGame;
+    private long currentGameId = 0L;
+
+    public JanggiController(JanggiCommandService commandService, JanggiQueryService queryService) {
+        this.commandService = commandService;
+        this.queryService = queryService;
     }
 
     public void run() {
-        while (!janggiGame.isGameFinished()) {
-            runPlayingPhase();
+        if(executeWithReturn(this::isPlayerWantPlayingUnfinishedGame)) {
+            runSavedGame();
+            return;
+        }
+        runNewGame();
+    }
+
+    private void runSavedGame() {
+        execute(this::setupSavedGameId);
+        runGame();
+    }
+
+    private void setupSavedGameId() {
+        SelectSavedGameRequest request = InputView.selectSavedGameId(queryService.findUnfinishedGameInfos());
+        queryService.isInProgress(request.gameId());
+        currentGameId = request.gameId();
+    }
+
+    private boolean isPlayerWantPlayingUnfinishedGame() {
+        if(queryService.hasUnfinishedGameId()) {
+            SelectResumeOptionRequest request = InputView.selectLoadGameOrNewGame();
+            return request.select();
         }
+        return false;
+    }
+
+    private void runNewGame() {
+        setupNewGameId();
+        runGame();
+    }
+
+    private void runGame() {
+        runPlayingPhase();
         runResultPhase();
     }
 
+    private void setupNewGameId() {
+        currentGameId = commandService.setupGame();
+    }
+
     private void runPlayingPhase() {
-        displayCurrentGameState();
-        execute(this::movePiece);
+        while (queryService.isInProgress(currentGameId)) {
+            displayCurrentGameState();
+            execute(this::movePiece);
+        }
     }
 
     private void displayCurrentGameState() {
-        OutputView.printBoard(janggiGame.allFactors());
-        OutputView.printCurrentPlayerTurn(janggiGame.currentPlayerTurn());
+        OutputView.printBoard(queryService.allFactors(currentGameId));
+        OutputView.printCurrentPlayerTurn(queryService.currentPlayerTurn(currentGameId));
+        OutputView.printCurrentPlayerPiecesPointSum(queryService.currentPlayerPiecesPointSum(currentGameId));
     }
 
     private void movePiece() {
+        Position selected = selectPiecePositionToMove();
+        Position target = selectPiecePositionToGoFrom(selected);
+
+        commandService.move(currentGameId, selected, target);
+    }
+
+    private Position selectPiecePositionToMove() {
         SelectPositionRequest selectRequest = InputView.selectPiecePosition();
-        Position selected = Position.of(selectRequest.row(), selectRequest.col());
+        return Position.of(selectRequest.row(), selectRequest.col());
+    }
 
-        SelectPositionRequest targetRequest = InputView.selectTargetPositionOf(janggiGame.findPieceInfoAt(selected));
-        Position target = Position.of(targetRequest.row(), targetRequest.col());
+    private Position selectPiecePositionToGoFrom(Position selected) {
+        SelectPositionRequest targetRequest =
+                InputView.selectTargetPositionWith(queryService.findPieceInfoAt(currentGameId, selected));
 
-        janggiGame.move(selected, target);
+        return Position.of(targetRequest.row(), targetRequest.col());
     }
 
     private void runResultPhase() {
-        OutputView.printBoard(janggiGame.allFactors());
-        OutputView.printResult(janggiGame.gameStatus());
+        OutputView.printBoard(queryService.allFactors(currentGameId));
+        OutputView.printResult(queryService.gameStatus(currentGameId));
     }
 
     private void execute(ExecutableTask task) {
@@ -59,4 +113,17 @@ private void execute(ExecutableTask task) {
             }
         }
     }
+
+    private <T> T executeWithReturn(Supplier<T> task) {
+        while (true) {
+            try {
+                T result = task.get();
+                OutputView.printTaskDivider();
+                return result;
+            } catch (JanggiGameException e) {
+                OutputView.printError(e.getMessage());
+                OutputView.printTaskDivider();
+            }
+        }
+    }
 }

src/main/java/dao/JanggiGameDao.java

@@ -0,0 +1,113 @@
+package dao;
+
+import dto.PieceSnapshot;
+import dto.UnfinishedGameInfo;
+import infrastructure.TransactionContext;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+
+public class JanggiGameDao {
+
+    public long insertGame(List<PieceSnapshot> pieces) throws SQLException {
+        long gameId = insert();
+        insertPieces(gameId, pieces);
+        return gameId;
+    }
+
+    public long updateGame(long gameId, List<PieceSnapshot> pieces) throws SQLException {
+        deletePieces(gameId);
+        insertPieces(gameId, pieces);
+        return gameId;
+    }
+
+    private long insert() throws SQLException {
+        String sql = "INSERT INTO game (created_at) VALUES (NOW())";
+
+        try (PreparedStatement ps = TransactionContext.getPreparedStatement(sql, Statement.RETURN_GENERATED_KEYS)) {
+            ps.executeUpdate();
+
+            ResultSet keys = ps.getGeneratedKeys();
+            if (keys.next()) {
+                return keys.getLong(1);
+            }
+            throw new SQLException("game INSERT 후 id 획득 실패");
+        }
+    }
+
+    private void deletePieces(long gameId) throws SQLException {
+        String sql = "DELETE FROM piece WHERE game_id = ?";
+        try (PreparedStatement ps = TransactionContext.getPreparedStatement(sql)) {
+            ps.setLong(1, gameId);
+            ps.executeUpdate();
+        }
+    }
+
+    private void insertPieces(long gameId, List<PieceSnapshot> pieces) throws SQLException {
+        String sql = "INSERT INTO piece (game_id, pos_row, pos_col, piece_name, team) VALUES (?, ?, ?, ?, ?)";
+
+        try (PreparedStatement ps = TransactionContext.getPreparedStatement(sql)) {
+            for (PieceSnapshot piece : pieces) {
+                ps.setLong(1, gameId);
+                ps.setInt(2, piece.row());
+                ps.setInt(3, piece.col());
+                ps.setString(4, piece.name());
+                ps.setString(5, piece.team());
+                ps.addBatch();
+            }
+            ps.executeBatch();
+        }
+    }
+
+    public List<PieceSnapshot> findAllPieces(long gameId) throws SQLException {
+        String sql = "SELECT pos_row, pos_col, piece_name, team FROM piece WHERE game_id = ?";
+
+        try (PreparedStatement ps = TransactionContext.getPreparedStatement(sql)) {
+            ps.setLong(1, gameId);
+
+            ResultSet rs = ps.executeQuery();
+            List<PieceSnapshot> pieces = new ArrayList<>();
+            while (rs.next()) {
+                pieces.add(PieceSnapshot.from(
+                        rs.getInt("pos_row"),
+                        rs.getInt("pos_col"),
+                        rs.getString("piece_name"),
+                        rs.getString("team")
+                ));
+            }
+            return pieces;
+        }
+    }
+
+    public Optional<Long> findLatestUnfinishedGameId() throws SQLException {
+        String sql = "SELECT game_id FROM game_state WHERE is_finished = false ORDER BY last_played_at DESC LIMIT 1";
+
+        try (PreparedStatement ps =  TransactionContext.getPreparedStatement(sql);
+             ResultSet rs = ps.executeQuery()) {
+            if (rs.next()) {
+                return Optional.of(rs.getLong("game_id"));
+            }
+            return Optional.empty();
+        }
+    }
+
+    public List<UnfinishedGameInfo> findUnfinishedGameInfos() throws SQLException {
+        String sql = "SELECT game_id, last_played_at FROM game_state WHERE is_finished = false ORDER BY last_played_at ASC";
+
+        try (PreparedStatement ps = TransactionContext.getPreparedStatement(sql)){
+            ResultSet rs = ps.executeQuery();
+            List<UnfinishedGameInfo> unfinishedGames = new ArrayList<>();
+            while (rs.next()) {
+                unfinishedGames.add(UnfinishedGameInfo.from(
+                        rs.getLong("game_id"),
+                        rs.getTimestamp("last_played_at").toLocalDateTime()
+                ));
+            }
+            return unfinishedGames;
+        }
+    }
+}