[4단계 - DB 적용] 이준섭 미션 제출합니다.

README.md

@@ -33,13 +33,52 @@
 - [x] 체스 말이 반환한 경로 안에 다른 체스 말이 있는지 검사
   - [x] 경로 안에 다른 체스 말이 있다면 이동할 수 없다 <- Path
 - **입력**
-- [x] move source위치 target위치을 실행해 이동한다
+- [x] move source 위치 target 위치을 실행해 이동한다
 
 ## 3단계 - 승패 및 점수
 ### 기능 요구 사항
-- [x] King이 잡혔을 때 게임을 종료해야 한다
+- [x] King 이 잡혔을 때 게임을 종료해야 한다
   - [x] 체스판에서 잡힌 말을 반환
   - [x] 체스 말에서 해당 말의 타입을 반환
 - [x] status 명령어를 입력하면 점수를 출력
   - [x] 점수를 계산하는 ScoreCalculator 클래스
     - [x] 같은 File 에 있는 Pawn 은 0.5점을 준다
+
+## 4단계 - DB 적용
+### 기능 요구 사항
+- **DB 연결 전 기능**
+- [x] end 명령어를 입력하면 각자의 점수와 승리 팀을 출력한다
+  - [x] 점수를 계산해서 점수가 높은 팀이 승리한다
+- **DB 연결**
+- [x] 애플리케이션을 재시작하더라도 이전에 하던 체스 게임을 다시 시작할 수 있어야 한다
+  - [x] 이어하기
+    - 이전에 진행하던 게임이 있다면 이어서 게임을 시작한다
+    - 이전에 진행하던 게임이 없다면 새로운 게임을 시작한다
+  - [x] 새로하기
+    - 이전에 진행하던 게임이 있어도 새로운 게임을 시작한다
+
+- chessGame 을 따로 저장, Turn 을 저장할 필요가 있음, 게임의 진행 상태를 저장할 필요가 있음
+
+- [x] 피스를 이동할 때 마다 피스 테이블을 업데이트한다
+- [x] 체스 게임을 저장할 수 있다
+- [x] 체스 게임을 찾을 수 있다
+- [x] 체스 게임을 삭제할 수 있다
+
+```
+CREATE TABLE chess_game (
+    id BIGINT NOT NULL AUTO_INCREMENT,
+    turn VARCHAR(16) NOT NULL,
+    PRIMARY KEY (id)
+);
+
+CREATE TABLE piece (
+    id BIGINT NOT NULL AUTO_INCREMENT,
+    chess_game_id BIGINT NOT NULL,
+    piece_file INT NOT NULL,
+    piece_rank INT NOT NULL,
+    color VARCHAR(16),
+    type VARCHAR(16),
+    PRIMARY KEY (id)
+);
+
+```

build.gradle

