[지하철 경로 미션] 코딩 연습겸 만들어봤습니다. 재미로만 봐주세요 ✌('ω')

README.md

@@ -251,3 +251,7 @@ public void getDijkstraShortestPath() {
 ## 📝 License
 
 This project is [MIT](https://github.com/woowacourse/java-subway-path-precourse/blob/master/LICENSE.md) licensed.
+
+## 🧩 풀이 과정
+
+[solving_process.md](https://github.com/jaehyeonjung0613/java-subway-path-precourse/blob/main/.github/solving_process.md)

src/main/java/subway/Application.java

@@ -1,10 +1,10 @@
 package subway;
 
-import java.util.Scanner;
+import subway.presentation.IntroViewController;
 
 public class Application {
     public static void main(String[] args) {
-        final Scanner scanner = new Scanner(System.in);
-        // TODO: 프로그램 구현
+        IntroViewController introViewController = new IntroViewController();
+        introViewController.execute();
     }
-}
+}

src/main/java/subway/application/section/dto/SectionDTO.java

@@ -0,0 +1,69 @@
+package subway.application.section.dto;
+
+import subway.domain.line.LineDTO;
+import subway.domain.station.StationDTO;
+
+public class SectionDTO {
+    private static final String SECTION_ADDING_LINE_INFO_ESSENTIAL_MESSAGE = "구간 생성시 노선 정보는 필수입니다.";
+    private static final String SECTION_ADDING_SOURCE_STATION_INFO_ESSENTIAL_MESSAGE = "구간 생성시 시작역 정보는 필수입니다.";
+    private static final String SECTION_ADDING_SINK_STATION_INFO_ESSENTIAL_MESSAGE = "구간 생성시 종료역 정보는 필수입니다.";
+
+    private final LineDTO lineDTO;
+    private final StationDTO sourceDTO;
+    private final StationDTO sinkDTO;
+    private int distance;
+    private int time;
+
+    public SectionDTO(LineDTO lineDTO, StationDTO sourceDTO, StationDTO sinkDTO) {
+        this(lineDTO, sourceDTO, sinkDTO, 0, 0);
+    }
+
+    public SectionDTO(LineDTO lineDTO, StationDTO sourceDTO, StationDTO sinkDTO, int distance, int time) {
+        this.validate(lineDTO, sourceDTO, sinkDTO);
+        this.lineDTO = lineDTO;
+        this.sourceDTO = sourceDTO;
+        this.sinkDTO = sinkDTO;
+        this.distance = distance;
+        this.time = time;
+    }
+
+    private void validate(LineDTO lineDTO, StationDTO sourceDTO, StationDTO sinkDTO) {
+        if (lineDTO == null) {
+            throw new IllegalArgumentException(SECTION_ADDING_LINE_INFO_ESSENTIAL_MESSAGE);
+        }
+        if (sourceDTO == null) {
+            throw new IllegalArgumentException(SECTION_ADDING_SOURCE_STATION_INFO_ESSENTIAL_MESSAGE);
+        }
+        if (sinkDTO == null) {
+            throw new IllegalArgumentException(SECTION_ADDING_SINK_STATION_INFO_ESSENTIAL_MESSAGE);
+        }
+    }
+
+    public LineDTO getLineDTO() {
+        return lineDTO;
+    }
+
+    public StationDTO getSourceDTO() {
+        return sourceDTO;
+    }
+
+    public StationDTO getSinkDTO() {
+        return sinkDTO;
+    }
+
+    public int getDistance() {
+        return distance;
+    }
+
+    public void setDistance(int distance) {
+        this.distance = distance;
+    }
+
+    public int getTime() {
+        return time;
+    }
+
+    public void setTime(int time) {
+        this.time = time;
+    }
+}

src/main/java/subway/application/section/dto/ShortCostRequest.java

@@ -0,0 +1,38 @@
+package subway.application.section.dto;
+
+import subway.domain.station.StationDTO;
+
+public class ShortCostRequest {
+    private static final String SOURCE_STATION_INFO_ESSENTIAL_MESSAGE = "시작역 정보는 필수입니다.";
+    private static final String SINK_STATION_INFO_ESSENTIAL_MESSAGE = "종료역 정보는 필수입니다.";
+    private static final String SAME_SOURCE_AND_SINK_STATION_MESSAGE = "출발역과 도착역이 동일합니다.";
+
+    private final StationDTO sourceDTO;
+    private final StationDTO sinkDTO;
+
+    public ShortCostRequest(StationDTO sourceDTO, StationDTO sinkDTO) {
+        this.validate(sourceDTO, sinkDTO);
+        this.sourceDTO = sourceDTO;
+        this.sinkDTO = sinkDTO;
+    }
+
+    private void validate(StationDTO sourceDTO, StationDTO sinkDTO) {
+        if(sourceDTO == null) {
+            throw new IllegalArgumentException(SOURCE_STATION_INFO_ESSENTIAL_MESSAGE);
+        }
+        if(sinkDTO == null) {
+            throw new IllegalArgumentException(SINK_STATION_INFO_ESSENTIAL_MESSAGE);
+        }
+        if(sourceDTO.equals(sinkDTO)) {
+            throw new IllegalArgumentException(SAME_SOURCE_AND_SINK_STATION_MESSAGE);
+        }
+    }
+
+    public StationDTO getSourceDTO() {
+        return sourceDTO;
+    }
+
+    public StationDTO getSinkDTO() {
+        return sinkDTO;
+    }
+}

src/main/java/subway/application/section/dto/ShortCostResponse.java

@@ -0,0 +1,46 @@
+package subway.application.section.dto;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import subway.domain.station.Station;
+
+public class ShortCostResponse {
+    private int totalDistance;
+    private int totalTime;
+    private final List<String> stationNameList;
+
+    public ShortCostResponse(List<Station> stationList) {
+        this.stationNameList = new ArrayList<>();
+        int length = stationList.size();
+        for (int index = 0; index < length; index++) {
+            Station source = stationList.get(index);
+            if (index + 1 < length) {
+                Station sink = stationList.get(index + 1);
+                totalDistance += source.findDistanceTo(sink);
+                totalTime += source.findTimeTo(sink);
+            }
+            stationNameList.add(source.getName());
+        }
+    }
+
+    public int getTotalDistance() {
+        return totalDistance;
+    }
+
+    public void setTotalDistance(int totalDistance) {
+        this.totalDistance = totalDistance;
+    }
+
+    public int getTotalTime() {
+        return totalTime;
+    }
+
+    public void setTotalTime(int totalTime) {
+        this.totalTime = totalTime;
+    }
+
+    public List<String> getStationNameList() {
+        return stationNameList;
+    }
+}

src/main/java/subway/application/section/service/SectionService.java

@@ -0,0 +1,82 @@
+package subway.application.section.service;
+
+import java.util.List;
+
+import org.jgrapht.GraphPath;
+import org.jgrapht.graph.DefaultWeightedEdge;
+
+import subway.application.section.dto.SectionDTO;
+import subway.application.section.dto.ShortCostRequest;
+import subway.application.section.dto.ShortCostResponse;
+import subway.domain.line.Line;
+import subway.domain.line.LineService;
+import subway.domain.section.Section;
+import subway.domain.section.SectionRepository;
+import subway.domain.station.Station;
+import subway.domain.station.StationDTO;
+import subway.domain.station.StationService;
+
+public class SectionService {
+    private static final String ALREADY_EXISTS_SECTION_MESSAGE = "이미 등록되어있는 구간입니다.";
+    private static final String NOT_EXISTS_SOURCE_STATION_MESSAGE = "존재하지 않은 시작역입니다.";
+    private static final String NOT_EXISTS_SINK_STATION_MESSAGE = "존재하지 않은 종료역입니다.";
+    private static final String NOT_CONNECTED_SOURCE_AND_SINK_STATION_MESSAGE = "시작 지점과 종료역이 연결되어 있지 않습니다.";
+
+    private final LineService lineService = new LineService();
+    private final StationService stationService = new StationService();
+    private final ShortDistanceService shortDistanceService = new ShortDistanceService();
+    private final ShortTimeService shortTimeService = new ShortTimeService();
+
+    public List<Section> findAll() {
+        return SectionRepository.sections();
+    }
+
+    public void addNode(StationDTO stationDTO) {
+        Station station = this.stationService.findOneByName(stationDTO.getName());
+        this.shortDistanceService.addNode(station);
+        this.shortTimeService.addNode(station);
+    }
+
+    public void addSection(SectionDTO sectionDTO) {
+        Line line = this.lineService.findOneByName(sectionDTO.getLineDTO().getName());
+        Station source = this.stationService.findOneByName(sectionDTO.getSourceDTO().getName());
+        Station sink = this.stationService.findOneByName(sectionDTO.getSinkDTO().getName());
+        Section section = new Section(line, source, sink, sectionDTO.getDistance(), sectionDTO.getTime());
+        if (SectionRepository.exists(section)) {
+            throw new IllegalArgumentException(ALREADY_EXISTS_SECTION_MESSAGE);
+        }
+        SectionRepository.addSection(section);
+        this.shortDistanceService.addEdge(section);
+        this.shortTimeService.addEdge(section);
+        line.addSection(section);
+        source.addSection(section);
+    }
+
+    public ShortCostResponse computeShortDistance(ShortCostRequest shortCostRequest) {
+        Station source = this.stationService.findByName(shortCostRequest.getSourceDTO().getName())
+            .orElseThrow(() -> new IllegalArgumentException(NOT_EXISTS_SOURCE_STATION_MESSAGE));
+        Station sink = this.stationService.findByName(shortCostRequest.getSinkDTO().getName())
+            .orElseThrow(() -> new IllegalArgumentException(NOT_EXISTS_SINK_STATION_MESSAGE));
+        GraphPath<Station, DefaultWeightedEdge> graphPath = this.shortDistanceService.compute(source, sink);
+        if (graphPath == null) {
+            throw new IllegalArgumentException(NOT_CONNECTED_SOURCE_AND_SINK_STATION_MESSAGE);
+        }
+        return new ShortCostResponse(graphPath.getVertexList());
+    }
+
+    public ShortCostResponse computeShortTime(ShortCostRequest shortCostRequest) {
+        Station source = this.stationService.findByName(shortCostRequest.getSourceDTO().getName())
+            .orElseThrow(() -> new IllegalArgumentException(NOT_EXISTS_SOURCE_STATION_MESSAGE));
+        Station sink = this.stationService.findByName(shortCostRequest.getSinkDTO().getName())
+            .orElseThrow(() -> new IllegalArgumentException(NOT_EXISTS_SINK_STATION_MESSAGE));
+        GraphPath<Station, DefaultWeightedEdge> graphPath = this.shortDistanceService.compute(source, sink);
+        if (graphPath == null) {
+            throw new IllegalArgumentException(NOT_CONNECTED_SOURCE_AND_SINK_STATION_MESSAGE);
+        }
+        return new ShortCostResponse(graphPath.getVertexList());
+    }
+
+    public void deleteAll() {
+        SectionRepository.deleteAll();
+    }
+}

src/main/java/subway/application/section/service/ShortCostService.java

@@ -0,0 +1,87 @@
+package subway.application.section.service;
+
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Set;
+
+import org.jgrapht.GraphPath;
+import org.jgrapht.alg.shortestpath.DijkstraShortestPath;
+import org.jgrapht.graph.AbstractBaseGraph;
+import org.jgrapht.graph.DefaultWeightedEdge;
+
+import subway.domain.section.Section;
+import subway.domain.station.Station;
+
+abstract class ShortCostService {
+    private final AbstractBaseGraph<Station, DefaultWeightedEdge> graph;
+
+    public ShortCostService(AbstractBaseGraph<Station, DefaultWeightedEdge> graph) {
+        this.graph = graph;
+    }
+
+    private static final String ALREADY_EXISTS_NODE_MESSAGE = "이미 등록되어있는 노드입니다.";
+    private static final String NOT_EXISTS_SOURCE_NODE_MESSAGE = "존재하지 않은 시작노드입니다.";
+    private static final String NOT_EXISTS_SINK_NODE_MESSAGE = "존재하지 않은 종료노드입니다.";
+    private static final String ALREADY_EXISTS_EDGE_MESSAGE = "이미 등록되어있는 간선입니다.";
+
+    protected Set<Station> findAllNode() {
+        return Collections.unmodifiableSet(graph.vertexSet());
+    }
+
+    protected Set<DefaultWeightedEdge> findAllEdge() {
+        return Collections.unmodifiableSet(graph.edgeSet());
+    }
+
+    protected void addNode(Station station) {
+        if (graph.containsVertex(station)) {
+            throw new IllegalArgumentException(ALREADY_EXISTS_NODE_MESSAGE);
+        }
+        graph.addVertex(station);
+    }
+
+    protected void addEdge(Section section) {
+        Station source = section.getSource();
+        Station sink = section.getSink();
+        this.validateSource(source);
+        this.validateSink(sink);
+        if (graph.containsEdge(source, sink)) {
+            throw new IllegalArgumentException(ALREADY_EXISTS_EDGE_MESSAGE);
+        }
+        graph.setEdgeWeight(graph.addEdge(source, sink), this.getWeight(section));
+    }
+
+    protected abstract double getWeight(Section section);
+
+    protected GraphPath<Station, DefaultWeightedEdge> compute(Station source, Station sink) {
+        this.validateSource(source);
+        this.validateSink(sink);
+        DijkstraShortestPath<Station, DefaultWeightedEdge> dijkstraShortestPath = new DijkstraShortestPath<>(graph);
+        return dijkstraShortestPath.getPath(source, sink);
+    }
+
+    protected void validateSource(Station source) {
+        if (!graph.containsVertex(source)) {
+            throw new IllegalArgumentException(NOT_EXISTS_SOURCE_NODE_MESSAGE);
+        }
+    }
+
+    protected void validateSink(Station sink) {
+        if (!graph.containsVertex(sink)) {
+            throw new IllegalArgumentException(NOT_EXISTS_SINK_NODE_MESSAGE);
+        }
+    }
+
+    protected void deleteAllNode() {
+        Set<Station> nodes = new HashSet<>(this.findAllNode());
+        graph.removeAllVertices(nodes);
+    }
+
+    protected void deleteAllEdge() {
+        graph.removeAllEdges(graph.edgeSet());
+    }
+
+    protected void deleteAll() {
+        this.deleteAllEdge();
+        this.deleteAllNode();
+    }
+}

src/main/java/subway/application/section/service/ShortDistanceService.java

@@ -0,0 +1,22 @@
+package subway.application.section.service;
+
+import org.jgrapht.graph.AbstractBaseGraph;
+import org.jgrapht.graph.DefaultWeightedEdge;
+import org.jgrapht.graph.DirectedWeightedMultigraph;
+
+import subway.domain.section.Section;
+import subway.domain.station.Station;
+
+class ShortDistanceService extends ShortCostService {
+    private static final AbstractBaseGraph<Station, DefaultWeightedEdge> graph = new DirectedWeightedMultigraph<>(
+        DefaultWeightedEdge.class);
+
+    public ShortDistanceService() {
+        super(graph);
+    }
+
+    @Override
+    protected double getWeight(Section section) {
+        return section.getDistance();
+    }
+}

src/main/java/subway/application/section/service/ShortTimeService.java

@@ -0,0 +1,22 @@
+package subway.application.section.service;
+
+import org.jgrapht.graph.AbstractBaseGraph;
+import org.jgrapht.graph.DefaultWeightedEdge;
+import org.jgrapht.graph.DirectedWeightedMultigraph;
+
+import subway.domain.section.Section;
+import subway.domain.station.Station;
+
+class ShortTimeService extends ShortCostService {
+    private static final AbstractBaseGraph<Station, DefaultWeightedEdge> graph = new DirectedWeightedMultigraph<>(
+        DefaultWeightedEdge.class);
+
+    public ShortTimeService() {
+        super(graph);
+    }
+
+    @Override
+    protected double getWeight(Section section) {
+        return section.getTime();
+    }
+}