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

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,23 @@
+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.config.argumentresolver.parking.ParkingQuery;
+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) {
+        ParkingLotsResponse parkingLots = parkingService.findParkingLots(parkingQueryRequest);
+        return ResponseEntity.ok(parkingLots);
+    }
+}

src/main/java/com/example/parking/application/coordinate/CoordinateService.java

@@ -29,11 +29,11 @@ public Location extractLocationByAddress(String address, double longitude, doubl
         ResponseEntity<CoordinateResponse> result = connect(uriComponents);
 
         if (isEmptyResultData(result)) {
-            return new Location(longitude, latitude);
+            return Location.of(latitude, longitude);
         }
 
         ExactLocation exactLocation = getExactLocation(result);
-        return new Location(exactLocation.getLongitude(), exactLocation.getLatitude());
+        return Location.of(latitude, longitude);
     }
 
     private ExactLocation getExactLocation(ResponseEntity<CoordinateResponse> result) {

src/main/java/com/example/parking/application/coordinate/dto/CoordinateResponse.java

@@ -21,17 +21,14 @@ public CoordinateResponse(List<ExactLocation> exactLocations, Meta meta) {
     }
 
     @NoArgsConstructor
+    @Getter
     public static class ExactLocation {
-        private Double x;
-        private Double y;
 
-        public Double getLatitude() {
-            return y;
-        }
+        @JsonProperty("x")
+        private Double latitude;
 
-        public Double getLongitude() {
-            return x;
-        }
+        @JsonProperty("y")
+        private Double longitude;
     }
 
     @Getter

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

@@ -0,0 +1,17 @@
+package com.example.parking.application.parking;
+
+import com.example.parking.domain.parking.Parking;
+import com.example.parking.domain.parking.dto.ParkingQueryCondition;
+import java.util.List;
+import org.springframework.stereotype.Component;
+
+@Component
+public class ParkingDomainService {
+
+    public List<Parking> filterByCondition(List<Parking> parkingLots, ParkingQueryCondition parkingQueryCondition) {
+        return parkingLots.stream()
+                .filter(parking -> parking.isMatchOperationType(parkingQueryCondition.getOperationType()))
+                .filter(parking -> parking.isMatchParkingType(parkingQueryCondition.getParkingType()))
+                .toList();
+    }
+}

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

@@ -0,0 +1,62 @@
+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.domain.parking.Location;
+import com.example.parking.domain.parking.Parking;
+import com.example.parking.domain.parking.dto.ParkingQueryCondition;
+import com.example.parking.domain.parking.repository.ParkingRepository;
+import java.util.List;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+
+@RequiredArgsConstructor
+@Service
+public class ParkingService {
+
+    public static final String DISTANCE_ORDER_CONDITION = "가까운 순";
+    private final ParkingRepository parkingRepository;
+    private final ParkingDomainService parkingDomainService;
+
+    public ParkingLotsResponse findParkingLots(ParkingQueryRequest parkingQueryRequest) {
+        Location middlLocation = Location.of(parkingQueryRequest.getLatitude(), parkingQueryRequest.getLongitude());
+
+        List<Parking> parkingLots = findParkingLotsByOrderCondition(parkingQueryRequest, middlLocation);
+        List<ParkingResponse> parkingLotsResponse = filteringByCondition(parkingQueryRequest, parkingLots);
+
+        return new ParkingLotsResponse(parkingLotsResponse);
+    }
+
+    private List<ParkingResponse> filteringByCondition(ParkingQueryRequest parkingQueryRequest,
+                                                       List<Parking> parkingLots) {
+        ParkingQueryCondition queryCondition = parkingQueryRequest.toQueryCondition();
+
+        List<Parking> filteredParkingLots = parkingDomainService.filterByCondition(parkingLots, queryCondition);
+        return filteredParkingLots.stream()
+                .map(this::toParkingResponse)
+                .toList();
+    }
+
+    private List<Parking> findParkingLotsByOrderCondition(ParkingQueryRequest parkingQueryRequest,
+                                                          Location middleLocation) {
+        if (parkingQueryRequest.getPriority().equals(DISTANCE_ORDER_CONDITION)) {
+            return parkingRepository.findAroundParkingLotsOrderByDistance(middleLocation.getPoint(),
+                    parkingQueryRequest.getRadius());
+        }
+        return parkingRepository.findAroundParkingLots(middleLocation.getPoint(), parkingQueryRequest.getRadius());
+    }
+
+    private ParkingResponse toParkingResponse(Parking parking) {
+        return new ParkingResponse(
+                parking.getId(),
+                parking.getBaseInformation().getName(),
+                null,
+                null,
+                parking.getBaseInformation().getParkingType().getDescription(),
+                false,
+                parking.getLocation().getLatitude(),
+                parking.getLocation().getLongitude()
+        );
+    }
+}

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,42 @@
+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.dto.ParkingQueryCondition;
+import lombok.Getter;
+
+@Getter
+public class ParkingQueryRequest {
+
+    private final String operationType;
+    private final String parkingType;
+    private final String feeType;
+    private final Boolean cardEnabled;
+    private final String priority;
+    private final Integer hours;
+    private final Double latitude;
+    private final Double longitude;
+    private final Integer radius;
+
+    public ParkingQueryRequest(String operationType, String parkingType, String feeType, Boolean cardEnabled,
+                               String priority,
+                               Integer hours, Double latitude, Double longitude, Integer radius) {
+        this.operationType = operationType;
+        this.parkingType = parkingType;
+        this.feeType = feeType;
+        this.cardEnabled = cardEnabled;
+        this.priority = priority;
+        this.hours = hours;
+        this.latitude = latitude;
+        this.longitude = longitude;
+        this.radius = radius;
+    }
+
+    public ParkingQueryCondition toQueryCondition() {
+        return new ParkingQueryCondition(
+                OperationType.find(this.operationType),
+                ParkingType.find(this.parkingType),
+                this.cardEnabled
+        );
+    }
+}

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

@@ -0,0 +1,20 @@
+package com.example.parking.config.argumentresolver;
+
+import com.example.parking.config.argumentresolver.parking.ParkingQueryArgumentResolver;
+import java.util.List;
+import lombok.RequiredArgsConstructor;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.web.method.support.HandlerMethodArgumentResolver;
+import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
+
+@RequiredArgsConstructor
+@Configuration
+public class WebMvcConfig implements WebMvcConfigurer {
+
+    private final ParkingQueryArgumentResolver parkingQueryArgumentResolver;
+
+    @Override
+    public void addArgumentResolvers(List<HandlerMethodArgumentResolver> resolvers) {
+        resolvers.add(parkingQueryArgumentResolver);
+    }
+}

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 {
+}

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

@@ -0,0 +1,34 @@
+package com.example.parking.config.argumentresolver.parking;
+
+import com.example.parking.application.parking.dto.ParkingQueryRequest;
+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 ParkingQueryArgumentResolver implements HandlerMethodArgumentResolver {
+
+    @Override
+    public boolean supportsParameter(MethodParameter parameter) {
+        return parameter.hasParameterAnnotation(ParkingQuery.class);
+    }
+
+    @Override
+    public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer,
+                                  NativeWebRequest webRequest, WebDataBinderFactory binderFactory) {
+        return new ParkingQueryRequest(
+                webRequest.getParameter("operationType"),
+                webRequest.getParameter("parkingType"),
+                webRequest.getParameter("feeType"),
+                Boolean.parseBoolean(webRequest.getParameter("cardEnabled")),
+                webRequest.getParameter("priority"),
+                Integer.parseInt(webRequest.getParameter("hours")),
+                Double.valueOf(webRequest.getParameter("latitude")),
+                Double.valueOf(webRequest.getParameter("longitude")),
+                Integer.parseInt(webRequest.getParameter("radius"))
+        );
+    }
+}