@@ -11,6 +11,8 @@ repositories {
 dependencies {
     testImplementation 'org.assertj:assertj-core:3.22.0'
     testImplementation 'org.junit.jupiter:junit-jupiter:5.8.2'
+
+    runtimeOnly 'mysql:mysql-connector-java:8.0.28'
 }
 
 java {

src/main/java/chess/ChessApplication.java

@@ -1,22 +1,20 @@
 package chess;
 
 import chess.controller.ChessController;
-import chess.model.command.CommandFactory;
-import chess.model.board.InitialBoard;
-import chess.view.InputView;
-import chess.view.OutputView;
+import chess.dao.chessGame.JdbcChessGameDao;
+import chess.dao.piece.JdbcPieceDao;
+import chess.service.ChessGameService;
+import java.sql.SQLException;
 
 public class ChessApplication {
 
-  public static void main(String[] args) {
+  public static void main(String[] args) throws SQLException {
 
-    InputView inputView = new InputView();
-    OutputView outputView = new OutputView();
-    CommandFactory commandFactory = new CommandFactory();
-    InitialBoard initialBoard = new InitialBoard();
+    final JdbcChessGameDao chessGameDao = new JdbcChessGameDao();
+    final JdbcPieceDao PieceDao = new JdbcPieceDao();
+    final ChessGameService chessGameService = new ChessGameService(chessGameDao, PieceDao);
+    final ChessController chessController = new ChessController(chessGameService);
 
-    ChessController chessController = new ChessController(inputView, outputView, commandFactory,
-        initialBoard);
-    chessController.runChess();
+    chessController.run();
   }
 }

src/main/java/chess/controller/ChessController.java

@@ -1,90 +1,52 @@
 package chess.controller;
 
-import chess.model.command.CommandFactory;
-import chess.model.command.CommandLauncher;
-import chess.model.ErrorMessage;
-import chess.model.board.Board;
-import chess.model.board.InitialBoard;
-import chess.model.piece.Piece;
-import chess.model.piece.PieceInfo;
-import chess.model.position.Color;
-import chess.model.position.Position;
-import chess.model.score.ScoreCalculator;
+import chess.controller.command.CommandFactory;
+import chess.controller.command.commands.Command;
+import chess.domain.game.ChessGame;
+import chess.domain.game.State;
+import chess.service.ChessGameService;
 import chess.view.InputView;
 import chess.view.OutputView;
+import java.sql.SQLException;
 
 public class ChessController {
 
-  private final InputView inputView;
-  private final OutputView outputView;
-  private final CommandFactory commandFactory;
-  private final Board board;
-  private Color currentTurn;
-  private boolean isRunning;
+  private final ChessGameService chessGameService;
 
-  public ChessController(InputView inputView, OutputView outputView, CommandFactory commandFactory, InitialBoard initialBoard) {
-    this.inputView = inputView;
-    this.outputView = outputView;
-    this.commandFactory = commandFactory;
-    this.board = initialBoard.createInitialBoard();
-    this.currentTurn = Color.WHITE;
-    this.isRunning = true;
+  public ChessController(ChessGameService chessGameService) {
+    this.chessGameService = chessGameService;
   }
 
-  public void runChess() {
-    outputView.printStartMessage();
-    CommandLauncher receivedCommand = null;
+  public void run() throws SQLException {
+    ChessGame chessGame = executeInitialCommandAndFetchChessGame();
 
-    while (receivedCommand == null) {
-      try {
-        String initialCommandInput = inputView.receiveCommand();
-        receivedCommand = commandFactory.createCommand(initialCommandInput);
-        if (receivedCommand.validateInitialCommandType()) {
-          break;
-        }
-        System.out.println(ErrorMessage.INVALID_INITIAL_COMMAND.getMessage());
-        receivedCommand = null;
-      } catch (IllegalArgumentException exception) {
-        System.out.println(exception.getMessage());
-      }
-    }
-
-    receivedCommand.execute(this);
-
-    while (isRunning) {
-      try {
-        String commandInput = inputView.receiveCommand();
-        receivedCommand = commandFactory.createCommand(commandInput);
-        if (receivedCommand.validateStatusCommandType()) {
-          calculateAndPrintCurrentTurnScore();
-        } else {
-          receivedCommand.execute(this);
-          currentTurn = currentTurn.changeTurn(currentTurn);
-        }
-      } catch (IllegalArgumentException exception) {
-        System.out.println(exception.getMessage());
-      }
+    while (isRunnable(chessGame)) {
+      executeCommand(chessGame);
     }
   }
 
-  public void startGame() {
-    outputView.printBoard(board.getMap());
-  }
-
-  public void endGame() {
-    isRunning = false;
+  private void executeCommand(ChessGame chessGame) {
+    try {
+      Command command = CommandFactory.createCommand(chessGame, InputView.receiveCommand());
+      command.execute(chessGameService);
+    } catch (IllegalArgumentException | UnsupportedOperationException e) {
+      OutputView.printErrorMessage(e);
+      executeCommand(chessGame);
+    }
   }
 
-  public void movePiece(Position source, Position target) {
-    Piece capturedPiece = board.move(source, target, currentTurn);
-    if (capturedPiece != null && capturedPiece.pieceType() == PieceInfo.KING) {
-      endGame();
+  private ChessGame executeInitialCommandAndFetchChessGame() throws SQLException {
+    try {
+      Command command = CommandFactory.createInitialCommand(InputView.receiveInitialCommand());
+      return command.initializeChessGame(chessGameService);
+    } catch (IllegalArgumentException | UnsupportedOperationException e) {
+      OutputView.printErrorMessage(e);
+      return executeInitialCommandAndFetchChessGame();
     }
-    outputView.printBoard(board.getMap());
   }
 
-  public void calculateAndPrintCurrentTurnScore() {
-    double score = ScoreCalculator.calculate(board.getMap(), currentTurn);
-    outputView.printCurrentTurnScore(currentTurn, score);
+  private boolean isRunnable(ChessGame chessGame) {
+    return chessGame.getState().equals(State.RUNNING)
+        || chessGame.getState().equals(State.WAITING);
   }
 }

src/main/java/chess/controller/command/CommandFactory.java

@@ -0,0 +1,46 @@
+package chess.controller.command;
+
+import chess.controller.command.commands.Command;
+import chess.controller.command.commands.ContinueCommand;
+import chess.controller.command.commands.EndCommand;
+import chess.controller.command.commands.MoveCommand;
+import chess.controller.command.commands.NewCommand;
+import chess.controller.command.commands.StartCommand;
+import chess.controller.command.commands.StatusCommand;
+import chess.domain.game.ChessGame;
+import java.util.EnumMap;
+import java.util.List;
+import java.util.Map;
+import java.util.function.BiFunction;
+
+public class CommandFactory {
+
+  private static final int COMMAND_INDEX = 0;
+
+  private static final Map<CommandType, BiFunction<ChessGame, List<String>, Command>> COMMAND_TYPES =
+      new EnumMap<>(CommandType.class);
+
+  private static final Map<CommandType, Command> INITIAL_COMMAND_TYPES = new EnumMap<>(CommandType.class);
+
+  static {
+    COMMAND_TYPES.put(CommandType.START, (chessGame, ignored) -> new StartCommand(chessGame));
+    COMMAND_TYPES.put(CommandType.END, (chessGame, ignored) -> new EndCommand(chessGame));
+    COMMAND_TYPES.put(CommandType.STATUS, (chessGame, ignored) -> new StatusCommand(chessGame));
+    COMMAND_TYPES.put(CommandType.MOVE, MoveCommand::new);
+
+    INITIAL_COMMAND_TYPES.put(CommandType.NEW, new NewCommand());
+    INITIAL_COMMAND_TYPES.put(CommandType.CONTINUE, new ContinueCommand());
+  }
+
+  public static Command createCommand(ChessGame chessGame, String command) {
+    final List<String> commandParts = List.of(command.split(" "));
+    final CommandType commandType = CommandType.findCommand(commandParts.get(COMMAND_INDEX));
+    return COMMAND_TYPES.get(commandType).apply(chessGame, commandParts);
+  }
+
+  public static Command createInitialCommand(String command) {
+    final List<String> commandParts = List.of(command.split(" "));
+    final CommandType commandType = CommandType.findCommand(commandParts.get(COMMAND_INDEX));
+    return INITIAL_COMMAND_TYPES.get(commandType);
+  }
+}

src/main/java/chess/controller/command/CommandType.java

@@ -0,0 +1,26 @@
+package chess.controller.command;
+
+import chess.domain.ErrorMessage;
+import java.util.Arrays;
+
+public enum CommandType {
+  START("start"),
+  END("end"),
+  STATUS("status"),
+  MOVE("move"),
+  NEW("new"),
+  CONTINUE("continue");
+
+  private final String command;
+
+  CommandType(final String command) {
+    this.command = command;
+  }
+
+  public static CommandType findCommand(final String value) {
+    return Arrays.stream(values())
+                 .filter(commandType -> commandType.command.equals(value))
+                 .findAny()
+                 .orElseThrow(() -> new IllegalArgumentException(ErrorMessage.INVALID_COMMAND.getMessage()));
+  }
+}

src/main/java/chess/controller/command/InitialCommandType.java

@@ -0,0 +1,22 @@
+package chess.controller.command;
+
+import chess.domain.ErrorMessage;
+import java.util.Arrays;
+
+public enum InitialCommandType {
+  NEW("new"),
+  CONTINUE("continue");
+
+  private final String command;
+
+  InitialCommandType(String command) {
+    this.command = command;
+  }
+
+  public static InitialCommandType findCommand(final String value) {
+    return Arrays.stream(values())
+                 .filter(command -> command.command.equals(value))
+                 .findAny()
+                 .orElseThrow(() -> new IllegalArgumentException(ErrorMessage.INVALID_INITIAL_COMMAND.getMessage()));
+  }
+}

src/main/java/chess/controller/command/commands/Command.java

@@ -0,0 +1,10 @@
+package chess.controller.command.commands;
+
+import chess.domain.game.ChessGame;
+import chess.service.ChessGameService;
+import java.sql.SQLException;
+
+public interface Command {
+  void execute(final ChessGameService chessGameService);
+  ChessGame initializeChessGame(final ChessGameService chessGameService) throws SQLException;
+}

src/main/java/chess/controller/command/commands/ContinueCommand.java

@@ -0,0 +1,25 @@
+package chess.controller.command.commands;
+
+import chess.domain.game.ChessGame;
+import chess.service.ChessGameService;
+import chess.view.OutputView;
+import java.sql.SQLException;
+
+public class ContinueCommand implements Command {
+
+  @Override
+  public ChessGame initializeChessGame(final ChessGameService chessGameService)
+      throws SQLException {
+    ChessGame chessGame = chessGameService.findChessGame();
+    if (chessGame == null) {
+      OutputView.printNoExistsRunningGameMessage();
+    }
+    OutputView.printContinueMessage();
+    return chessGame;
+  }
+
+  @Override
+  public void execute(ChessGameService chessGameService) {
+    throw new UnsupportedOperationException();
+  }
+}

src/main/java/chess/controller/command/commands/EndCommand.java

@@ -0,0 +1,23 @@
+package chess.controller.command.commands;
+
+import chess.domain.game.ChessGame;
+import chess.service.ChessGameService;
+
+public class EndCommand implements Command {
+
+  private final ChessGame chessGame;
+
+  public EndCommand(ChessGame chessGame) {
+    this.chessGame = chessGame;
+  }
+
+  @Override
+  public void execute(final ChessGameService chessGameService) {
+    chessGame.end();
+  }
+
+  @Override
+  public ChessGame initializeChessGame(final ChessGameService chessGameService) {
+    throw new UnsupportedOperationException();
+  }
+}