Flux type response should be corresponding to List

core/src/main/java/feign/Types.java

@@ -23,6 +23,8 @@
 import java.util.Arrays;
 import java.util.NoSuchElementException;
 
+import static feign.Util.checkState;
+
 /**
  * Static methods for working with types.
  *
@@ -325,6 +327,40 @@ public static Type resolveReturnType(Type baseType, Type overridingType) {
     return baseType;
   }
 
+  /**
+   * Resolves the last type parameter of the parameterized {@code supertype}, based on the {@code
+   * genericContext}, into its upper bounds.
+   * <p/>
+   * Implementation copied from {@code
+   * retrofit.RestMethodInfo}.
+   *
+   * @param genericContext Ex. {@link java.lang.reflect.Field#getGenericType()}
+   * @param supertype Ex. {@code Decoder.class}
+   * @return in the example above, the type parameter of {@code Decoder}.
+   * @throws IllegalStateException if {@code supertype} cannot be resolved into a parameterized type
+   *         using {@code context}.
+   */
+  public static Type resolveLastTypeParameter(Type genericContext, Class<?> supertype)
+          throws IllegalStateException {
+    Type resolvedSuperType =
+            Types.getSupertype(genericContext, Types.getRawType(genericContext), supertype);
+    checkState(resolvedSuperType instanceof ParameterizedType,
+            "could not resolve %s into a parameterized type %s",
+            genericContext, supertype);
+    Type[] types = ParameterizedType.class.cast(resolvedSuperType).getActualTypeArguments();
+    for (int i = 0; i < types.length; i++) {
+      Type type = types[i];
+      if (type instanceof WildcardType) {
+        types[i] = ((WildcardType) type).getUpperBounds()[0];
+      }
+    }
+    return types[types.length - 1];
+  }
+
+  public static ParameterizedType parameterize(Class<?> rawClass, Type... typeArguments) {
+    return new ParameterizedTypeImpl(rawClass.getEnclosingClass(), rawClass, typeArguments);
+  }
+
   static final class ParameterizedTypeImpl implements ParameterizedType {
 
     private final Type ownerType;

core/src/main/java/feign/Util.java

@@ -215,33 +215,12 @@ public static void ensureClosed(Closeable closeable) {
   }
 
   /**
-   * Resolves the last type parameter of the parameterized {@code supertype}, based on the {@code
-   * genericContext}, into its upper bounds.
-   * <p/>
-   * Implementation copied from {@code
-   * retrofit.RestMethodInfo}.
-   *
-   * @param genericContext Ex. {@link java.lang.reflect.Field#getGenericType()}
-   * @param supertype Ex. {@code Decoder.class}
-   * @return in the example above, the type parameter of {@code Decoder}.
-   * @throws IllegalStateException if {@code supertype} cannot be resolved into a parameterized type
-   *         using {@code context}.
+   * Moved to {@code feign.Types.resolveLastTypeParameter}
    */
+  @Deprecated
   public static Type resolveLastTypeParameter(Type genericContext, Class<?> supertype)
       throws IllegalStateException {
-    Type resolvedSuperType =
-        Types.getSupertype(genericContext, Types.getRawType(genericContext), supertype);
-    checkState(resolvedSuperType instanceof ParameterizedType,
-        "could not resolve %s into a parameterized type %s",
-        genericContext, supertype);
-    Type[] types = ParameterizedType.class.cast(resolvedSuperType).getActualTypeArguments();
-    for (int i = 0; i < types.length; i++) {
-      Type type = types[i];
-      if (type instanceof WildcardType) {
-        types[i] = ((WildcardType) type).getUpperBounds()[0];
-      }
-    }
-    return types[types.length - 1];
+    return Types.resolveLastTypeParameter(genericContext, supertype);
   }
 
   /**

reactive/README.md

@@ -14,24 +14,34 @@ implementation to your classpath.  Then configure Feign to use the reactive stre
 public interface GitHubReactor {
 
   @RequestLine("GET /repos/{owner}/{repo}/contributors")
-  Flux<Contributor> contributors(@Param("owner") String owner, @Param("repo") String repo);
+  Flux<Contributor> contributorsFlux(@Param("owner") String owner, @Param("repo") String repo);
+
+  @RequestLine("GET /repos/{owner}/{repo}/contributors")
+  Mono<List<Contributor>> contributorsMono(@Param("owner") String owner, @Param("repo") String repo);
 
   class Contributor {
-    String login;
-
-    public Contributor(String login) {
-      this.login = login;
-    }
+      String login;
+
+      public String getLogin() {
+          return login;
+      }
+
+      public void setLogin(String login) {
+          this.login = login;
+      }
   }
 }
 
 public class ExampleReactor {
   public static void main(String args[]) {
-    GitHubReactor gitHub = ReactorFeign.builder()      
+    GitHubReactor gitHub = ReactorFeign.builder() 
+      .decoder(new ReactiveDecoder(new JacksonDecoder()))     
       .target(GitHubReactor.class, "https://api.github.com");
 
-    List<Contributor> contributors = gitHub.contributors("OpenFeign", "feign")
-      .collect(Collectors.toList())
+    List<GitHubReactor.Contributor> contributorsFromFlux = gitHub.contributorsFlux("OpenFeign", "feign")
+      .collectList()
+      .block();
+    List<GitHubReactor.Contributor> contributorsFromMono = gitHub.contributorsMono("OpenFeign", "feign")
       .block();
   }
 }
@@ -79,33 +89,5 @@ the wrapped in the appropriate reactive wrappers.
 ### Iterable and Collections responses
 
 Due to the Synchronous nature of Feign requests, methods that return `Iterable` types must specify the collection 
-in the `Publisher`.  For `Reactor` types, this limits the use of `Flux` as a response type.  If you
-want to use `Flux`, you will need to manually convert the `Mono` or `Iterable` response types into
-`Flux` using the `fromIterable` method.
-
+in the `Publisher`.  For `Reactor` types, this limits the use of `Flux` as a response type.
 
-```java
-public interface GitHub {
-
-  @RequestLine("GET /repos/{owner}/{repo}/contributors")
-  Mono<List<Contributor>> contributors(@Param("owner") String owner, @Param("repo") String repo);
-
-  class Contributor {
-    String login;
-
-    public Contributor(String login) {
-      this.login = login;
-    }
-  }
-}
-
-public class ExampleApplication {
-  public static void main(String[] args) {
-    GitHub gitHub = ReactorFeign.builder()
-      .target(GitHub.class, "https://api.github.com");
-
-    Mono<List<Contributor>> contributors = gitHub.contributors("OpenFeign", "feign");
-    Flux<Contributor> contributorFlux = Flux.fromIterable(contributors.block());
-  }
-}
-```

reactive/src/main/java/feign/reactive/ReactiveDecoder.java

@@ -0,0 +1,50 @@
+/*
+ * Copyright 2012-2023 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.reactive;
+
+import feign.FeignException;
+import feign.Response;
+import feign.Types;
+import feign.codec.Decoder;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
+import java.io.IOException;
+import java.lang.reflect.Type;
+import java.util.List;
+
+public class ReactiveDecoder implements Decoder {
+
+    private final Decoder delegate;
+
+    public ReactiveDecoder(Decoder decoder) {
+        this.delegate = decoder;
+    }
+
+    @Override
+    public Object decode(Response response, Type type) throws IOException, FeignException {
+        Class<?> rawType = Types.getRawType(type);
+        if (rawType.isAssignableFrom(Mono.class)) {
+            Type lastType = Types.resolveLastTypeParameter(type, Mono.class);
+            return Mono.just(delegate.decode(response, lastType));
+        }
+        if (rawType.isAssignableFrom(Flux.class)) {
+            Type lastType = Types.resolveLastTypeParameter(type, Flux.class);
+            Type listType = Types.parameterize(List.class, lastType);
+            return Flux.fromIterable((Iterable)delegate.decode(response, listType));
+        }
+
+        return delegate.decode(response, type);
+    }
+}