Add support for multi-value query parameters

Signed-off-by: Daeho Kwon <trewq231@naver.com>

Author: kwondh5217

core/src/main/java/com/linecorp/armeria/internal/server/annotation/AnnotatedValueResolver.java

@@ -64,6 +64,7 @@
 import com.google.common.base.MoreObjects;
 import com.google.common.base.Splitter;
 import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Iterables;
 import com.google.common.primitives.Primitives;
 
@@ -607,10 +608,12 @@ private static AnnotatedValueResolver ofQueryParamMap(String name,
         final Class<?> rawValueType = ClassUtil.typeToClass(valueType);
         assert rawValueType != null;
 
-        if (valueType instanceof ParameterizedType && !List.class.isAssignableFrom(rawValueType)) {
+        if (valueType instanceof ParameterizedType && !(rawValueType == Iterable.class ||
+                                                        rawValueType == List.class ||
+                                                        rawValueType == Collection.class ||
+                                                        rawValueType == Set.class)) {
             throw new IllegalArgumentException(
-                    "Invalid Map value type: " + rawValueType +
-                    ". Only List<?> is supported for multi-value query parameters.");
+                    "Invalid Map value type: " + rawValueType);
         }
 
         final BiFunction<AnnotatedValueResolver, ResolverContext, Object> biFunction;
@@ -626,6 +629,17 @@ private static AnnotatedValueResolver ofQueryParamMap(String name,
                                                                             .addAll(replacement)
                                                                             .build()
                                                ));
+        } else if (Set.class.isAssignableFrom(rawValueType)) {
+            biFunction = (resolver, ctx) -> ctx.queryParams().stream()
+                                               .collect(toImmutableMap(
+                                                       Entry::getKey,
+                                                       e -> ImmutableSet.of(e.getValue()),
+                                                       (existing, replacement) ->
+                                                               ImmutableSet.<String>builder()
+                                                                           .addAll(existing)
+                                                                           .addAll(replacement)
+                                                                           .build()
+                                               ));
         } else {
             biFunction = (resolver, ctx) -> ctx.queryParams().stream()
                                                .collect(toImmutableMap(

core/src/test/java/com/linecorp/armeria/internal/server/annotation/AnnotatedServiceTest.java

@@ -640,8 +640,16 @@ public String map(RequestContext ctx, @Param Map<String, Object> map) {
                                                 .collect(Collectors.joining(", "));
         }
 
-        @Get("/param/multiValueMap")
-        public String multiValueMap(RequestContext ctx, @Param Map<String, List<Object>> map) {
+        @Get("/param/listMap")
+        public String listMap(RequestContext ctx, @Param Map<String, List<Object>> map) {
+            validateContext(ctx);
+            return map.isEmpty() ? "empty" : map.entrySet().stream()
+                                                .map(entry -> entry.getKey() + '=' + entry.getValue())
+                                                .collect(Collectors.joining(", "));
+        }
+
+        @Get("/param/setMap")
+        public String setMap(RequestContext ctx, @Param Map<String, Set<Object>> map) {
             validateContext(ctx);
             return map.isEmpty() ? "empty" : map.entrySet().stream()
                                                 .map(entry -> entry.getKey() + '=' + entry.getValue())
@@ -1089,10 +1097,15 @@ void testParam() throws Exception {
                      "key1=value1, key2=value2");
             testBody(hc, get("/7/param/map"), "empty");
 
-            // Case all query parameters test multi value map
-            testBody(hc, get("/7/param/multiValueMap?key1=value1&key1=value2&key2=value1&key2=value2"),
+            // Case all query parameters test multi value map of List
+            testBody(hc, get("/7/param/listMap?key1=value1&key1=value2&key2=value1&key2=value2"),
                      "key1=[value1, value2], key2=[value1, value2]");
-            testBody(hc, get("/7/param/multiValueMap"), "empty");
+            testBody(hc, get("/7/param/listMap"), "empty");
+
+            // Case all query parameters test multi value map of Set
+            testBody(hc, get("/7/param/setMap?key1=value1&key1=value1&key2=value2&key2=value2"),
+                     "key1=[value1], key2=[value2]");
+            testBody(hc, get("/7/param/setMap"), "empty");
         }
     }
 

core/src/test/java/com/linecorp/armeria/internal/server/annotation/AnnotatedValueResolverTest.java

@@ -108,12 +108,14 @@ class AnnotatedValueResolverTest {
                                                               "value3",
                                                               "value2");
 
+    static final Set<String> queryParamMaps = ImmutableSet.of("queryParamMap",
+                                                              "queryParamListMap",
+                                                              "queryParamSetMap");
+
     static final ResolverContext resolverContext;
     static final ServiceRequestContext context;
     static final HttpRequest request;
     static final RequestHeaders originalHeaders;
-    static final String QUERY_PARAM_MAP = "queryParamMap";
-    static final String QUERY_PARAM_MULTI_VALUE_MAP = "queryParamMultiValueMap";
     static Map<String, AttributeKey<?>> successExpectAttrKeys;
     static Map<String, AttributeKey<?>> failExpectAttrKeys;
 
@@ -374,8 +376,7 @@ private static void testResolver(AnnotatedValueResolver resolver) {
                     }
                 }
             } else {
-                if (QUERY_PARAM_MAP.equals(resolver.httpElementName()) ||
-                    QUERY_PARAM_MULTI_VALUE_MAP.equals(resolver.httpElementName())) {
+                if (queryParamMaps.contains(resolver.httpElementName())) {
                     assertThat(resolver.defaultValue()).isNull();
                 } else {
                     assertThat(resolver.defaultValue()).isNotNull();
@@ -387,8 +388,7 @@ private static void testResolver(AnnotatedValueResolver resolver) {
                             .isEqualTo(resolver.elementType());
                 } else if (resolver.shouldWrapValueAsOptional()) {
                     assertThat(value).isEqualTo(Optional.of(resolver.defaultValue()));
-                } else if (QUERY_PARAM_MAP.equals(resolver.httpElementName()) ||
-                           QUERY_PARAM_MULTI_VALUE_MAP.equals(resolver.httpElementName())) {
+                } else if (queryParamMaps.contains(resolver.httpElementName())) {
                     assertThat(value).isNotNull();
                     assertThat(value).isInstanceOf(Map.class);
                     assertThat((Map<?, ?>) value).size()
@@ -471,7 +471,8 @@ void method1(@Param String var1,
                      @Param @Default List<String> emptyParam3,
                      @Param @Default List<Integer> emptyParam4,
                      @Param Map<String, Object> queryParamMap,
-                     @Param Map<String, List<Object>> queryParamMultiValueMap,
+                     @Param Map<String, List<Object>> queryParamListMap,
+                     @Param Map<String, Set<Object>> queryParamSetMap,
                      @Header List<String> header1,
                      @Header("header1") Optional<List<ValueEnum>> optionalHeader1,
                      @Header String header2,
@@ -548,8 +549,6 @@ void time(@Param @Default("PT20.345S") Duration duration,
     }
 
     static class InvalidMultiValueMapService {
-        void invalidParamWithMapOfSet(@Param Map<String, Set<String>> param) {}
-
         void invalidParamWithMapOfMap(@Param Map<String, Map<String, String>> param) {}
     }