fix: 핀 조회 파라미터 복구 및 필터 파싱 재적용

src/main/java/com/zimdugo/locker/application/filter/IndoorOutdoorFilterType.java

@@ -0,0 +1,12 @@
+package com.zimdugo.locker.application.filter;
+
+import com.zimdugo.locker.domain.locker.IndoorOutdoorType;
+
+public enum IndoorOutdoorFilterType {
+    INDOOR,
+    OUTDOOR;
+
+    public IndoorOutdoorType toDomain() {
+        return IndoorOutdoorType.valueOf(name());
+    }
+}

src/main/java/com/zimdugo/locker/application/filter/LockerFacilityFilterType.java

@@ -0,0 +1,18 @@
+package com.zimdugo.locker.application.filter;
+
+import com.zimdugo.locker.domain.locker.LockerType;
+
+public enum LockerFacilityFilterType {
+    MUSEUM,
+    SUBWAY_STATION,
+    DEPARTMENT_STORE,
+    CONVENIENCE_STORE,
+    PUBLIC_OFFICE,
+    PRIVATE_LOCKER,
+    TRAIN_STATION,
+    ETC;
+
+    public LockerType toDomain() {
+        return LockerType.valueOf(name());
+    }
+}

src/main/java/com/zimdugo/locker/application/filter/LockerSearchFilterFactory.java

@@ -0,0 +1,35 @@
+package com.zimdugo.locker.application.filter;
+
+import com.zimdugo.locker.domain.search.LockerSearchFilter;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+public final class LockerSearchFilterFactory {
+
+    private LockerSearchFilterFactory() {
+    }
+
+    public static LockerSearchFilter create(
+        Set<LockerSizeFilterType> sizeTypes,
+        Set<IndoorOutdoorFilterType> indoorOutdoorTypes,
+        Set<LockerFacilityFilterType> lockerTypes
+    ) {
+        return new LockerSearchFilter(
+            sizeTypes == null
+                ? Set.of()
+                : sizeTypes.stream()
+                    .map(LockerSizeFilterType::toDomain)
+                    .collect(Collectors.toUnmodifiableSet()),
+            indoorOutdoorTypes == null
+                ? Set.of()
+                : indoorOutdoorTypes.stream()
+                    .map(IndoorOutdoorFilterType::toDomain)
+                    .collect(Collectors.toUnmodifiableSet()),
+            lockerTypes == null
+                ? Set.of()
+                : lockerTypes.stream()
+                    .map(LockerFacilityFilterType::toDomain)
+                    .collect(Collectors.toUnmodifiableSet())
+        );
+    }
+}

src/main/java/com/zimdugo/locker/application/filter/LockerSizeFilterType.java

@@ -0,0 +1,13 @@
+package com.zimdugo.locker.application.filter;
+
+import com.zimdugo.locker.domain.locker.LockerSizeType;
+
+public enum LockerSizeFilterType {
+    SMALL,
+    MEDIUM,
+    LARGE;
+
+    public LockerSizeType toDomain() {
+        return LockerSizeType.valueOf(name());
+    }
+}

src/main/java/com/zimdugo/locker/application/pin/LockerPinQuery.java

@@ -1,5 +1,8 @@
 package com.zimdugo.locker.application.pin;
 
