Skip to content

Commit 07a41b0

Browse files
kdavisk6velo
kdavisk6
authored and
velo
committed
Reactive Wrapper Support (OpenFeign#795)
Adding support for Reactive Streams `Publisher` return types. Support is provided through the `ReactiveInvocationHandler` and follows a similar pattern used by `feign-hystrix`. Each method invocation is wrapped in a `Callable`, which is then wrapped into the appropriate Reactive Streams `Publisher`, as defined in the builder and the return type of the method. This approach is not "reactive all the way down". The requests are still executed via a regular `Client` and are synchronous. However, it is possible to still take advantage of the backpressure, scheduling, and functional support provided by the library implementations. Limitations: Streams are not supported and Iterable responses are not treated reactively. Iterables must be explicitly cast into a reactive type. Reworked Builders and removed the need for the enumerator
1 parent dec9991 commit 07a41b0

14 files changed

Lines changed: 1209 additions & 2 deletions

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

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -30,15 +30,15 @@
3030
* @author Bob Lee
3131
* @author Jesse Wilson
3232
*/
33-
final class Types {
33+
public final class Types {
3434

3535
private static final Type[] EMPTY_TYPE_ARRAY = new Type[0];
3636

3737
private Types() {
3838
// No instances.
3939
}
4040

41-
static Class<?> getRawType(Type type) {
41+
public static Class<?> getRawType(Type type) {
4242
if (type instanceof Class<?>) {
4343
// Type is a normal class.
4444
return (Class<?>) type;

‎pom.xml‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -36,6 +36,7 @@
3636
<module>ribbon</module>
3737
<module>sax</module>
3838
<module>slf4j</module>
39+
<module>reactive</module>
3940
<module>example-github</module>
4041
<module>example-wikipedia</module>
4142
<!-- remove after feign 10.0 release -->

‎reactive/README.md‎

Lines changed: 113 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,113 @@
1+
Reactive Streams Wrapper
2+
---
3+
4+
This module wraps Feign's http requests in a [Reactive Streams](https://reactive-streams.org)
5+
Publisher, enabling the use of Reactive Stream `Publisher` return types. Supported Reactive Streams implementations are:
6+
7+
* [Reactor](https://project-reactor.org) (`Mono` and `Flux`)
8+
* [ReactiveX (RxJava)](https://reactivex.io) (`Flowable` only)
9+
10+
To use these wrappers, add the `feign-reactive-wrappers` module, and your desired `reactive-streams`
11+
implementation to your classpath. Then configure Feign to use the reactive streams wrappers.
12+
13+
```java
14+
public interface GitHubReactor {
15+
16+
@RequestLine("GET /repos/{owner}/{repo}/contributors")
17+
Flux<Contributor> contributors(@Param("owner") String owner, @Param("repo") String repo);
18+
19+
class Contributor {
20+
String login;
21+
22+
public Contributor(String login) {
23+
this.login = login;
24+
}
25+
}
26+
}
27+
28+
public class ExampleReactor {
29+
public static void main(String args[]) {
30+
GitHubReactor gitHub = ReactorFeign.builder()
31+
.target(GitHubReactor.class, "https://api.github.com");
32+
33+
List<Contributor> contributors = gitHub.contributors("OpenFeign", "feign")
34+
.map(Contributor::new)
35+
.collect(Collectors.toList())
36+
.block();
37+
}
38+
}
39+
40+
public interface GitHubReactiveX {
41+
42+
@RequestLine("GET /repos/{owner}/{repo}/contributors")
43+
Flowable<Contributor> contributors(@Param("owner") String owner, @Param("repo") String repo);
44+
45+
class Contributor {
46+
String login;
47+
48+
public Contributor(String login) {
49+
this.login = login;
50+
}
51+
}
52+
}
53+
54+
public class ExampleRxJava2 {
55+
public static void main(String args[]) {
56+
GitHubReactiveX gitHub = RxJavaFeign.builder()
57+
.target(GitHub.class, "https://api.github.com");
58+
59+
List<Contributor> contributors = gitHub.contributors("OpenFeign", "feign")
60+
.map(Contributor::new)
61+
.collect(Collectors.toList())
62+
.block();
63+
}
64+
}
65+
66+
```
67+
68+
Considerations
69+
---
70+
71+
These wrappers are not *reactive all the way down*, given that Feign generated requests are
72+
synchronous. Requests still block, but execution is controlled by the `Publisher` and their
73+
related `Scheduler`. While this may not be ideal in terms of a fully reactive application, providing these
74+
wrappers provide an intermediate upgrade path for Feign.
75+
76+
### Streaming
77+
78+
Methods that return `java.util.streams` Types are not supported. Responses are read fully,
79+
the wrapped in the appropriate reactive wrappers.
80+
81+
### Iterable and Collections responses
82+
83+
Due to the Synchronous nature of Feign requests, methods that return `Iterable` types must specify the collection
84+
in the `Publisher`. For `Reactor` types, this limits the use of `Flux` as a response type. If you
85+
want to use `Flux`, you will need to manually convert the `Mono` or `Iterable` response types into
86+
`Flux` using the `fromIterable` method.
87+
88+
89+
```java
90+
public interface GitHub {
91+
92+
@RequestLine("GET /repos/{owner}/{repo}/contributors")
93+
Mono<List<Contributor>> contributors(@Param("owner") String owner, @Param("repo") String repo);
94+
95+
class Contributor {
96+
String login;
97+
98+
public Contributor(String login) {
99+
this.login = login;
100+
}
101+
}
102+
}
103+
104+
public class ExampleApplication {
105+
public static void main(String[] args) {
106+
GitHub gitHub = ReactorFeign.builder()
107+
.target(GitHub.class, "https://api.github.com");
108+
109+
Mono<List<Contributor>> contributors = gitHub.contributors("OpenFeign", "feign");
110+
Flux<Contributor> contributorFlux = Flux.fromIterable(contributors.block());
111+
}
112+
}
113+
```

‎reactive/pom.xml‎

Lines changed: 95 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,95 @@
1+
<?xml version="1.0" encoding="UTF-8"?>
2+
<!--
3+
4+
Copyright 2012-2018 The Feign Authors
5+
6+
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
7+
in compliance with the License. You may obtain a copy of the License at
8+
9+
http://www.apache.org/licenses/LICENSE-2.0
10+
11+
Unless required by applicable law or agreed to in writing, software distributed under the License
12+
is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
13+
or implied. See the License for the specific language governing permissions and limitations under
14+
the License.
15+
16+
-->
17+
<project xmlns="http://maven.apache.org/POM/4.0.0"
18+
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
19+
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
20+
<parent>
21+
<groupId>io.github.openfeign</groupId>
22+
<artifactId>parent</artifactId>
23+
<version>10.0.2-SNAPSHOT</version>
24+
</parent>
25+
<modelVersion>4.0.0</modelVersion>
26+
27+
<name>Feign Reactive Wrappers</name>
28+
<artifactId>feign-reactive-wrappers</artifactId>
29+
<description>Reactive Wrapper for Feign Clients</description>
30+
31+
<properties>
32+
<main.basedir>${project.basedir}/..</main.basedir>
33+
<reactor.version>3.1.8.RELEASE</reactor.version>
34+
<reactive.streams.version>1.0.2</reactive.streams.version>
35+
<reactivex.version>2.2.2</reactivex.version>
36+
<mockito.version>1.9.5</mockito.version>
37+
</properties>
38+
39+
<dependencies>
40+
<dependency>
41+
<groupId>io.github.openfeign</groupId>
42+
<artifactId>feign-core</artifactId>
43+
<version>${project.version}</version>
44+
</dependency>
45+
<dependency>
46+
<groupId>org.reactivestreams</groupId>
47+
<artifactId>reactive-streams</artifactId>
48+
<version>${reactive.streams.version}</version>
49+
</dependency>
50+
<dependency>
51+
<groupId>io.projectreactor</groupId>
52+
<artifactId>reactor-core</artifactId>
53+
<version>${reactor.version}</version>
54+
<scope>provided</scope>
55+
<optional>true</optional>
56+
</dependency>
57+
<dependency>
58+
<groupId>io.reactivex.rxjava2</groupId>
59+
<artifactId>rxjava</artifactId>
60+
<version>${reactivex.version}</version>
61+
<scope>provided</scope>
62+
<optional>true</optional>
63+
</dependency>
64+
<dependency>
65+
<groupId>org.mockito</groupId>
66+
<artifactId>mockito-all</artifactId>
67+
<version>${mockito.version}</version>
68+
<scope>test</scope>
69+
</dependency>
70+
<dependency>
71+
<groupId>io.github.openfeign</groupId>
72+
<artifactId>feign-jackson</artifactId>
73+
<version>${project.version}</version>
74+
<scope>test</scope>
75+
</dependency>
76+
<dependency>
77+
<groupId>io.github.openfeign</groupId>
78+
<artifactId>feign-okhttp</artifactId>
79+
<version>${project.version}</version>
80+
<scope>test</scope>
81+
</dependency>
82+
<dependency>
83+
<groupId>io.github.openfeign</groupId>
84+
<artifactId>feign-jaxrs</artifactId>
85+
<version>${project.version}</version>
86+
<scope>test</scope>
87+
</dependency>
88+
<dependency>
89+
<groupId>com.squareup.okhttp3</groupId>
90+
<artifactId>mockwebserver</artifactId>
91+
<scope>test</scope>
92+
</dependency>
93+
</dependencies>
94+
95+
</project>

‎reactive/src/main/java/feign/reactive/ReactiveDelegatingContract.java‎

Lines changed: 81 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,81 @@
1+
/**
2+
* Copyright 2012-2018 The Feign Authors
3+
*
4+
* Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
5+
* in compliance with the License. You may obtain a copy of the License at
6+
*
7+
* http://www.apache.org/licenses/LICENSE-2.0
8+
*
9+
* Unless required by applicable law or agreed to in writing, software distributed under the License
10+
* is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
11+
* or implied. See the License for the specific language governing permissions and limitations under
12+
* the License.
13+
*/
14+
package feign.reactive;
15+
16+
import feign.Contract;
17+
import feign.MethodMetadata;
18+
import feign.Types;
19+
import java.lang.reflect.ParameterizedType;
20+
import java.lang.reflect.Type;
21+
import java.util.Arrays;
22+
import java.util.List;
23+
import java.util.stream.Stream;
24+
import org.reactivestreams.Publisher;
25+
26+
public class ReactiveDelegatingContract implements Contract {
27+
28+
private final Contract delegate;
29+
30+
ReactiveDelegatingContract(Contract delegate) {
31+
this.delegate = delegate;
32+
}
33+
34+
@Override
35+
public List<MethodMetadata> parseAndValidatateMetadata(Class<?> targetType) {
36+
List<MethodMetadata> methodsMetadata = this.delegate.parseAndValidatateMetadata(targetType);
37+
38+
for (final MethodMetadata metadata : methodsMetadata) {
39+
final Type type = metadata.returnType();
40+
if (!isReactive(type)) {
41+
throw new IllegalArgumentException(String.format(
42+
"Method %s of contract %s doesn't returns a org.reactivestreams.Publisher",
43+
metadata.configKey(), targetType.getSimpleName()));
44+
}
45+
46+
/*
47+
* we will need to change the return type of the method to match the return type contained
48+
* within the Publisher
49+
*/
50+
Type[] actualTypes = ((ParameterizedType) type).getActualTypeArguments();
51+
if (actualTypes.length > 1) {
52+
throw new IllegalStateException("Expected only one contained type.");
53+
} else {
54+
Class<?> actual = Types.getRawType(actualTypes[0]);
55+
if (Stream.class.isAssignableFrom(actual)) {
56+
throw new IllegalArgumentException(
57+
"Streams are not supported when using Reactive Wrappers");
58+
}
59+
metadata.returnType(actualTypes[0]);
60+
}
61+
}
62+
63+
return methodsMetadata;
64+
}
65+
66+
/**
67+
* Ensure that the type provided implements a Reactive Streams Publisher.
68+
*
69+
* @param type to inspect.
70+
* @return true if the type implements the Reactive Streams Publisher specification.
71+
*/
72+
private boolean isReactive(Type type) {
73+
if (!ParameterizedType.class.isAssignableFrom(type.getClass())) {
74+
return false;
75+
}
76+
ParameterizedType parameterizedType = (ParameterizedType) type;
77+
Type raw = parameterizedType.getRawType();
78+
return Arrays.asList(((Class) raw).getInterfaces())
79+
.contains(Publisher.class);
80+
}
81+
}

‎reactive/src/main/java/feign/reactive/ReactiveFeign.java‎

Lines changed: 61 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,61 @@
1+
/**
2+
* Copyright 2012-2018 The Feign Authors
3+
*
4+
* Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
5+
* in compliance with the License. You may obtain a copy of the License at
6+
*
7+
* http://www.apache.org/licenses/LICENSE-2.0
8+
*
9+
* Unless required by applicable law or agreed to in writing, software distributed under the License
10+
* is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
11+
* or implied. See the License for the specific language governing permissions and limitations under
12+
* the License.
13+
*/
14+
15+
package feign.reactive;
16+
17+
import feign.Contract;
18+
import feign.Feign;
19+
import feign.InvocationHandlerFactory;
20+
21+
abstract class ReactiveFeign {
22+
23+
24+
25+
public static class Builder extends Feign.Builder {
26+
27+
private Contract contract = new Contract.Default();
28+
29+
/**
30+
* Extend the current contract to support Reactive Stream return types.
31+
*
32+
* @param contract to extend.
33+
* @return a Builder for chaining.
34+
*/
35+
@Override
36+
public Builder contract(Contract contract) {
37+
this.contract = contract;
38+
return this;
39+
}
40+
41+
/**
42+
* Build the Feign instance.
43+
*
44+
* @return a new Feign Instance.
45+
*/
46+
@Override
47+
public Feign build() {
48+
if (!(this.contract instanceof ReactiveDelegatingContract)) {
49+
super.contract(new ReactiveDelegatingContract(this.contract));
50+
} else {
51+
super.contract(this.contract);
52+
}
53+
return super.build();
54+
}
55+
56+
@Override
57+
public Feign.Builder doNotCloseAfterDecode() {
58+
throw new UnsupportedOperationException("Streaming Decoding is not supported.");
59+
}
60+
}
61+
}

0 commit comments

Comments
 (0)