src/main/java/com/example/parking/domain/parking/BaseInformation.java

@@ -1,14 +1,18 @@
 package com.example.parking.domain.parking;
 
-import static jakarta.persistence.EnumType.*;
+import static jakarta.persistence.EnumType.STRING;
 import static lombok.AccessLevel.PROTECTED;
 
 import jakarta.persistence.Embeddable;
 import jakarta.persistence.Embedded;
 import jakarta.persistence.Enumerated;
+import lombok.Getter;
 import lombok.NoArgsConstructor;
+import lombok.ToString;
 
 @NoArgsConstructor(access = PROTECTED)
+@Getter
+@ToString(of = "name")
 @Embeddable
 public class BaseInformation {
 
@@ -17,21 +21,29 @@ public class BaseInformation {
     private String address;
 
     @Embedded
-    private PayTypes payType;
+    private PayTypes payTypes;
 
     @Enumerated(STRING)
     private ParkingType parkingType;
 
     @Enumerated(STRING)
     private OperationType operationType;
 
-    public BaseInformation(String name, String tel, String address, PayTypes payType, ParkingType parkingType,
+    public BaseInformation(String name, String tel, String address, PayTypes payTypes, ParkingType parkingType,
                            OperationType operationType) {
         this.name = name;
         this.tel = tel;
         this.address = address;
-        this.payType = payType;
+        this.payTypes = payTypes;
         this.parkingType = parkingType;
         this.operationType = operationType;
     }
+
+    public boolean isMatchOperationType(OperationType operationType) {
+        return this.operationType == operationType;
+    }
+
+    public boolean isMatchParkingType(ParkingType parkingType) {
+        return this.parkingType == parkingType;
+    }
 }