Make possible for contracts to declare parameters as ignored

Author: velo

core/src/main/java/feign/Contract.java

@@ -13,19 +13,15 @@
  */
 package feign;
 
+import static feign.Util.checkState;
+import static feign.Util.emptyToNull;
 import java.lang.annotation.Annotation;
 import java.lang.reflect.*;
 import java.net.URI;
 import java.util.*;
-import java.util.function.BiConsumer;
-import java.util.function.BiFunction;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
-import java.util.stream.Collectors;
-import feign.Contract.DeclarativeContract.ClassAnnotationProcessor;
 import feign.Request.HttpMethod;
-import static feign.Util.checkState;
-import static feign.Util.emptyToNull;
 
 /**
  * Defines what annotations and values are valid on interfaces.
@@ -106,9 +102,15 @@ protected MethodMetadata parseAndValidateMetadata(Class<?> targetType, Method me
         if (parameterAnnotations[i] != null) {
           isHttpAnnotation = processAnnotationsOnParameter(data, parameterAnnotations[i], i);
         }
+
+        if (isHttpAnnotation) {
+          data.ignoreParamater(i);
+        }
+
         if (parameterTypes[i] == URI.class) {
           data.urlIndex(i);
-        } else if (!isHttpAnnotation && parameterTypes[i] != Request.Options.class) {
+        } else if (!isHttpAnnotation && parameterTypes[i] != Request.Options.class
+            && !data.isAlreadyProcessed(i)) {
           checkState(data.formParams().isEmpty(),
               "Body parameters cannot be used with form parameters.");
           checkState(data.bodyIndex() == null, "Method has too many Body parameters: %s", method);
@@ -220,6 +222,7 @@ public abstract class DeclarativeContract extends BaseContract {
     Map<Class<Annotation>, ParameterAnnotationProcessor<Annotation>> parameterAnnotationProcessors =
         new HashMap<>();
 
+    @Override
     public final List<MethodMetadata> parseAndValidatateMetadata(Class<?> targetType) {
       // any implementations must register processors
       return super.parseAndValidatateMetadata(targetType);
@@ -263,17 +266,17 @@ protected void processAnnotationOnMethod(MethodMetadata data,
      * @return true if you called {@link #nameParam(MethodMetadata, String, int)} after finding an
      *         http-relevant annotation.
      */
+    @Override
     protected final boolean processAnnotationsOnParameter(MethodMetadata data,
                                                           Annotation[] annotations,
                                                           int paramIndex) {
-      return Arrays.stream(annotations)
+      Arrays.stream(annotations)
           .filter(
               annotation -> parameterAnnotationProcessors.containsKey(annotation.annotationType()))
-          .map(annotation -> parameterAnnotationProcessors
+          .forEach(annotation -> parameterAnnotationProcessors
               .getOrDefault(annotation.annotationType(), ParameterAnnotationProcessor.DO_NOTHING)
-              .process(annotation, data, paramIndex))
-          .collect(Collectors.reducing(Boolean::logicalOr))
-          .orElse(false);
+              .process(annotation, data, paramIndex));
+      return false;
     }
 
     @FunctionalInterface
