[feat] 현재까지 변경사항 main으로 병합

src/main/java/com/wayble/server/common/converter/StringListConverter.java

@@ -0,0 +1,38 @@
+package com.wayble.server.common.converter;
+
+import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import jakarta.persistence.AttributeConverter;
+import jakarta.persistence.Converter;
+import lombok.extern.slf4j.Slf4j;
+
+import java.util.Collections;
+import java.util.List;
+
+@Slf4j
+@Converter
+public class StringListConverter implements AttributeConverter<List<String>, String> {
+    private static final ObjectMapper objectMapper = new ObjectMapper();
+
+    @Override
+    public String convertToDatabaseColumn(List<String> list) {
+        try {
+            return list == null ? "[]" : objectMapper.writeValueAsString(list);
+        } catch (Exception e) {
+            log.warn("Failed to convert list to JSON string: {}", list, e);
+            return "[]";
+        }
+    }
+
+    @Override
+    public List<String> convertToEntityAttribute(String json) {
+        try {
+            if (json == null || json.isBlank()) return Collections.emptyList();
+            return objectMapper.readValue(json, new TypeReference<List<String>>() {});
+        } catch (Exception e) {
+            log.warn("Failed to convert JSON string to list: {}", json, e);
+            return Collections.emptyList();
+        }
+    }
+}
+

src/main/java/com/wayble/server/direction/controller/WalkingController.java

@@ -2,6 +2,7 @@
 
 import com.wayble.server.common.response.CommonResponse;
 import com.wayble.server.direction.controller.swagger.WalkingSwagger;
+import com.wayble.server.direction.dto.response.WayblePathResponse;
 import com.wayble.server.direction.external.tmap.dto.request.TMapRequest;
 import com.wayble.server.direction.external.tmap.dto.response.TMapParsingResponse;
 import com.wayble.server.direction.service.WalkingService;
@@ -13,13 +14,13 @@
 
 @RestController
 @RequiredArgsConstructor
-@RequestMapping("/api/v1/directions/walking")
+@RequestMapping("/api/v1/directions")
 public class WalkingController implements WalkingSwagger {
 
     private final WalkingService walkingService;
 
     @Override
-    @GetMapping()
+    @GetMapping("/walking")
     public CommonResponse<TMapParsingResponse> callTMapApi(
             @RequestParam double startX,
             @RequestParam double startY,
@@ -31,4 +32,15 @@ public CommonResponse<TMapParsingResponse> callTMapApi(
         TMapRequest request = new TMapRequest(startX, startY, endX, endY, startName, endName);
         return CommonResponse.success(walkingService.callTMapApi(request));
     }
+
+    @Override
+    @GetMapping("/wayble")
+    public CommonResponse<WayblePathResponse> getWayblePath(
+            @RequestParam double startLat,
+            @RequestParam double startLon,
+            @RequestParam double endLat,
+            @RequestParam double endLon
+    ) {
+        return CommonResponse.success(walkingService.findWayblePath(startLat, startLon, endLat, endLon));
+    }
 }

src/main/java/com/wayble/server/direction/controller/swagger/WalkingSwagger.java

@@ -1,6 +1,7 @@
 package com.wayble.server.direction.controller.swagger;
 
 import com.wayble.server.common.response.CommonResponse;
+import com.wayble.server.direction.dto.response.WayblePathResponse;
 import com.wayble.server.direction.external.tmap.dto.response.TMapParsingResponse;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.responses.ApiResponse;
@@ -28,4 +29,21 @@ CommonResponse<TMapParsingResponse> callTMapApi(
             @RequestParam String startName,
             @RequestParam String endName
     );
+
+    @Operation(
+            summary = "웨이블 추천 경로 길찾기 API",
+            description = "웨이블 마커를 활용하여 웨이블 추천 경로 길찾기를 진행합니다."
+    )
+    @ApiResponses(value = {
+            @ApiResponse(
+                    responseCode = "200",
+                    description = "웨이블 추천 경로 길찾기가 성공적으로 실행되었습니다."
+            )
+    })
+    CommonResponse<WayblePathResponse> getWayblePath(
+            @RequestParam double startLat,
+            @RequestParam double startLon,
+            @RequestParam double endLat,
+            @RequestParam double endLon
+    );
 }

src/main/java/com/wayble/server/direction/dto/response/WayblePathResponse.java

