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

build.gradle

@@ -9,6 +9,9 @@ repositories {
 }
 
 dependencies {
+    implementation 'com.zaxxer:HikariCP:6.0.0'
+    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')

src/main/java/Application.java

@@ -1,19 +1,71 @@
+import com.zaxxer.hikari.HikariConfig;
+import com.zaxxer.hikari.HikariDataSource;
 import controller.GameController;
+import data.BoardDto;
+import data.BoardRepository;
+import data.TransactionManager;
 import domain.board.Board;
 import domain.board.BoardInitializer;
+import domain.piece.Camp;
 import view.InputView;
+import view.OutputView;
+
+import java.util.List;
 
 public class Application {
     public static void main(String[] args) {
-        Board board = new Board(BoardInitializer.init(InputView.readBoardSetting()));
-        GameController gameController = new GameController(board);
+        try (HikariDataSource hikariDataSource = createDataSource()) {
+            TransactionManager transactionManager = new TransactionManager(hikariDataSource);
+
+            BoardRepository boardRepository = new BoardRepository();
+
+            Board board = initBoard(transactionManager, boardRepository);
+
+            GameController gameController = new GameController(board, boardRepository, transactionManager);
+            gameController.run();
 
-        while (!board.isGameOver()) {
-            gameController.printBoard();
-            gameController.move();
+            OutputView.printBoard(board);
+            OutputView.printWinner(board.winner(), board.score(Camp.CHO), board.score(Camp.HAN));
+
+            transactionManager.executeTransaction(connection -> {
+                        boardRepository.delete(connection, board);
+                        return null;
+                    }
+            );
         }
+    }
+
+    private static HikariDataSource createDataSource() {
+        HikariConfig hikariConfig = new HikariConfig();
+        hikariConfig.setJdbcUrl("jdbc:h2:~/janggi;INIT=RUNSCRIPT FROM 'src/main/resources/create_tables.sql'");
+        hikariConfig.setDriverClassName("org.h2.Driver");
+        hikariConfig.setUsername("sa");
+        hikariConfig.setPassword("");
+
+        return new HikariDataSource(hikariConfig);
+    }
+
+    private static Board initBoard(TransactionManager transactionManager, BoardRepository boardRepository) {
+        printSavedBoards(transactionManager, boardRepository);
+        int boardId = InputView.readBoardNumber();
+
+        Board board;
+        if (boardId == 0) {
+            board = Board.from(BoardInitializer.init(InputView.readBoardSetting()));
+            transactionManager.executeTransaction(connection -> {
+                boardRepository.save(connection, board);
+                return null;
+            });
+            return board;
+        }
+        return transactionManager.executeTransaction(connection -> boardRepository.findById(connection, (long) boardId));
+    }
 
-        gameController.printBoard();
-        gameController.printWinner();
+    private static void printSavedBoards(TransactionManager transactionManager, BoardRepository boardRepository) {
+        transactionManager.executeTransaction(connection -> {
+            List<BoardDto> boards = boardRepository.findAll(connection);
+            OutputView.printBoards(boards);
+            return null;
+        });
     }
 }

src/main/java/controller/GameController.java

@@ -1,39 +1,48 @@
 
 package controller;
 
+import data.BoardRepository;
+import data.TransactionManager;
 import domain.board.Board;
 import domain.board.Position;
 import view.InputView;
 import view.OutputView;
 
 public class GameController {
     private final Board board;
+    private final BoardRepository boardRepository;
+    private final TransactionManager transactionManager;
 
-    public GameController(Board board) {
+    public GameController(Board board, BoardRepository boardRepository, TransactionManager transactionManager) {
         this.board = board;
+        this.boardRepository = boardRepository;
+        this.transactionManager = transactionManager;
     }
 
-    public void move() {
-        while (true) {
+    public void run(){
+        while (board.isGameInProgress()) {
+            OutputView.printBoard(board);
             try {
                 Position departure = parsePosition(InputView.readDeparturePosition());
                 Position destination = parsePosition(InputView.readDestinationPosition());
-                board.move(departure, destination);
-                return;
-            } catch (IllegalArgumentException exception) {
-                OutputView.printError(exception.getMessage());
+
+                transactionManager.executeTransaction(connection -> {
+                    board.move(departure, destination);
+                    boardRepository.save(connection, board);
+                    return null;
+                });
+            } catch (IllegalArgumentException e) {
+                System.out.println(e.getMessage());
+            } catch (RuntimeException e) {
+                if (e.getCause() instanceof IllegalArgumentException cause) {
+                    System.out.println(cause.getMessage());
+                    continue;
+                }
+                throw e;
             }
         }
     }
 
-    public void printBoard() {
-        OutputView.printBoard(board);
-    }
-
-    public void printWinner() {
-        OutputView.printWinner(board.winner());
-    }
-
     private Position parsePosition(String value) {
         String[] tokens = value.split(",");
         if (tokens.length != 2) {

src/main/java/data/BoardDao.java

@@ -0,0 +1,111 @@
+package data;
+
+import domain.piece.Camp;
+
+import java.sql.*;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+
+public class BoardDao {
+    public Long insertBoard(Connection connection, boolean gameInProgress, String turn) {
+        String sql = "INSERT INTO boards (`game_in_progress`, `turn`) VALUES (?, ?)";
+        try (
+                PreparedStatement preparedStatement = connection.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS)
+        ) {
+            preparedStatement.setBoolean(1, gameInProgress);
+            preparedStatement.setString(2, turn);
+
+            preparedStatement.executeUpdate();
+
+            return getGenerateId(preparedStatement);
+
+        } catch (SQLException e) {
+            throw new IllegalStateException("데이터 삽입에 실패했습니다.", e);
+        }
+    }
+
+    public Optional<BoardDto> getBoard(Connection connection, Long boardId) {
+        String sql = "SELECT `id`, `game_in_progress`, `turn` FROM boards WHERE `id` = (?)";
+        try (
+                PreparedStatement preparedStatement = connection.prepareStatement(sql)
+        ) {
+            preparedStatement.setLong(1, boardId);
+
+            return getBoardDto(preparedStatement);
+        } catch (SQLException e) {
+            throw new IllegalStateException("데이터 조회에 실패했습니다.", e);
+        }
+
+    }
+
+    public List<BoardDto> getAllBoards(Connection connection) {
+        String sql = "SELECT `id`, `game_in_progress`, `turn` FROM boards WHERE `game_in_progress` = true ORDER BY `id`";
+        List<BoardDto> boards = new ArrayList<>();
+
+        try (PreparedStatement preparedStatement = connection.prepareStatement(sql);
+             ResultSet resultSet = preparedStatement.executeQuery()) {
+            while (resultSet.next()) {
+                boards.add(mapRow(resultSet));
+            }
+            return boards;
+        } catch (SQLException e) {
+            throw new IllegalStateException("데이터 조회에 실패했습니다.", e);
+        }
+    }
+
+
+    public void deleteBoard(Connection connection, Long boardId) {
+        String sql = "DELETE FROM boards WHERE `id`=(?)";
+        try (
+                PreparedStatement preparedStatement = connection.prepareStatement(sql)
+        ) {
+            preparedStatement.setLong(1, boardId);
+
+            preparedStatement.executeUpdate();
+        } catch (SQLException e) {
+            throw new IllegalStateException("데이터 삭제에 실패했습니다.", e);
+        }
+    }
+
+    public void updateBoard(Connection connection, Long boardId, boolean gameInProgress, String turn) {
+        String sql = "UPDATE boards SET `game_in_progress` = (?), `turn` = (?) WHERE `id` = (?)";
+        try (
+                PreparedStatement preparedStatement = connection.prepareStatement(sql)
+        ) {
+            preparedStatement.setBoolean(1, gameInProgress);
+            preparedStatement.setString(2, turn);
+            preparedStatement.setLong(3, boardId);
+
+            preparedStatement.executeUpdate();
+        } catch (SQLException e) {
+            throw new IllegalStateException("데이터 수정에 실패했습니다.", e);
+        }
+    }
+
+    private Long getGenerateId(PreparedStatement preparedStatement) throws SQLException {
+        try (ResultSet resultSet = preparedStatement.getGeneratedKeys()) {
+            if (resultSet.next()) {
+                return resultSet.getLong(1);
+            }
+            throw new IllegalArgumentException("ID를 조회할 수 없습니다.");
+        }
+    }
+
+    private Optional<BoardDto> getBoardDto(PreparedStatement preparedStatement) throws SQLException {
+        try (ResultSet resultSet = preparedStatement.executeQuery()) {
+            if (!resultSet.next()) {
+                return Optional.empty();
+            }
+            return Optional.of(mapRow(resultSet));
+        }
+    }
+
+    private BoardDto mapRow(ResultSet resultSet) throws SQLException {
+        return new BoardDto(
+                resultSet.getLong("id"),
+                resultSet.getBoolean("game_in_progress"),
+                Camp.valueOf(resultSet.getString("turn"))
+        );
+    }
+}

src/main/java/data/BoardDto.java

@@ -0,0 +1,10 @@
+package data;
+
+import domain.piece.Camp;
+
+public record BoardDto(
+        Long id,
+        boolean gameInProgress,
+        Camp turn
+) {
+}

src/main/java/data/BoardRepository.java

@@ -0,0 +1,69 @@
+package data;
+
+import domain.board.Board;
+import domain.board.Position;
+import domain.piece.Camp;
+import domain.piece.Piece;
+import domain.piece.PieceType;
+
+import java.sql.Connection;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class BoardRepository {
+    private final PieceDao pieceDao = new PieceDao();
+    private final BoardDao boardDao = new BoardDao();
+
+    public void save(Connection connection, Board board) {
+        Map<Position, Piece> pieces = board.pieces();
+
+        Long boardId;
+        if (board.id() == null) {
+            boardId = boardDao.insertBoard(connection, board.isGameInProgress(), board.turn().name());
+            board.assignId(boardId);
+        } else {
+            boardId = board.id();
+            boardDao.updateBoard(connection, boardId, board.isGameInProgress(), board.turn().name());
+            pieceDao.deleteAllByBoard(connection, boardId);
+        }
+
+        pieces.forEach((position, piece) ->
+                pieceDao.insertPiece(connection, boardId, piece.pieceType().name(),
+                        piece.camp().name(), position.column(), position.row())
+        );
+    }
+
+    public Board findById(Connection connection, Long boardId) {
+        BoardDto boardDto = boardDao.getBoard(connection, boardId).orElseThrow(() ->
+                new IllegalArgumentException("존재하지 않는 장기판입니다."));
+        List<PieceDto> piecesInfo = pieceDao.getAllPieceByBoard(connection, boardId);
+
+        Map<Position, Piece> pieces = new HashMap<>();
+        for (PieceDto piece : piecesInfo) {
+            Camp camp = piece.camp();
+            PieceType pieceType = piece.type();
+            pieces.put(new Position(piece.column(), piece.row()),
+                    Piece.of(camp, pieceType));
+        }
+
+        Board board = new Board(pieces, boardDto.gameInProgress(), boardDto.turn());
+        board.assignId(boardDto.id());
+        return board;
+    }
+
+    public List<BoardDto> findAll(Connection connection) {
+        return boardDao.getAllBoards(connection);
+    }
+
+    public void delete(Connection connection, Board board) {
+        Long boardId = board.id();
+
+        if (boardId == null) {
+            throw new IllegalStateException("존재하지 않는 게임입니다.");
+        }
+
+        pieceDao.deleteAllByBoard(connection, boardId);
+        boardDao.deleteBoard(connection, boardId);
+    }
+}