Step3 경로조회 기능

src/main/java/nextstep/subway/SubwayApplication.java

@@ -2,7 +2,13 @@
 
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.context.annotation.Import;
 
+import nextstep.subway.path.ShortedPathFinderConfiguration;
+
+@Import({
+        ShortedPathFinderConfiguration.class
+})
 @SpringBootApplication
 public class SubwayApplication {
 

src/main/java/nextstep/subway/line/domain/Sections.java

@@ -7,6 +7,7 @@
 
 import javax.persistence.CascadeType;
 import javax.persistence.Embeddable;
+import javax.persistence.FetchType;
 import javax.persistence.OneToMany;
 
 import lombok.AccessLevel;
@@ -29,7 +30,7 @@
 @AllArgsConstructor
 public class Sections {
 
-    @OneToMany(mappedBy = "line", cascade = { CascadeType.PERSIST, CascadeType.MERGE}, orphanRemoval = true)
+    @OneToMany(mappedBy = "line", cascade = { CascadeType.PERSIST, CascadeType.MERGE}, orphanRemoval = true, fetch = FetchType.EAGER)
     private List<Section> sections = new ArrayList<>();
 
     public boolean hasOneSection() {
@@ -213,5 +214,4 @@ public Optional<Section> findSectionByDownStation(Station station) {
                        .filter(section -> section.equalsDownStation(station))
                        .findFirst();
     }
-
 }

src/main/java/nextstep/subway/path/DijkstraShortestPathFinder.java

@@ -0,0 +1,47 @@
+package nextstep.subway.path;
+
+import org.jgrapht.GraphPath;
+import org.jgrapht.alg.shortestpath.DijkstraShortestPath;
+import org.jgrapht.graph.DefaultWeightedEdge;
+import org.jgrapht.graph.WeightedMultigraph;
+
+import nextstep.subway.line.domain.Sections;
+import nextstep.subway.section.domain.Section;
+import nextstep.subway.station.domain.Station;
+import nextstep.subway.support.ErrorCode;
+import nextstep.subway.support.SubwayException;
+
+public class DijkstraShortestPathFinder implements ShortestPathFinder {
+
+    @Override
+    public ShortestPath find(Sections sections, Station source, Station target) {
+        WeightedMultigraph<Station, DefaultWeightedEdge> graph = createGraph(sections);
+
+        DijkstraShortestPath dijkstraShortestPath = new DijkstraShortestPath(graph);
+        GraphPath<Station, ShortestPath> result = dijkstraShortestPath.getPath(source, target);
+
+        if (result == null) {
+            throw new SubwayException(ErrorCode.PATH_SOURCE_TARGET_NOT_CONNECTED);
+        }
+
+        return new ShortestPath(result.getVertexList(), (int) result.getWeight());
+    }
+
+    private WeightedMultigraph<Station, DefaultWeightedEdge> createGraph(Sections sections) {
+        WeightedMultigraph<Station, DefaultWeightedEdge> graph = new WeightedMultigraph(DefaultWeightedEdge.class);
+
+        for (Section section : sections.getSections()) {
+            if (!graph.containsVertex(section.getUpStation())) {
+                graph.addVertex(section.getUpStation());
+            }
+
+            if (!graph.containsVertex(section.getDownStation())) {
+                graph.addVertex(section.getDownStation());
+            }
+
+            graph.setEdgeWeight(graph.addEdge(section.getUpStation(), section.getDownStation()), section.getDistance());
+        }
+
+        return graph;
+    }
+}

src/main/java/nextstep/subway/path/PathController.java

@@ -0,0 +1,28 @@
+package nextstep.subway.path;
+
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+
+import nextstep.subway.station.service.StationService;
+
+@RestController
+@Slf4j
+@RequiredArgsConstructor
+public class PathController {
+    private final PathFindService pathFindService;
+    private final StationService stationService;
+
+    @GetMapping("/paths")
+    public ResponseEntity<PathResponse> getPaths(@RequestParam("source") Long sourceStationId, @RequestParam("target") Long targetStationId) {
+        ShortestPath shortestPath = pathFindService.getPath(stationService.get(sourceStationId), stationService.get(targetStationId));
+
+        return ResponseEntity.ok()
+                             .body(new PathResponse(shortestPath));
+    }
+}
+

src/main/java/nextstep/subway/path/PathFindService.java

@@ -0,0 +1,32 @@
+package nextstep.subway.path;
+
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import nextstep.subway.line.domain.Sections;
+import nextstep.subway.section.service.SectionReadService;
+import nextstep.subway.station.domain.Station;
+import nextstep.subway.support.ErrorCode;
+import nextstep.subway.support.SubwayException;
+
+@Service
+@Slf4j
+@RequiredArgsConstructor
+public class PathFindService {
+    private final SectionReadService sectionReadService;
+    private final ShortestPathFinder shortestPathFinder;
+
+    @Transactional(readOnly = true)
+    public ShortestPath getPath(Station sourceStation, Station targetStation) {
+        if (sourceStation.equals(targetStation)) {
+            throw new SubwayException(ErrorCode.PATH_SOURCE_TARGET_SHOULD_DIFFERENT);
+        }
+
+        Sections allSections = new Sections(sectionReadService.getAll());
+
+        return shortestPathFinder.find(allSections, sourceStation, targetStation);
+    }
+}

src/main/java/nextstep/subway/path/PathResponse.java

@@ -0,0 +1,24 @@
+package nextstep.subway.path;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+import lombok.Getter;
+
+import nextstep.subway.station.view.StationResponse;
+
+@Getter
+public class PathResponse {
+
+    private List<StationResponse> stations;
+    private int distance;
+
+    public PathResponse(ShortestPath shortestPath) {
+        this.stations = shortestPath.getStations()
+                                    .stream()
+                                    .map(StationResponse::new)
+                                    .collect(Collectors.toList());
+
+        this.distance = shortestPath.getDistance();
+    }
+}

src/main/java/nextstep/subway/path/ShortedPathFinderConfiguration.java

@@ -0,0 +1,13 @@
+package nextstep.subway.path;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+public class ShortedPathFinderConfiguration {
+
+    @Bean
+    public ShortestPathFinder shortestPathFinder() {
+        return new DijkstraShortestPathFinder();
+    }
+}

src/main/java/nextstep/subway/path/ShortestPath.java

@@ -0,0 +1,18 @@
+package nextstep.subway.path;
+
+import java.util.List;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+import nextstep.subway.station.domain.Station;
+
+@Getter
+@NoArgsConstructor
+@AllArgsConstructor
+public class ShortestPath {
+    private List<Station> stations;
+    private int distance;
+
+}

src/main/java/nextstep/subway/path/ShortestPathFinder.java

@@ -0,0 +1,8 @@
+package nextstep.subway.path;
+
+import nextstep.subway.line.domain.Sections;
+import nextstep.subway.station.domain.Station;
+
+public interface ShortestPathFinder {
+    ShortestPath find(Sections sections, Station sourceStation, Station targetStation);
+}

src/main/java/nextstep/subway/section/domain/Section.java

@@ -25,6 +25,7 @@
 @NoArgsConstructor(access = AccessLevel.PROTECTED)
 @AllArgsConstructor
 @Builder
+//@EqualsAndHashCode(of = "id")
 public class Section {
     @Id
     @GeneratedValue(strategy = GenerationType.IDENTITY)

src/main/java/nextstep/subway/section/repository/SectionRepository.java

@@ -7,5 +7,4 @@
 
 @Repository
 public interface SectionRepository extends JpaRepository<Section, Long> {
-
 }

src/main/java/nextstep/subway/section/service/SectionReadService.java

@@ -0,0 +1,24 @@
+package nextstep.subway.section.service;
+
+import java.util.List;
+
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import nextstep.subway.section.domain.Section;
+import nextstep.subway.section.repository.SectionRepository;
+
+@Service
+@Slf4j
+@RequiredArgsConstructor
+@Transactional(readOnly = true)
+public class SectionReadService {
+    private final SectionRepository sectionRepository;
+
+    public List<Section> getAll() {
+        return sectionRepository.findAll();
+    }
+}

src/main/java/nextstep/subway/station/exception/StationNotFoundException.java

@@ -1,5 +1,10 @@
 package nextstep.subway.station.exception;
 
-public class StationNotFoundException extends RuntimeException {
+import nextstep.subway.support.ErrorCode;
+import nextstep.subway.support.SubwayException;
 
+public class StationNotFoundException extends SubwayException {
+    public StationNotFoundException() {
+        super(ErrorCode.STATION_NOT_FOUND);
+    }
 }

src/main/java/nextstep/subway/support/ErrorCode.java

@@ -8,5 +8,8 @@ public enum ErrorCode {
     SECTION_NOT_FOUND,
     SECTION_ADD_FAIL,
     STATION_NOT_ON_SECTIONS,
+    PATH_SOURCE_TARGET_SHOULD_DIFFERENT,
+    PATH_SOURCE_TARGET_NOT_CONNECTED,
+    STATION_NOT_FOUND,
     ;
 }