@@ -0,0 +1,49 @@
+package com.wayble.server.direction.dto.response;
+
+import com.wayble.server.direction.entity.type.Type;
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Builder;
+
+import java.util.List;
+
+@Builder
+@Schema(description = "웨이블 추천 경로 API")
+public record WayblePathResponse(
+
+        @Schema(description = "총 거리", example = "1365")
+        int distance,
+
+        @Schema(description = "총 소요 시간", example = "909")
+        int time,
+
+        @Schema(description = "위치", example = "[{\"lat\":37.4941736,\"lon\":127.0247425,\"type\":\"RAMP\"}]")
+        List<WayblePoint> points,
+
+        @Schema(description = "좌표 리스트", example = "[[127.0247425,37.4941736],[127.0249966,37.4942539]]")
+        List<double[]> polyline
+) {
+    public record WayblePoint(
+            @Schema(description = "위도", example = "37.4941736")
+            double lat,
+
+            @Schema(description = "경도", example = "127.0247425")
+            double lon,
+
+            @Schema(description = "웨이블 마커 타입", example = "RAMP")
+            Type type
+    ) {}
+
+    public static WayblePathResponse of(
+            int distance,
+            int time,
+            List<WayblePoint> points,
+            List<double[]> polyline
+    ) {
+        return WayblePathResponse.builder()
+                .distance(distance)
+                .time(time)
+                .points(points)
+                .polyline(polyline)
+                .build();
+    }
+}

src/main/java/com/wayble/server/direction/entity/Edge.java

@@ -0,0 +1,11 @@
+package com.wayble.server.direction.entity;
+
+import java.util.List;
+
+public record Edge(
+        long from,
+        long to,
+        double length,
+        List<double[]> geometry
+) {
+}

src/main/java/com/wayble/server/direction/entity/Node.java

@@ -0,0 +1,8 @@
+package com.wayble.server.direction.entity;
+
+public record Node(
+        Long id,
+        double lat,
+        double lon
+) {
+}

src/main/java/com/wayble/server/direction/entity/WaybleMarker.java

@@ -0,0 +1,11 @@
+package com.wayble.server.direction.entity;
+
+import com.wayble.server.direction.entity.type.Type;
+
+public record WaybleMarker(
+        Long id,
+        double lat,
+        double lon,
+        Type type
+) {
+}

src/main/java/com/wayble/server/direction/entity/type/Type.java

@@ -0,0 +1,22 @@
+package com.wayble.server.direction.entity.type;
+
+import lombok.Getter;
+
+@Getter
+public enum Type {
+    WHEELCHAIR_CHARGER("휠체어 충전소"),
+    NO_THRESHOLD("문턱 없음"),
+    RAMP("경사로"),
+    TABLE_SEAT("테이블석"),
+    ELEVATOR("엘리베이터"),
+    FIRST_FLOOR("1층"),
+    ACCESSIBLE_TOILET("장애인 화장실"),
+    WHEELCHAIR_LIFT("휠체어 리프트"),
+    NONE("해당없음");
+
+    private final String description;
+
+    Type(String description) {
+        this.description = description;
+    }
+}

src/main/java/com/wayble/server/direction/exception/WalkingErrorCase.java

