반경 내 주차장 조회 기능 구현

build.gradle

@@ -24,6 +24,8 @@ repositories {
 dependencies {
     implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
     implementation 'org.springframework.boot:spring-boot-starter-web'
+    implementation group: 'org.hibernate.orm', name: 'hibernate-spatial', version: '6.3.1.Final'
+
     compileOnly 'org.projectlombok:lombok'
     runtimeOnly 'com.h2database:h2'
     runtimeOnly 'com.mysql:mysql-connector-j'

src/main/java/com/example/parking/api/parking/ParkingController.java

@@ -0,0 +1,31 @@
+package com.example.parking.api.parking;
+
+import com.example.parking.application.parking.ParkingService;
+import com.example.parking.application.parking.dto.ParkingLotsResponse;
+import com.example.parking.application.parking.dto.ParkingQueryRequest;
+import com.example.parking.application.parking.dto.ParkingSearchConditionRequest;
+import com.example.parking.config.argumentresolver.parking.ParkingMemberId;
+import com.example.parking.config.argumentresolver.parking.ParkingQuery;
+import com.example.parking.config.argumentresolver.parking.ParkingSearchCondition;
+import lombok.RequiredArgsConstructor;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+@RequiredArgsConstructor
+@RestController
+public class ParkingController {
+
+    private final ParkingService parkingService;
+
+    @GetMapping("/parkings")
+    public ResponseEntity<ParkingLotsResponse> find(
+            @ParkingQuery ParkingQueryRequest parkingQueryRequest,
+            @ParkingSearchCondition ParkingSearchConditionRequest parkingSearchConditionRequest,
+            @ParkingMemberId Long parkingMemberId
+    ) {
+        ParkingLotsResponse parkingLots = parkingService.findParkingLots(parkingQueryRequest,
+                parkingSearchConditionRequest, parkingMemberId);
+        return ResponseEntity.ok(parkingLots);
+    }
+}

src/main/java/com/example/parking/application/parking/ParkingDomainService.java

@@ -0,0 +1,77 @@
+package com.example.parking.application.parking;
+
+import com.example.parking.application.parking.dto.ParkingLotsResponse.ParkingResponse;
+import com.example.parking.domain.favorite.Favorite;
+import com.example.parking.domain.parking.Fee;
+import com.example.parking.domain.parking.FilterCondition;
+import com.example.parking.domain.parking.Location;
+import com.example.parking.domain.parking.Parking;
+import com.example.parking.domain.parking.ParkingFeeCalculator;
+import com.example.parking.support.Association;
+import java.time.LocalDateTime;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Component;
+
+@RequiredArgsConstructor
+@Component
+public class ParkingDomainService {
+
+    private final ParkingFeeCalculator parkingFeeCalculator;
+
+    public List<Parking> filterByCondition(List<Parking> parkingLots, FilterCondition filterCondition) {
+        return parkingLots.stream()
+                .filter(parking -> parking.containsOperationType(filterCondition.getOperationTypes()))
+                .filter(parking -> parking.containsParkingType(filterCondition.getParkingTypes()))
+                .filter(parking -> parking.containsPayType(filterCondition.getPayTypes()))
+                .toList();
+    }
+
+    public List<ParkingResponse> calculateParkingInfo(List<Parking> parkingLots, int hours,
+                                                      Location destination, List<Favorite> memberFavorites) {
+        Set<Long> favoriteParkingIds = extractFavoriteParkingIds(memberFavorites);
+        return extractParkingInfo(parkingLots, destination, hours, favoriteParkingIds);
+    }
+
+    private List<ParkingResponse> extractParkingInfo(List<Parking> parkingLots, Location destination, int hours,
+                                                     Set<Long> favoriteParkingIds) {
+        LocalDateTime now = LocalDateTime.now();
+
+        List<ParkingResponse> parkingResponses = new ArrayList<>();
+        for (Parking parking : parkingLots) {
+            Fee fee = parkingFeeCalculator.calculateParkingFee(parking, now, now.plusHours(hours));
+            int walkingTime = parking.calculateWalkingTime(destination);
+            ParkingResponse parkingResponse = toParkingResponse(
+                    parking,
+                    fee,
+                    walkingTime,
+                    favoriteParkingIds.contains(parking.getId())
+            );
+            parkingResponses.add(parkingResponse);
+        }
+        return parkingResponses;
+    }
+
+    private Set<Long> extractFavoriteParkingIds(List<Favorite> memberFavorites) {
+        return memberFavorites.stream()
+                .map(Favorite::getParkingId)
+                .map(Association::getId)
+                .collect(Collectors.toSet());
+    }
+
+    private ParkingResponse toParkingResponse(Parking parking, Fee fee, int walkingTime, boolean isFavorite) {
+        return new ParkingResponse(
+                parking.getId(),
+                parking.getBaseInformation().getName(),
+                fee.getFee(),
+                walkingTime,
+                parking.getBaseInformation().getParkingType().getDescription(),
+                isFavorite,
+                parking.getLocation().getLatitude(),
+                parking.getLocation().getLongitude()
+        );
+    }
+}

src/main/java/com/example/parking/application/parking/ParkingService.java

@@ -1,7 +1,20 @@
 package com.example.parking.application.parking;
 
+import com.example.parking.application.parking.dto.ParkingLotsResponse;
+import com.example.parking.application.parking.dto.ParkingLotsResponse.ParkingResponse;
+import com.example.parking.application.parking.dto.ParkingQueryRequest;
+import com.example.parking.application.parking.dto.ParkingSearchConditionRequest;
+import com.example.parking.domain.favorite.Favorite;
+import com.example.parking.domain.favorite.FavoriteRepository;
+import com.example.parking.domain.parking.FilterCondition;
+import com.example.parking.domain.parking.Location;
+import com.example.parking.domain.parking.OperationType;
 import com.example.parking.domain.parking.Parking;
-import com.example.parking.domain.parking.ParkingRepository;
+import com.example.parking.domain.parking.ParkingType;
+import com.example.parking.domain.parking.PayType;
+import com.example.parking.domain.parking.repository.ParkingRepository;
+import com.example.parking.support.Association;
+import java.util.Collections;
 import java.util.List;
 import java.util.Set;
 import lombok.RequiredArgsConstructor;
@@ -12,7 +25,58 @@
 @Service
 public class ParkingService {
 
+    private static final String DISTANCE_ORDER_CONDITION = "가까운 순";
+
     private final ParkingRepository parkingRepository;
+    private final ParkingDomainService parkingDomainService;
+    private final FavoriteRepository favoriteRepository;
+
+    @Transactional(readOnly = true)
+    public ParkingLotsResponse findParkingLots(ParkingQueryRequest parkingQueryRequest,
+                                               ParkingSearchConditionRequest parkingSearchConditionRequest,
+                                               Long memberId) {
+        Location destination = Location.of(parkingQueryRequest.getLongitude(), parkingQueryRequest.getLatitude());
+        FilterCondition filterCondition = toFilterCondition(parkingSearchConditionRequest);
+
+        List<Favorite> favorites = findMemberFavorites(memberId);
+        List<Parking> parkingLots = findParkingLotsByOrderCondition(parkingSearchConditionRequest.getPriority(),
+                parkingQueryRequest, destination);
+
+        List<Parking> filteredParkingLots = filteringByCondition(parkingLots, filterCondition);
+        List<ParkingResponse> parkingResponses = parkingDomainService.calculateParkingInfo(filteredParkingLots,
+                parkingSearchConditionRequest.getHours(), destination, favorites);
+
+        return new ParkingLotsResponse(parkingResponses);
+    }
+
+    private FilterCondition toFilterCondition(ParkingSearchConditionRequest parkingSearchConditionRequest) {
+        List<ParkingType> parkingTypes = ParkingType.collectMatch(parkingSearchConditionRequest.getParkingTypes());
+        List<OperationType> operationTypes = OperationType.collectMatch(
+                parkingSearchConditionRequest.getOperationTypes());
+        List<PayType> payTypes = PayType.collectMatch(parkingSearchConditionRequest.getPayTypes());
+
+        return new FilterCondition(operationTypes, parkingTypes, payTypes);
+    }
+
+    private List<Favorite> findMemberFavorites(Long memberId) {
+        if (memberId == null) {
+            return Collections.emptyList();
+        }
+        return favoriteRepository.findByMemberId(Association.from(memberId));
+    }
+
+    private List<Parking> filteringByCondition(List<Parking> parkingLots, FilterCondition filterCondition) {
+        return parkingDomainService.filterByCondition(parkingLots, filterCondition);
+    }
+
+    private List<Parking> findParkingLotsByOrderCondition(String priority, ParkingQueryRequest parkingQueryRequest,
+                                                          Location middleLocation) {
+        if (priority.equals(DISTANCE_ORDER_CONDITION)) {
+            return parkingRepository.findAroundParkingLotsOrderByDistance(middleLocation.getPoint(),
+                    parkingQueryRequest.getRadius());
+        }
+        return parkingRepository.findAroundParkingLots(middleLocation.getPoint(), parkingQueryRequest.getRadius());
+    }
 
     @Transactional
     public void saveAll(List<Parking> parkingLots) {

src/main/java/com/example/parking/application/parking/dto/ParkingLotsResponse.java

@@ -0,0 +1,44 @@
+package com.example.parking.application.parking.dto;
+
+import java.util.List;
+import lombok.Getter;
+
+@Getter
+public class ParkingLotsResponse {
+
+    private List<ParkingResponse> parkingLots;
+
+    private ParkingLotsResponse() {
+    }
+
+    public ParkingLotsResponse(List<ParkingResponse> parkingLots) {
+        this.parkingLots = parkingLots;
+    }
+
+    @Getter
+    public static class ParkingResponse {
+        private Long parkingId;
+        private String parkingName;
+        private Integer estimatedFee;
+        private Integer estimatedWalkingTime;
+        private String parkingType;
+        private Boolean isFavorite;
+        private Double latitude;
+        private Double longitude;
+
+        private ParkingResponse() {
+        }
+
+        public ParkingResponse(Long parkingId, String parkingName, Integer estimatedFee, Integer estimatedWalkingTime,
+                               String parkingType, Boolean isFavorite, Double latitude, Double longitude) {
+            this.parkingId = parkingId;
+            this.parkingName = parkingName;
+            this.estimatedFee = estimatedFee;
+            this.estimatedWalkingTime = estimatedWalkingTime;
+            this.parkingType = parkingType;
+            this.isFavorite = isFavorite;
+            this.latitude = latitude;
+            this.longitude = longitude;
+        }
+    }
+}

src/main/java/com/example/parking/application/parking/dto/ParkingQueryRequest.java

@@ -0,0 +1,17 @@
+package com.example.parking.application.parking.dto;
+
+import lombok.Getter;
+
+@Getter
+public class ParkingQueryRequest {
+
+    private final Double latitude;
+    private final Double longitude;
+    private final Integer radius;
+
+    public ParkingQueryRequest(Double latitude, Double longitude, Integer radius) {
+        this.latitude = latitude;
+        this.longitude = longitude;
+        this.radius = radius;
+    }
+}

src/main/java/com/example/parking/application/parking/dto/ParkingSearchConditionRequest.java

@@ -0,0 +1,43 @@
+package com.example.parking.application.parking.dto;
+
+import com.example.parking.domain.parking.OperationType;
+import com.example.parking.domain.parking.ParkingType;
+import com.example.parking.domain.parking.PayType;
+import java.util.List;
+import lombok.Getter;
+
+@Getter
+public class ParkingSearchConditionRequest {
+
+    private static final int BASE_HOURS = 1;
+    private static final String NOT_FREE = "유료";
+    private static final String RECOMMEND_ORDER_CONDITION = "추천 순";
+
+    private final List<String> operationTypes;
+    private final List<String> parkingTypes;
+    private final String feeTypes;
+    private final List<String> payTypes;
+    private final Integer hours;
+    private final String priority;
+
+    public ParkingSearchConditionRequest(List<String> operationTypes, List<String> parkingTypes, String feeTypes,
+                                         List<String> payTypes, int hours, String priority) {
+        this.operationTypes = operationTypes;
+        this.parkingTypes = parkingTypes;
+        this.feeTypes = feeTypes;
+        this.payTypes = payTypes;
+        this.hours = hours;
+        this.priority = priority;
+    }
+
+    public static ParkingSearchConditionRequest base() {
+        return new ParkingSearchConditionRequest(
+                OperationType.getAllValues(),
+                ParkingType.getAllValues(),
+                NOT_FREE,
+                PayType.getAllValues(),
+                BASE_HOURS,
+                RECOMMEND_ORDER_CONDITION
+        );
+    }
+}

src/main/java/com/example/parking/config/WebMvcConfig.java

@@ -1,6 +1,9 @@
 package com.example.parking.config;
 
 import com.example.parking.config.argumentresolver.AuthArgumentResolver;
+import com.example.parking.config.argumentresolver.parking.ParkingMemberIdArgumentResolver;
+import com.example.parking.config.argumentresolver.parking.ParkingQueryArgumentResolver;
+import com.example.parking.config.argumentresolver.parking.ParkingSearchConditionArgumentResolver;
 import com.example.parking.external.config.interceptor.AuthInterceptor;
 import java.util.List;
 import lombok.RequiredArgsConstructor;
@@ -15,19 +18,26 @@ public class WebMvcConfig implements WebMvcConfigurer {
 
     private final AuthInterceptor authInterceptor;
     private final AuthArgumentResolver authArgumentResolver;
+    private final ParkingQueryArgumentResolver parkingQueryArgumentResolver;
+    private final ParkingSearchConditionArgumentResolver parkingSearchConditionArgumentResolver;
+    private final ParkingMemberIdArgumentResolver parkingMemberIdArgumentResolver;
 
     @Override
     public void addInterceptors(InterceptorRegistry registry) {
         registry.addInterceptor(authInterceptor)
                 .addPathPatterns("/**")
                 .excludePathPatterns(List.of(
                         "/users",
-                        "/login"
+                        "/login",
+                        "/parkings"
                 ));
     }
 
     @Override
     public void addArgumentResolvers(List<HandlerMethodArgumentResolver> resolvers) {
         resolvers.add(authArgumentResolver);
+        resolvers.add(parkingQueryArgumentResolver);
+        resolvers.add(parkingSearchConditionArgumentResolver);
+        resolvers.add(parkingMemberIdArgumentResolver);
     }
 }

src/main/java/com/example/parking/config/argumentresolver/parking/ParkingMemberId.java

@@ -0,0 +1,11 @@
+package com.example.parking.config.argumentresolver.parking;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target(ElementType.PARAMETER)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface ParkingMemberId {
+}

src/main/java/com/example/parking/config/argumentresolver/parking/ParkingMemberIdArgumentResolver.java

@@ -0,0 +1,22 @@
+package com.example.parking.config.argumentresolver.parking;
+
+import org.springframework.core.MethodParameter;
+import org.springframework.stereotype.Component;
+import org.springframework.web.bind.support.WebDataBinderFactory;
+import org.springframework.web.context.request.NativeWebRequest;
+import org.springframework.web.method.support.HandlerMethodArgumentResolver;
+import org.springframework.web.method.support.ModelAndViewContainer;
+
+@Component
+public class ParkingMemberIdArgumentResolver implements HandlerMethodArgumentResolver {
+    @Override
+    public boolean supportsParameter(MethodParameter parameter) {
+        return parameter.hasParameterAnnotation(ParkingMemberId.class);
+    }
+
+    @Override
+    public Long resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer,
+                                NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception {
+        return Long.parseLong(webRequest.getParameter("JSESSIONID"));
+    }
+}

src/main/java/com/example/parking/config/argumentresolver/parking/ParkingQuery.java

@@ -0,0 +1,11 @@
+package com.example.parking.config.argumentresolver.parking;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target(ElementType.PARAMETER)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface ParkingQuery {
+}