+import com.zimdugo.locker.application.filter.IndoorOutdoorFilterType;
+import com.zimdugo.locker.application.filter.LockerFacilityFilterType;
+import com.zimdugo.locker.application.filter.LockerSizeFilterType;
 import java.util.Set;
 
 public record LockerPinQuery(
@@ -8,12 +11,12 @@ public record LockerPinQuery(
     double neLat,
     double neLng,
     double zoomLevel,
-    Double latitude,
-    Double longitude,
+    Double userLat,
+    Double userLng,
     String keyword,
-    Set<String> sizeTypes,
-    Set<String> indoorOutdoorTypes,
-    Set<String> lockerTypes
+    Set<LockerSizeFilterType> sizeTypes,
+    Set<IndoorOutdoorFilterType> indoorOutdoorTypes,
+    Set<LockerFacilityFilterType> lockerTypes
 ) {
     public LockerPinQuery(
         double swLat,

src/main/java/com/zimdugo/locker/application/pin/LockerPinQueryService.java

@@ -1,5 +1,6 @@
 package com.zimdugo.locker.application.pin;
 
+import com.zimdugo.locker.application.filter.LockerSearchFilterFactory;
 import com.zimdugo.locker.application.common.LocationValidator;
 import com.zimdugo.locker.application.search.LockerSearchResultQueryService;
 import com.zimdugo.locker.application.result.search.LockerSearchItemResult;
@@ -29,9 +30,9 @@ public class LockerPinQueryService {
     private final LockerSearchResultQueryService lockerSearchResultQueryService;
 
     public LockerPinResult getPins(Long userId, LockerPinQuery query) {
-        LocationValidator.validateBounds(query.swLat(), query.swLng(), query.neLat(), query.neLng());
+        LocationValidator.validateBounds(query.swLat(), query.swLng(), query.neLat(), query.neLng()); //좌표 검증
 
-        LockerSearchFilter filter = LockerSearchFilter.from(
+        LockerSearchFilter filter = LockerSearchFilterFactory.create(
             query.sizeTypes(),
             query.indoorOutdoorTypes(),
             query.lockerTypes()
@@ -58,14 +59,14 @@ public LockerPinResult getPins(Long userId, LockerPinQuery query) {
     }
 
     private LockerPinResult getSearchPins(Long userId, LockerPinQuery query, LockerSearchFilter filter) {
-        if (query.latitude() == null || query.longitude() == null) {
+        if (query.userLat() == null || query.userLng() == null) {
             return LockerPinResult.empty();
         }
 
         List<LockerSearchItemResult> items = lockerSearchResultQueryService.getDisplayableSearchItemsForPins(
             userId,
-            query.latitude(),
-            query.longitude(),
+            query.userLat(),
+            query.userLng(),
             query.keyword(),
             filter
         );

src/main/java/com/zimdugo/locker/application/place/PlaceLockerQueryCommand.java

@@ -1,13 +1,16 @@
 package com.zimdugo.locker.application.place;
 
+import com.zimdugo.locker.application.filter.IndoorOutdoorFilterType;
+import com.zimdugo.locker.application.filter.LockerFacilityFilterType;
+import com.zimdugo.locker.application.filter.LockerSizeFilterType;
 import java.util.Set;
 
 public record PlaceLockerQueryCommand(
     Long placeId,
     double latitude,
     double longitude,
-    Set<String> sizeTypes,
-    Set<String> indoorOutdoorTypes,
-    Set<String> lockerTypes
+    Set<LockerSizeFilterType> sizeTypes,
+    Set<IndoorOutdoorFilterType> indoorOutdoorTypes,
+    Set<LockerFacilityFilterType> lockerTypes
 ) {
 }

src/main/java/com/zimdugo/locker/application/place/PlaceLockerQueryService.java

@@ -1,5 +1,6 @@
 package com.zimdugo.locker.application.place;
 
+import com.zimdugo.locker.application.filter.LockerSearchFilterFactory;
 import com.zimdugo.common.i18n.CurrentRequestLanguage;
 import com.zimdugo.core.exception.BusinessException;
 import com.zimdugo.core.exception.ErrorCode;
@@ -37,7 +38,7 @@ public PlaceLockerResult getPlaceLockers(Long userId, PlaceLockerQueryCommand co
 
         LockerPlace place = lockerPlaceReader.readById(command.placeId(), languageCode)
             .orElseThrow(() -> new BusinessException(ErrorCode.PLACE_NOT_FOUND));
-        LockerSearchFilter filter = LockerSearchFilter.from(
+        LockerSearchFilter filter = LockerSearchFilterFactory.create(
             command.sizeTypes(),
             command.indoorOutdoorTypes(),
             command.lockerTypes()

src/main/java/com/zimdugo/locker/application/search/LockerSearchCommand.java

@@ -1,14 +1,17 @@
 package com.zimdugo.locker.application.search;
 
+import com.zimdugo.locker.application.filter.IndoorOutdoorFilterType;
+import com.zimdugo.locker.application.filter.LockerFacilityFilterType;
+import com.zimdugo.locker.application.filter.LockerSizeFilterType;
 import java.util.Set;
 
 public record LockerSearchCommand(
     double latitude,
     double longitude,
     String keyword,
-    Set<String> sizeTypes,
-    Set<String> indoorOutdoorTypes,
-    Set<String> lockerTypes,
+    Set<LockerSizeFilterType> sizeTypes,
+    Set<IndoorOutdoorFilterType> indoorOutdoorTypes,
+    Set<LockerFacilityFilterType> lockerTypes,
     Double zoom
 ) {
 }

src/main/java/com/zimdugo/locker/application/search/LockerSearchResultQueryService.java

@@ -1,5 +1,6 @@
 package com.zimdugo.locker.application.search;
 
+import com.zimdugo.locker.application.filter.LockerSearchFilterFactory;
 import com.zimdugo.common.i18n.CurrentRequestLanguage;
 import com.zimdugo.locker.application.pin.LockerSearchPinAssembler;
 import com.zimdugo.locker.application.pin.LockerPinClusterer;
@@ -102,7 +103,7 @@ public LockerSearchResult getSearchResults(
     }
 
     private LockerSearchFilter toSearchFilter(LockerSearchCommand command) {
-        return LockerSearchFilter.from(
+        return LockerSearchFilterFactory.create(
             command.sizeTypes(),
             command.indoorOutdoorTypes(),
             command.lockerTypes()

src/main/java/com/zimdugo/locker/domain/search/LockerSearchFilter.java

@@ -1,21 +1,11 @@
 package com.zimdugo.locker.domain.search;
 
-import com.zimdugo.core.exception.BusinessException;
-import com.zimdugo.core.exception.ErrorCode;
 import com.zimdugo.locker.domain.locker.IndoorOutdoorType;
 import com.zimdugo.locker.domain.locker.LockerSizeType;
 import com.zimdugo.locker.domain.locker.LockerType;
-import java.util.Arrays;
 import java.util.Collections;
 import java.util.EnumSet;
-import java.util.Locale;
-import java.util.Objects;
 import java.util.Set;
-import java.util.function.Function;
-import java.util.stream.Collectors;
-import lombok.extern.slf4j.Slf4j;
-
-@Slf4j
 public record LockerSearchFilter(
     Set<LockerSizeType> sizeTypes,
     Set<IndoorOutdoorType> indoorOutdoorTypes,
@@ -38,30 +28,6 @@ public static LockerSearchFilter empty() {
         return new LockerSearchFilter(Set.of(), Set.of(), Set.of());
     }
 
-    public static LockerSearchFilter from(
-        Set<String> sizeTypes,
-        Set<String> indoorOutdoorTypes,
-        Set<String> lockerTypes
-    ) {
-        log.debug(
-            "검색 필터 파싱 시작. sizeTypes={}, indoorOutdoorTypes={}, lockerTypes={}",
-            sizeTypes,
-            indoorOutdoorTypes,
-            lockerTypes
-        );
-
-        Set<LockerSizeType> parsedSizeTypes = parseEnumSet(sizeTypes, LockerSizeType::from);
-        Set<IndoorOutdoorType> parsedIndoorOutdoorTypes =
-            parseEnumSet(indoorOutdoorTypes, val -> parse(val, IndoorOutdoorType.class));
-        Set<LockerType> parsedLockerTypes = parseEnumSet(lockerTypes, val -> parse(val, LockerType.class));
-
-        return new LockerSearchFilter(
-            parsedSizeTypes,
-            parsedIndoorOutdoorTypes,
-            parsedLockerTypes
-        );
-    }
-
     public boolean isEmpty() {
         return sizeTypes.isEmpty() && indoorOutdoorTypes.isEmpty() && lockerTypes.isEmpty();
     }
@@ -75,33 +41,4 @@ public boolean matches(
             && (indoorOutdoorTypes.isEmpty() || indoorOutdoorTypes.contains(lockerIndoorOutdoorType))
             && (lockerTypes.isEmpty() || lockerTypes.contains(actualLockerType));
     }
-
-    private static <T extends Enum<T>> Set<T> parseEnumSet(
-        Set<String> values,
-        Function<String, T> mapper
-    ) {
-        if (values == null) {
-            return Set.of();
-        }
-        return values.stream()
-            .filter(Objects::nonNull)
-            .map(value -> value.replaceAll("[\\[\\]\"]", ""))
-            .flatMap(value -> Arrays.stream(value.split(",")))
-            .map(String::trim)
-            .map(mapper)
-            .filter(Objects::nonNull)
-            .collect(Collectors.toUnmodifiableSet());
-    }
-
-    private static <T extends Enum<T>> T parse(String value, Class<T> enumType) {
-        if (value == null || value.isBlank()) {
-            return null;
-        }
-
-        try {
-            return Enum.valueOf(enumType, value.trim().toUpperCase(Locale.ROOT));
-        } catch (IllegalArgumentException e) {
-            throw new BusinessException(ErrorCode.INVALID_PARAMETER_FORMAT);
-        }
-    }
 }

src/main/java/com/zimdugo/locker/entrypoint/config/LockerRequestWebMvcConfig.java

@@ -0,0 +1,19 @@
+package com.zimdugo.locker.entrypoint.config;
+
+import com.zimdugo.locker.entrypoint.converter.IndoorOutdoorTypeRequestConverter;
+import com.zimdugo.locker.entrypoint.converter.LockerSizeTypeRequestConverter;
+import com.zimdugo.locker.entrypoint.converter.LockerTypeRequestConverter;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.format.FormatterRegistry;
+import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
+
+@Configuration
+public class LockerRequestWebMvcConfig implements WebMvcConfigurer {
+
+    @Override
+    public void addFormatters(FormatterRegistry registry) {
+        registry.addConverter(new LockerSizeTypeRequestConverter());
+        registry.addConverter(new IndoorOutdoorTypeRequestConverter());
+        registry.addConverter(new LockerTypeRequestConverter());
+    }
+}

src/main/java/com/zimdugo/locker/entrypoint/converter/IndoorOutdoorTypeRequestConverter.java

@@ -0,0 +1,24 @@
+package com.zimdugo.locker.entrypoint.converter;
+
+import com.zimdugo.core.exception.BusinessException;
+import com.zimdugo.core.exception.ErrorCode;
+import com.zimdugo.locker.application.filter.IndoorOutdoorFilterType;
+import java.util.Locale;
+import org.springframework.core.convert.converter.Converter;
+
+public class IndoorOutdoorTypeRequestConverter implements Converter<String, IndoorOutdoorFilterType> {
+
+    @Override
+    public IndoorOutdoorFilterType convert(String source) {
+        String normalized = LockerFilterRequestValueNormalizer.normalize(source);
+        if (normalized == null || normalized.isBlank()) {
+            return null;
+        }
+
+        try {
+            return IndoorOutdoorFilterType.valueOf(normalized.toUpperCase(Locale.ROOT));
+        } catch (IllegalArgumentException e) {
+            throw new BusinessException(ErrorCode.INVALID_PARAMETER_FORMAT);
+        }
+    }
+}

src/main/java/com/zimdugo/locker/entrypoint/converter/LockerFilterRequestValueNormalizer.java

@@ -0,0 +1,14 @@
+package com.zimdugo.locker.entrypoint.converter;
+
+final class LockerFilterRequestValueNormalizer {
+
+    private LockerFilterRequestValueNormalizer() {
+    }
+
+    static String normalize(String source) {
+        if (source == null) {
+            return null;
+        }
+        return source.replaceAll("[\\[\\]\"]", "").trim();
+    }
+}

src/main/java/com/zimdugo/locker/entrypoint/converter/LockerSizeTypeRequestConverter.java

@@ -0,0 +1,24 @@
+package com.zimdugo.locker.entrypoint.converter;
+
+import com.zimdugo.core.exception.BusinessException;
+import com.zimdugo.core.exception.ErrorCode;
+import com.zimdugo.locker.application.filter.LockerSizeFilterType;
+import java.util.Locale;
+import org.springframework.core.convert.converter.Converter;
+
+public class LockerSizeTypeRequestConverter implements Converter<String, LockerSizeFilterType> {
+
+    @Override
+    public LockerSizeFilterType convert(String source) {
+        String normalized = LockerFilterRequestValueNormalizer.normalize(source);
+        if (normalized == null || normalized.isBlank()) {
+            return null;
+        }
+
+        try {
+            return LockerSizeFilterType.valueOf(normalized.toUpperCase(Locale.ROOT));
+        } catch (IllegalArgumentException e) {
+            throw new BusinessException(ErrorCode.INVALID_LOCKER_SIZE_TYPE);
+        }
+    }
+}