@@ -9,6 +9,9 @@
 public enum WalkingErrorCase implements ErrorCase {
 
     T_MAP_API_FAILED(500, 8001, "T MAP API 호출에 실패했습니다."),
+    GRAPH_FILE_NOT_FOUND(500, 8002, "그래프 파일을 찾을 수 없습니다."),
+    GRAPH_INIT_FAILED(500, 8003, "그래프 초기화에 실패했습니다."),
+    NODE_NOT_FOUND(400, 8004, "해당 위도, 경도 근처의 노드가 존재하지 않습니다."),
     ;
 
     private final Integer httpStatusCode;

src/main/java/com/wayble/server/direction/init/GraphInit.java

@@ -0,0 +1,109 @@
+package com.wayble.server.direction.init;
+
+import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.wayble.server.common.exception.ApplicationException;
+import com.wayble.server.direction.entity.Edge;
+import com.wayble.server.direction.entity.Node;
+import com.wayble.server.direction.entity.WaybleMarker;
+import com.wayble.server.direction.entity.type.Type;
+import com.wayble.server.direction.exception.WalkingErrorCase;
+import com.wayble.server.direction.service.util.HaversineUtil;
+import jakarta.annotation.PostConstruct;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Component;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.*;
+import java.util.stream.Collectors;
+
+@Slf4j
+@Component
+public class GraphInit {
+
+    private List<Node> nodes;
+    private List<Edge> edges;
+    private List<WaybleMarker> markers;
+    private Map<Long, List<Edge>> adjacencyList;
+    private Map<Long, Node> nodeMap;
+    private Map<Long, Type> markerMap;
+
+    @PostConstruct
+    public void init() {
+        ObjectMapper objectMapper = new ObjectMapper();
+
+        try {
+            // 그래프
+            try (InputStream graphStream = getClass().getResourceAsStream("/seocho_pedestrian.json")) {
+                if (graphStream == null) {
+                    throw new ApplicationException(WalkingErrorCase.GRAPH_FILE_NOT_FOUND);
+                }
+                JsonNode root = objectMapper.readTree(graphStream);
+                nodes = Arrays.asList(objectMapper.convertValue(root.get("nodes"), Node[].class));
+                edges = Arrays.asList(objectMapper.convertValue(root.get("edges"), Edge[].class));
+
+                nodeMap = nodes.stream().collect(Collectors.toMap(Node::id, node -> node));
+            }
+
+            // 웨이블 마커
+            try (InputStream markerStream = getClass().getResourceAsStream("/wayble_markers.json")) {
+                markers = markerStream != null
+                        ? objectMapper.readValue(markerStream, new TypeReference<>() {})
+                        : new ArrayList<>();
+            }
+            markerMap = findWaybleMarkers();
+            adjacencyList = buildAdjacencyList();
+        } catch (IOException e) {
+            log.error("🚨 그래프 초기화 실패: {}", e.getMessage());
+            throw new ApplicationException(WalkingErrorCase.GRAPH_INIT_FAILED);
+        }
+    }
+
+    private Map<Long, List<Edge>> buildAdjacencyList() {
+        Map<Long, List<Edge>> adjacencyList = new HashMap<>();
+
+        for (Edge edge : edges) {
+            boolean isWaybleMarker = markerMap.containsKey(edge.from()) || markerMap.containsKey(edge.to());
+            double distance = isWaybleMarker ? edge.length() * 0.5 : edge.length();
+
+            // 양방향
+            adjacencyList.computeIfAbsent(edge.from(), k -> new ArrayList<>())
+                    .add(new Edge(edge.from(), edge.to(), distance, edge.geometry()));
+            adjacencyList.computeIfAbsent(edge.to(), k -> new ArrayList<>())
+                    .add(new Edge(edge.to(), edge.from(), distance, edge.geometry()));
+        }
+        return adjacencyList;
+    }
+
+    private Map<Long, Type> findWaybleMarkers() {
+        Map<Long, Type> waybleMarkers = new HashMap<>();
+
+        for (WaybleMarker marker : markers) {
+            long nearNode = nodes.stream()
+                    .min(Comparator.comparingDouble(
+                            n -> HaversineUtil.haversine(marker.lat(), marker.lon(), n.lat(), n.lon())
+                    ))
+                    .map(Node::id)
+                    .orElse(marker.id());
+
+            if (nearNode != marker.id()) {
+                waybleMarkers.put(nearNode, marker.type());
+            }
+        }
+        return waybleMarkers;
+    }
+
+    public Map<Long, Node> getNodeMap() {
+        return Collections.unmodifiableMap(nodeMap);
+    }
+
+    public Map<Long, Type> getMarkerMap() {
+        return Collections.unmodifiableMap(markerMap);
+    }
+
+    public Map<Long, List<Edge>> getGraph() {
+        return Collections.unmodifiableMap(adjacencyList);
+    }
+}

src/main/java/com/wayble/server/direction/service/WalkingService.java

@@ -1,23 +1,31 @@
 package com.wayble.server.direction.service;
 
 import com.wayble.server.common.exception.ApplicationException;
+import com.wayble.server.direction.dto.response.WayblePathResponse;
+import com.wayble.server.direction.entity.Node;
 import com.wayble.server.direction.exception.WalkingErrorCase;
 import com.wayble.server.direction.external.tmap.TMapClient;
 import com.wayble.server.direction.external.tmap.dto.request.TMapRequest;
 import com.wayble.server.direction.external.tmap.dto.response.TMapParsingResponse;
 import com.wayble.server.direction.external.tmap.dto.response.TMapResponse;
 import com.wayble.server.direction.external.tmap.mapper.TMapMapper;
+import com.wayble.server.direction.init.GraphInit;
+import com.wayble.server.direction.service.util.HaversineUtil;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Service;
 
+import java.util.Comparator;
+
 @Slf4j
 @Service
 @RequiredArgsConstructor
 public class WalkingService {
 
     private final TMapClient tMapClient;
     private final TMapMapper tMapMapper;
+    private final GraphInit graphInit;
+    private final WaybleDijkstraService waybleDijkstraService;
 
     public TMapParsingResponse callTMapApi(TMapRequest request) {
         try {
@@ -29,4 +37,25 @@ public TMapParsingResponse callTMapApi(TMapRequest request) {
             throw new ApplicationException(WalkingErrorCase.T_MAP_API_FAILED);
         }
     }
+
+    public WayblePathResponse findWayblePath(
+            double startLat,
+            double startLon,
+            double endLat,
+            double endLon
+    ) {
+        long startNode = findNearestNode(startLat, startLon);
+        long endNode = findNearestNode(endLat, endLon);
+
+        return waybleDijkstraService.createWayblePath(startNode, endNode);
+    }
+
+    private long findNearestNode(double lat, double lon) {
+        return graphInit.getNodeMap().values().stream()
+                .min(Comparator.comparingDouble(
+                        node -> HaversineUtil.haversine(lat, lon, node.lat(), node.lon())
+                ))
+                .map(Node::id)
+                .orElseThrow(() -> new ApplicationException(WalkingErrorCase.NODE_NOT_FOUND));
+    }
 }