Removes Dagger 1.x Dependency and support for javax.inject.Named

Dagger 1.x and 2.x are incompatible. Rather than choose one over the
other, this change removes Dagger completely. Users can now choose any
injector, constructing Feign via its Builder.

This change also drops support for javax.inject.Named, which has
been replaced by feign.Param.

see #120

Author: Adrian Cole

CHANGELOG.md

@@ -1,3 +1,7 @@
+### Version 8.0
+* Removes Dagger 1.x Dependency
+* Removes support for parameters annotated with `javax.inject.@Named`. Use `feign.@Param` instead.
+
 ### Version 7.1
 * Introduces feign.@Param to annotate template parameters. Users must migrate from `javax.inject.@Named` to `feign.@Param` before updating to Feign 8.0.
   * Supports custom expansion via `@Param(value = "name", expander = CustomExpander.class)`

README.md

@@ -50,35 +50,14 @@ interface Bank {
 Bank bank = Feign.builder().decoder(new AccountDecoder()).target(Bank.class, "https://api.examplebank.com");
 ```
 
-For further flexibility, you can use Dagger modules directly.  See the `Dagger` section for more details.
-
-### Request Interceptors
-When you need to change all requests, regardless of their target, you'll want to configure a `RequestInterceptor`.
-For example, if you are acting as an intermediary, you might want to propagate the `X-Forwarded-For` header.
-
-```java
-static class ForwardedForInterceptor implements RequestInterceptor {
-  @Override public void apply(RequestTemplate template) {
-    template.header("X-Forwarded-For", "origin.host.com");
-  }
-}
-...
-Bank bank = Feign.builder().decoder(accountDecoder).requestInterceptor(new ForwardedForInterceptor()).target(Bank.class, "https://api.examplebank.com");
-```
-
-Another common example of an interceptor would be authentication, such as using the built-in `BasicAuthRequestInterceptor`.
-
-```java
-Bank bank = Feign.builder().decoder(accountDecoder).requestInterceptor(new BasicAuthRequestInterceptor(username, password)).target(Bank.class, "https://api.examplebank.com");
-```
-
 ### Multiple Interfaces
 Feign can produce multiple api interfaces.  These are defined as `Target<T>` (default `HardCodedTarget<T>`), which allow for dynamic discovery and decoration of requests prior to execution.
 
 For example, the following pattern might decorate each request with the current url and auth token from the identity service.
 
 ```java
-CloudDNS cloudDNS = Feign.builder().target(new CloudIdentityTarget<CloudDNS>(user, apiKey));
+Feign feign = Feign.builder().build();
+CloudDNS cloudDNS = feign.target(new CloudIdentityTarget<CloudDNS>(user, apiKey));
 ```
 
 You can find [several examples](https://github.com/Netflix/feign/tree/master/core/src/test/java/feign/examples) in the test tree.  Do take time to look at them, as seeing is believing!
@@ -87,7 +66,7 @@ You can find [several examples](https://github.com/Netflix/feign/tree/master/cor
 Feign intends to work well within Netflix and other Open Source communities.  Modules are welcome to integrate with your favorite projects!
 
 ### Gson
-[GsonModule](https://github.com/Netflix/feign/tree/master/gson) adds default encoders and decoders so you get get started with a JSON api.
+[Gson](https://github.com/Netflix/feign/tree/master/gson) includes an encoder and decoder you can use with a JSON API.
 
 Add `GsonEncoder` and/or `GsonDecoder` to your `Feign.Builder` like so:
 
@@ -100,7 +79,7 @@ GitHub github = Feign.builder()
 ```
 
 ### Jackson
-[JacksonModule](https://github.com/Netflix/feign/tree/master/jackson) adds an encoder and decoder you can use with a JSON API.
+[Jackson](https://github.com/Netflix/feign/tree/master/jackson) includes an encoder and decoder you can use with a JSON API.
 
 Add `JacksonEncoder` and/or `JacksonDecoder` to your `Feign.Builder` like so:
 
@@ -124,7 +103,7 @@ api = Feign.builder()
 ```
 
 ### JAXB
-[JAXBModule](https://github.com/Netflix/feign/tree/master/jaxb) allows you to encode and decode XML using JAXB.
+[JAXB](https://github.com/Netflix/feign/tree/master/jaxb) includes an encoder and decoder you can use with an XML API.
 
 Add `JAXBEncoder` and/or `JAXBDecoder` to your `Feign.Builder` like so:
 
@@ -136,7 +115,7 @@ api = Feign.builder()
 ```
 
 ### JAX-RS
-[JAXRSModule](https://github.com/Netflix/feign/tree/master/jaxrs) overrides annotation processing to instead use standard ones supplied by the JAX-RS specification.  This is currently targeted at the 1.1 spec.
+[JAXRSContract](https://github.com/Netflix/feign/tree/master/jaxrs) overrides annotation processing to instead use standard ones supplied by the JAX-RS specification.  This is currently targeted at the 1.1 spec.
 
 Here's the example above re-written to use JAX-RS:
 ```java
@@ -147,7 +126,7 @@ interface GitHub {
 ```
 ```java
 GitHub github = Feign.builder()
-                     .contract(new JAXRSModule.JAXRSContract())
+                     .contract(new JAXRSContract())
                      .target(GitHub.class, "https://api.github.com");           
 ```
 ### OkHttp
@@ -162,11 +141,12 @@ GitHub github = Feign.builder()
 ```
 
 ### Ribbon
-[RibbonModule](https://github.com/Netflix/feign/tree/master/ribbon) overrides URL resolution of Feign's client, adding smart routing and resiliency capabilities provided by [Ribbon](https://github.com/Netflix/ribbon).
+[RibbonClient](https://github.com/Netflix/feign/tree/master/ribbon) overrides URL resolution of Feign's client, adding smart routing and resiliency capabilities provided by [Ribbon](https://github.com/Netflix/ribbon).
 
 Integration requires you to pass your ribbon client name as the host part of the url, for example `myAppProd`.
 ```java
-MyService api = Feign.create(MyService.class, "https://myAppProd", new RibbonModule());
+MyService api = Feign.builder().client(new RibbonClient()).target(MyService.class, "https://myAppProd");
+
 ```
 
 ### SLF4J
@@ -206,27 +186,45 @@ GitHub github = Feign.builder()
                      .target(GitHub.class, "https://api.github.com");
 ```
 
-### Advanced usage and Dagger
-#### Dagger
-Feign can be directly wired into Dagger which keeps things at compile time and Android friendly.  As opposed to exposing builders for config, Feign intends users to embed their config in Dagger.
+### Advanced usage
 
-Where possible, Feign configuration uses normal Dagger conventions.  For example, `RequestInterceptor` bindings are of `Provider.Type.SET`, meaning you can have multiple interceptors.  Here's an example of multiple interceptor bindings.
+#### Logging
+You can log the http messages going to and from the target by setting up a `Logger`.  Here's the easiest way to do that:
 ```java
-@Provides(type = SET) RequestInterceptor forwardedForInterceptor() {
-  return new RequestInterceptor() {
-    @Override public void apply(RequestTemplate template) {
-      template.header("X-Forwarded-For", "origin.host.com");
-    }
-  };
-}
+GitHub github = Feign.builder()
+                     .decoder(new GsonDecoder())
+                     .logger(new Logger.JavaLogger().appendToFile("logs/http.log"))
+                     .logLevel(Logger.Level.FULL)
+                     .target(GitHub.class, "https://api.github.com");
+```
 
-@Provides(type = SET) RequestInterceptor userAgentInterceptor() {
-  return new RequestInterceptor() {
-    @Override public void apply(RequestTemplate template) {
-      template.header("User-Agent", "My Cool Client");
-    }
-  };
+The SLF4JLogger (see above) may also be of interest.
+
+
+#### Request Interceptors
+When you need to change all requests, regardless of their target, you'll want to configure a `RequestInterceptor`.
+For example, if you are acting as an intermediary, you might want to propagate the `X-Forwarded-For` header.
+
+```java
+static class ForwardedForInterceptor implements RequestInterceptor {
+  @Override public void apply(RequestTemplate template) {
+    template.header("X-Forwarded-For", "origin.host.com");
+  }
 }
+...
+Bank bank = Feign.builder()
+                 .decoder(accountDecoder)
+                 .requestInterceptor(new ForwardedForInterceptor())
+                 .target(Bank.class, "https://api.examplebank.com");
+```
+
+Another common example of an interceptor would be authentication, such as using the built-in `BasicAuthRequestInterceptor`.
+
+```java
+Bank bank = Feign.builder()
+                 .decoder(accountDecoder)
+                 .requestInterceptor(new BasicAuthRequestInterceptor(username, password))
+                 .target(Bank.class, "https://api.examplebank.com");
 ```
 
 #### Custom Parameter Expansion
@@ -237,15 +235,3 @@ for example formatting dates.
 ```java
 @RequestLine("GET /?since={date}") Result list(@Param(value = "date", expander = DateToMillis.class) Date date);
 ```
-
-#### Logging
-You can log the http messages going to and from the target by setting up a `Logger`.  Here's the easiest way to do that:
-```java
-GitHub github = Feign.builder()
-                     .decoder(new GsonDecoder())
-                     .logger(new Logger.JavaLogger().appendToFile("logs/http.log"))
-                     .logLevel(Logger.Level.FULL)
-                     .target(GitHub.class, "https://api.github.com");
-```
-
-The SLF4JModule (see above) may also be of interest.

build.gradle

@@ -12,6 +12,5 @@ subprojects {
     repositories { 
         jcenter()
     }
-    apply from: rootProject.file('dagger.gradle')
     group = "com.netflix.${githubProjectName}" // TEMPLATE: Set to organization of project
 }

core/build.gradle

@@ -3,9 +3,8 @@ apply plugin: 'java'
 sourceCompatibility = 1.6
 
 dependencies {
-    testCompile 'com.google.code.gson:gson:2.2.4'
-    testCompile 'com.fasterxml.jackson.core:jackson-databind:2.2.2'
     testCompile 'junit:junit:4.12'
     testCompile 'org.assertj:assertj-core:1.7.1'
     testCompile 'com.squareup.okhttp:mockwebserver:2.2.0'
+    testCompile 'com.google.code.gson:gson:2.2.4' // for example
 }

core/src/main/java/feign/Client.java

@@ -19,7 +19,6 @@
 import static feign.Util.CONTENT_LENGTH;
 import static feign.Util.ENCODING_GZIP;
 
-import dagger.Lazy;
 import feign.Request.Options;
 import java.io.IOException;
 import java.io.InputStream;
@@ -31,7 +30,6 @@
 import java.util.List;
 import java.util.Map;
 import java.util.zip.GZIPOutputStream;
-import javax.inject.Inject;
 import javax.net.ssl.HostnameVerifier;
 import javax.net.ssl.HttpsURLConnection;
 import javax.net.ssl.SSLSocketFactory;
@@ -49,12 +47,11 @@ public interface Client {
   Response execute(Request request, Options options) throws IOException;
 
   public static class Default implements Client {
-    private final Lazy<SSLSocketFactory> sslContextFactory;
-    private final Lazy<HostnameVerifier> hostnameVerifier;
+    private final SSLSocketFactory sslContextFactory;
+    private final HostnameVerifier hostnameVerifier;
 
-    @Inject
-    public Default(
-        Lazy<SSLSocketFactory> sslContextFactory, Lazy<HostnameVerifier> hostnameVerifier) {
+    /** Null parameters imply platform defaults. */
+    public Default(SSLSocketFactory sslContextFactory, HostnameVerifier hostnameVerifier) {
       this.sslContextFactory = sslContextFactory;
       this.hostnameVerifier = hostnameVerifier;
     }
@@ -70,8 +67,12 @@ HttpURLConnection convertAndSend(Request request, Options options) throws IOExce
           (HttpURLConnection) new URL(request.url()).openConnection();
       if (connection instanceof HttpsURLConnection) {
         HttpsURLConnection sslCon = (HttpsURLConnection) connection;
-        sslCon.setSSLSocketFactory(sslContextFactory.get());
-        sslCon.setHostnameVerifier(hostnameVerifier.get());
+        if (sslContextFactory != null) {
+          sslCon.setSSLSocketFactory(sslContextFactory);
+        }
+        if (hostnameVerifier != null) {
+          sslCon.setHostnameVerifier(hostnameVerifier);
+        }
       }
       connection.setConnectTimeout(options.connectTimeoutMillis());
       connection.setReadTimeout(options.readTimeoutMillis());

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

@@ -26,7 +26,6 @@
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
-import javax.inject.Named;
 
 /** Defines what annotations and values are valid on interfaces. */
 public interface Contract {
@@ -177,16 +176,10 @@ protected boolean processAnnotationsOnParameter(
       boolean isHttpAnnotation = false;
       for (Annotation annotation : annotations) {
         Class<? extends Annotation> annotationType = annotation.annotationType();
-        if (annotationType == Param.class || annotationType == Named.class) {
-          String name =
-              annotationType == Param.class
-                  ? ((Param) annotation).value()
-                  : ((Named) annotation).value();
+        if (annotationType == Param.class) {
+          String name = ((Param) annotation).value();
           checkState(
-              emptyToNull(name) != null,
-              "%s annotation was empty on param %s.",
-              annotationType.getSimpleName(),
-              paramIndex);
+              emptyToNull(name) != null, "Param annotation was empty on param %s.", paramIndex);
           nameParam(data, name, paramIndex);
           if (annotationType == Param.class) {
             Class<? extends Param.Expander> expander = ((Param) annotation).expander();