OpenFeign · velo · Apr 23, 2018 · Mar 23, 2018 · Mar 24, 2018 · Mar 26, 2018
diff --git a/README.md b/README.md
@@ -444,6 +444,35 @@ A Map parameter can be annotated with `QueryMap` to construct a query that uses
 V find(@QueryMap Map<String, Object> queryMap);
 ```
 
+This may also be used to generate the query parameters from a POJO object using a `QueryMapEncoder`.
+
+```java
+@RequestLine("GET /find")
+V find(@QueryMap CustomPojo customPojo);
+```
+
+When used in this manner, without specifying a custom `QueryMapEncoder`, the query map will be generated using member variable names as query parameter names. The following POJO will generate query params of "/find?name={name}&number={number}" (order of included query parameters not guaranteed, and as usual, if any value is null, it will be left out).
+
+```java
+public class CustomPojo {
+  private final String name;
+  private final int number;
+
+  public CustomPojo (String name, int number) {
+    this.name = name;
+    this.number = number;
+  }
+}
+```
+
+To setup a custom `QueryMapEncoder`:
+
+```java
+MyApi myApi = Feign.builder()
+                 .queryMapEncoder(new MyCustomQueryMapEncoder())
+                 .target(MyApi.class, "https://api.hostname.com");
+```
+
 #### Static and Default Methods
 Interfaces targeted by Feign may have static or default methods (if using Java 8+).
 These allows Feign clients to contain logic that is not expressly defined by the underlying API.

diff --git a/core/src/main/java/feign/Contract.java b/core/src/main/java/feign/Contract.java
@@ -123,7 +123,9 @@ protected MethodMetadata parseAndValidateMetadata(Class<?> targetType, Method me
       }
 
       if (data.queryMapIndex() != null) {
-        checkMapString("QueryMap", parameterTypes[data.queryMapIndex()], genericParameterTypes[data.queryMapIndex()]);
+        if (Map.class.isAssignableFrom(parameterTypes[data.queryMapIndex()])) {
+          checkMapKeys("QueryMap", genericParameterTypes[data.queryMapIndex()]);
+        }
       }
 
       return data;
@@ -132,6 +134,10 @@ protected MethodMetadata parseAndValidateMetadata(Class<?> targetType, Method me
     private static void checkMapString(String name, Class<?> type, Type genericType) {
       checkState(Map.class.isAssignableFrom(type),
               "%s parameter must be a Map: %s", name, type);
+      checkMapKeys(name, genericType);
+    }
+
+    private static void checkMapKeys(String name, Type genericType) {
       Type[] parameterTypes = ((ParameterizedType) genericType).getActualTypeArguments();
       Class<?> keyClass = (Class<?>) parameterTypes[0];
       checkState(String.class.equals(keyClass),

diff --git a/core/src/main/java/feign/Feign.java b/core/src/main/java/feign/Feign.java
@@ -101,6 +101,7 @@ public static class Builder {
     private Logger logger = new NoOpLogger();
     private Encoder encoder = new Encoder.Default();
     private Decoder decoder = new Decoder.Default();
+    private QueryMapEncoder queryMapEncoder = new QueryMapEncoder.Default();
     private ErrorDecoder errorDecoder = new ErrorDecoder.Default();
     private Options options = new Options();
     private InvocationHandlerFactory invocationHandlerFactory =
@@ -143,6 +144,11 @@ public Builder decoder(Decoder decoder) {
       return this;
     }
 
+    public Builder queryMapEncoder(QueryMapEncoder queryMapEncoder) {
+      this.queryMapEncoder = queryMapEncoder;
+      return this;
+    }
+
     /**
      * Allows to map the response before passing it to the decoder.
      */
@@ -241,9 +247,9 @@ public Feign build() {
           new SynchronousMethodHandler.Factory(client, retryer, requestInterceptors, logger,
                                                logLevel, decode404, closeAfterDecode);
       ParseHandlersByName handlersByName =
-          new ParseHandlersByName(contract, options, encoder, decoder,
+          new ParseHandlersByName(contract, options, encoder, decoder, queryMapEncoder,
                                   errorDecoder, synchronousMethodHandlerFactory);
-      return new ReflectiveFeign(handlersByName, invocationHandlerFactory);
+      return new ReflectiveFeign(handlersByName, invocationHandlerFactory, queryMapEncoder);
     }
   }
 

diff --git a/core/src/main/java/feign/QueryMapEncoder.java b/core/src/main/java/feign/QueryMapEncoder.java
@@ -0,0 +1,88 @@
+/**
+ * Copyright 2012-2018 The Feign Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
+ * in compliance with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
+ * or implied. See the License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package feign;
+
+import feign.codec.EncodeException;
+import java.lang.reflect.Field;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * A QueryMapEncoder encodes Objects into maps of query parameter names to values.
+ */
+public interface QueryMapEncoder {
+
+  /**
+   * Encodes the given object into a query map.
+   *
+   * @param object the object to encode
+   * @return the map represented by the object
+   */
+  Map<String, Object> encode (Object object);
+
+  class Default implements QueryMapEncoder {
+
+    private final Map<Class<?>, ObjectParamMetadata> classToMetadata =
+        new HashMap<Class<?>, ObjectParamMetadata>();
+
+    @Override
+    public Map<String, Object> encode (Object object) throws EncodeException {
+      try {
+        ObjectParamMetadata metadata = getMetadata(object.getClass());
+        Map<String, Object> fieldNameToValue = new HashMap<String, Object>();
+        for (Field field : metadata.objectFields) {
+          Object value = field.get(object);
+          if (value != null && value != object) {
+            fieldNameToValue.put(field.getName(), value);
+          }
+        }
+        return fieldNameToValue;
+      } catch (IllegalAccessException e) {
+        throw new EncodeException("Failure encoding object into query map", e);
+      }
+    }
+
+    private ObjectParamMetadata getMetadata(Class<?> objectType) {
+      ObjectParamMetadata metadata = classToMetadata.get(objectType);
+      if (metadata == null) {
+        metadata = ObjectParamMetadata.parseObjectType(objectType);
+        classToMetadata.put(objectType, metadata);
+      }
+      return metadata;
+    }
+
+    private static class ObjectParamMetadata {
+
+      private final List<Field> objectFields;
+
+      private ObjectParamMetadata (List<Field> objectFields) {
+        this.objectFields = Collections.unmodifiableList(objectFields);
+      }
+
+      private static ObjectParamMetadata parseObjectType(Class<?> type) {
+        List<Field> fields = new ArrayList<Field>();
+        for (Field field : type.getDeclaredFields()) {
+          if (!field.isAccessible()) {
+            field.setAccessible(true);
+          }
+          fields.add(field);
+        }
+        return new ObjectParamMetadata(fields);
+      }
+    }
+  }
+}
diff --git a/core/src/main/java/feign/ReflectiveFeign.java b/core/src/main/java/feign/ReflectiveFeign.java
@@ -29,16 +29,17 @@
 
 import static feign.Util.checkArgument;
 import static feign.Util.checkNotNull;
-import static feign.Util.checkState;
 
 public class ReflectiveFeign extends Feign {
 
   private final ParseHandlersByName targetToHandlersByName;
   private final InvocationHandlerFactory factory;
+  private final QueryMapEncoder queryMapEncoder;
 
-  ReflectiveFeign(ParseHandlersByName targetToHandlersByName, InvocationHandlerFactory factory) {
+  ReflectiveFeign(ParseHandlersByName targetToHandlersByName, InvocationHandlerFactory factory, QueryMapEncoder queryMapEncoder) {
     this.targetToHandlersByName = targetToHandlersByName;
     this.factory = factory;
+    this.queryMapEncoder = queryMapEncoder;
   }
 
   /**
@@ -128,14 +129,22 @@ static final class ParseHandlersByName {
     private final Encoder encoder;
     private final Decoder decoder;
     private final ErrorDecoder errorDecoder;
+    private final QueryMapEncoder queryMapEncoder;
     private final SynchronousMethodHandler.Factory factory;
 
-    ParseHandlersByName(Contract contract, Options options, Encoder encoder, Decoder decoder,
-                        ErrorDecoder errorDecoder, SynchronousMethodHandler.Factory factory) {
+    ParseHandlersByName(
+        Contract contract,
+        Options options,
+        Encoder encoder,
+        Decoder decoder,
+        QueryMapEncoder queryMapEncoder,
+        ErrorDecoder errorDecoder,
+        SynchronousMethodHandler.Factory factory) {
       this.contract = contract;
       this.options = options;
       this.factory = factory;
       this.errorDecoder = errorDecoder;
+      this.queryMapEncoder = queryMapEncoder;
       this.encoder = checkNotNull(encoder, "encoder");
       this.decoder = checkNotNull(decoder, "decoder");
     }
@@ -146,11 +155,11 @@ public Map<String, MethodHandler> apply(Target key) {
       for (MethodMetadata md : metadata) {
         BuildTemplateByResolvingArgs buildTemplate;
         if (!md.formParams().isEmpty() && md.template().bodyTemplate() == null) {
-          buildTemplate = new BuildFormEncodedTemplateFromArgs(md, encoder);
+          buildTemplate = new BuildFormEncodedTemplateFromArgs(md, encoder, queryMapEncoder);
         } else if (md.bodyIndex() != null) {
-          buildTemplate = new BuildEncodedTemplateFromArgs(md, encoder);
+          buildTemplate = new BuildEncodedTemplateFromArgs(md, encoder, queryMapEncoder);
         } else {
-          buildTemplate = new BuildTemplateByResolvingArgs(md);
+          buildTemplate = new BuildTemplateByResolvingArgs(md, queryMapEncoder);
         }
         result.put(md.configKey(),
                    factory.create(key, md, buildTemplate, options, decoder, errorDecoder));
@@ -161,11 +170,14 @@ public Map<String, MethodHandler> apply(Target key) {
 
   private static class BuildTemplateByResolvingArgs implements RequestTemplate.Factory {
 
+    private final QueryMapEncoder queryMapEncoder;
+
     protected final MethodMetadata metadata;
     private final Map<Integer, Expander> indexToExpander = new LinkedHashMap<Integer, Expander>();
 
-    private BuildTemplateByResolvingArgs(MethodMetadata metadata) {
+    private BuildTemplateByResolvingArgs(MethodMetadata metadata, QueryMapEncoder queryMapEncoder) {
       this.metadata = metadata;
+      this.queryMapEncoder = queryMapEncoder;
       if (metadata.indexToExpander() != null) {
         indexToExpander.putAll(metadata.indexToExpander());
         return;
@@ -212,7 +224,9 @@ public RequestTemplate create(Object[] argv) {
       if (metadata.queryMapIndex() != null) {
         // add query map parameters after initial resolve so that they take
         // precedence over any predefined values
-        template = addQueryMapQueryParameters((Map<String, Object>) argv[metadata.queryMapIndex()], template);
+        Object value = argv[metadata.queryMapIndex()];
+        Map<String, Object> queryMap = toQueryMap(value);
+        template = addQueryMapQueryParameters(queryMap, template);
       }
 
       if (metadata.headerMapIndex() != null) {
@@ -222,6 +236,17 @@ public RequestTemplate create(Object[] argv) {
       return template;
     }
 
+    private Map<String, Object> toQueryMap (Object value) {
+     if (value instanceof Map) {
+        return (Map<String, Object>)value;
+      }
+      try {
+        return queryMapEncoder.encode(value);
+      } catch (EncodeException e) {
+        throw new IllegalStateException(e);
+      }
+    }
+
     private Object expandElements(Expander expander, Object value) {
       if (value instanceof Iterable) {
         return expandIterable(expander, (Iterable) value);
@@ -231,7 +256,7 @@ private Object expandElements(Expander expander, Object value) {
 
     private List<String> expandIterable(Expander expander, Iterable value) {
       List<String> values = new ArrayList<String>();
-      for (Object element : (Iterable) value) {
+      for (Object element : value) {
         if (element!=null) {
           values.add(expander.expand(element));
         }
@@ -300,8 +325,8 @@ private static class BuildFormEncodedTemplateFromArgs extends BuildTemplateByRes
 
     private final Encoder encoder;
 
-    private BuildFormEncodedTemplateFromArgs(MethodMetadata metadata, Encoder encoder) {
-      super(metadata);
+    private BuildFormEncodedTemplateFromArgs(MethodMetadata metadata, Encoder encoder, QueryMapEncoder queryMapEncoder) {
+      super(metadata, queryMapEncoder);
       this.encoder = encoder;
     }
 
@@ -329,8 +354,8 @@ private static class BuildEncodedTemplateFromArgs extends BuildTemplateByResolvi
 
     private final Encoder encoder;
 
-    private BuildEncodedTemplateFromArgs(MethodMetadata metadata, Encoder encoder) {
-      super(metadata);
+    private BuildEncodedTemplateFromArgs(MethodMetadata metadata, Encoder encoder, QueryMapEncoder queryMapEncoder) {
+      super(metadata, queryMapEncoder);
       this.encoder = encoder;
     }
 

diff --git a/core/src/test/java/feign/CustomPojo.java b/core/src/test/java/feign/CustomPojo.java
@@ -0,0 +1,25 @@
+/**
+ * Copyright 2012-2018 The Feign Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
+ * in compliance with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
+ * or implied. See the License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package feign;
+
+public class CustomPojo {
+
+  private final String name;
+  private final Integer number;
+
+  CustomPojo(String name, Integer number) {
+    this.name = name;
+    this.number = number;
+  }
+}