@@ -332,7 +335,8 @@ protected <E extends Annotation> void registerMethodAnnotation(Class<E> annotati
     @FunctionalInterface
     public interface ParameterAnnotationProcessor<E extends Annotation> {
 
-      ParameterAnnotationProcessor<Annotation> DO_NOTHING = (ann, data, i) -> false;
+      ParameterAnnotationProcessor<Annotation> DO_NOTHING = (ann, data, i) -> {
+      };
 
       /**
        * @param annotation present on the current parameter annotation.
@@ -342,7 +346,7 @@ public interface ParameterAnnotationProcessor<E extends Annotation> {
        * @return true if you called {@link #nameParam(MethodMetadata, String, int)} after finding an
        *         http-relevant annotation.
        */
-      boolean process(E annotation, MethodMetadata metadata, int paramIndex);
+      void process(E annotation, MethodMetadata metadata, int paramIndex);
     }
 
     /**
@@ -424,20 +428,17 @@ public Default() {
         if (!data.template().hasRequestVariable(name)) {
           data.formParams().add(name);
         }
-        return true;
       });
       super.registerParameterAnnotation(QueryMap.class, (queryMap, data, paramIndex) -> {
         checkState(data.queryMapIndex() == null,
             "QueryMap annotation was present on multiple parameters.");
         data.queryMapIndex(paramIndex);
         data.queryMapEncoded(queryMap.encoded());
-        return true;
       });
       super.registerParameterAnnotation(HeaderMap.class, (queryMap, data, paramIndex) -> {
         checkState(data.headerMapIndex() == null,
             "HeaderMap annotation was present on multiple parameters.");
         data.headerMapIndex(paramIndex);
-        return true;
       });
     }
 

core/src/main/java/feign/MethodMetadata.java

@@ -15,11 +15,7 @@
 
 import java.io.Serializable;
 import java.lang.reflect.Type;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
+import java.util.*;
 import feign.Param.Expander;
 
 public final class MethodMetadata implements Serializable {
@@ -41,6 +37,7 @@ public final class MethodMetadata implements Serializable {
       new LinkedHashMap<Integer, Class<? extends Expander>>();
   private Map<Integer, Boolean> indexToEncoded = new LinkedHashMap<Integer, Boolean>();
   private transient Map<Integer, Expander> indexToExpander;
+  private BitSet parameterToIgnore = new BitSet();
 
   MethodMetadata() {}
 
@@ -163,4 +160,50 @@ public MethodMetadata indexToExpander(Map<Integer, Expander> indexToExpander) {
   public Map<Integer, Expander> indexToExpander() {
     return indexToExpander;
   }
+
+  /**
+   * @param i individual parameter that should be ignored
+   * @return this instance
+   */
+  public MethodMetadata ignoreParamater(int i) {
+    this.parameterToIgnore.set(i);
+    return this;
+  }
+
+  public BitSet parameterToIgnore() {
+    return parameterToIgnore;
+  }
+
+  public MethodMetadata parameterToIgnore(BitSet parameterToIgnore) {
+    this.parameterToIgnore = parameterToIgnore;
+    return this;
+  }
+
+  /**
+   * @param i individual parameter to check if should be ignored
+   * @return true when field should not be processed by feign
+   */
+  public boolean shouldIgnoreParamater(int i) {
+    return parameterToIgnore.get(i);
+  }
+
+  /**
+   * @param index
+   * @return true if the parameter {@code index} was already consumed by a any
+   *         {@link MethodMetadata} holder
+   */
+  public boolean isAlreadyProcessed(Integer index) {
+    return index.equals(urlIndex)
+        || index.equals(bodyIndex)
+        || index.equals(headerMapIndex)
+        || index.equals(queryMapIndex)
+        || indexToName.containsKey(index)
+        || indexToExpanderClass.containsKey(index)
+        || indexToEncoded.containsKey(index)
+        || (indexToExpander != null && indexToExpander.containsKey(index))
+        || parameterToIgnore.get(index);
+  }
+
+
+
 }

jaxrs/src/main/java/feign/jaxrs/JAXRSContract.java

@@ -138,7 +138,6 @@ protected void registerParamAnnotations() {
         checkState(emptyToNull(name) != null, "PathParam.value() was empty on parameter %s",
             paramIndex);
         nameParam(data, name, paramIndex);
-        return true;
       });
       registerParameterAnnotation(QueryParam.class, (param, data, paramIndex) -> {
         final String name = param.value();
@@ -147,7 +146,6 @@ protected void registerParamAnnotations() {
         final String query = addTemplatedParam(name);
         data.template().query(name, query);
         nameParam(data, name, paramIndex);
-        return true;
       });
       registerParameterAnnotation(HeaderParam.class, (param, data, paramIndex) -> {
         final String name = param.value();
@@ -156,15 +154,13 @@ protected void registerParamAnnotations() {
         final String header = addTemplatedParam(name);
         data.template().header(name, header);
         nameParam(data, name, paramIndex);
-        return true;
       });
       registerParameterAnnotation(FormParam.class, (param, data, paramIndex) -> {
         final String name = param.value();
         checkState(emptyToNull(name) != null, "FormParam.value() was empty on parameter %s",
             paramIndex);
         data.formParams().add(name);
         nameParam(data, name, paramIndex);
-        return true;
       });
     }
   }

jaxrs2/src/main/java/feign/jaxrs2/JAXRS2Contract.java

@@ -28,8 +28,8 @@ public JAXRS2Contract() {
     // this will prevent interfaces from becoming unusable entirely due to single (unsupported)
     // endpoints.
     // https://github.com/OpenFeign/feign/issues/669
-    super.registerParameterAnnotation(Suspended.class, (ann, data, i) -> true);
-    super.registerParameterAnnotation(Context.class, (ann, data, i) -> true);
+    super.registerParameterAnnotation(Suspended.class, (ann, data, i) -> data.ignoreParamater(i));
+    super.registerParameterAnnotation(Context.class, (ann, data, i) -> data.ignoreParamater(i));
   }
 
 }