SpringCloud Feign

Feign是受到Retrofit，JAXRS-2.0和WebSocket的影響，它是一個java到http客戶端綁定的開源項目。 Feign的主要目標是將Java Http 客戶端變得簡單。Feign的源碼地址：https://github.com/OpenFeign/feign

寫一個Feign 簡單的實現一個Feign客戶端，首先經過@FeignClient，客戶端，其中value爲調用其餘服務的名稱，FeignConfig.class爲FeignClient的配置文件，代碼以下：

@FeignClient(value = "service-hi",configuration = FeignConfig.class)
public interface SchedualServiceHi {
    @GetMapping(value = "/hi")
    String sayHiFromClientOne(@RequestParam(value = "name") String name);
}

其自定義配置文件以下，固然也能夠不寫配置文件，用默認的便可：

@Configuration
public class FeignConfig {

    @Bean
    public Retryer feignRetryer() {
        return new Retryer.Default(100, SECONDS.toMillis(1), 5);
    }

}

查看FeignClient註解的源碼，其代碼以下：

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface FeignClient {

@AliasFor("name")
String value() default "";

@AliasFor("value")
String name() default "";

@AliasFor("value")
String name() default "";
String url() default "";
boolean decode404() default false;

Class<?>[] configuration() default {};
Class<?> fallback() default void.class;

Class<?> fallbackFactory() default void.class;
}

String path() default "";

boolean primary() default true;

FeignClient註解被@Target(ElementType.TYPE)修飾，表示FeignClient註解的做用目標在接口上； @Retention(RetentionPolicy.RUNTIME)，註解會在class字節碼文件中存在，在運行時能夠經過反射獲取到；@Documented表示該註解將被包含在javadoc中。

feign 用於聲明具備該接口的REST客戶端的接口的註釋應該是建立（例如用於自動鏈接到另外一個組件。 若是功能區可用，那將是 用於負載平衡後端請求，而且能夠配置負載平衡器 使用與假裝客戶端相同名稱（即值）@RibbonClient 。

其中value()和name()同樣，是被調用的 service的名稱。 url(),直接填寫硬編碼的url,decode404()即404是否被解碼，仍是拋異常；configuration()，標明FeignClient的配置類，默認的配置類爲FeignClientsConfiguration類，能夠覆蓋Decoder、Encoder和Contract等信息，進行自定義配置。fallback(),填寫熔斷器的信息類。

FeignClient的配置 默認的配置類爲FeignClientsConfiguration，這個類在spring-cloud-netflix-core的jar包下，打開這個類，能夠發現它是一個配置類，注入了不少的相關配置的bean，包括feignRetryer、FeignLoggerFactory、FormattingConversionService等,其中還包括了Decoder、Encoder、Contract，若是這三個bean在沒有注入的狀況下，會自動注入默認的配置。

Decoder feignDecoder: ResponseEntityDecoder(這是對SpringDecoder的封裝) Encoder feignEncoder: SpringEncoder Logger feignLogger: Slf4jLogger Contract feignContract: SpringMvcContract Feign.Builder feignBuilder: HystrixFeign.Builder

@Configuration
public class FeignClientsConfiguration {

...//省略代碼

@Bean
    @ConditionalOnMissingBean
    public Decoder feignDecoder() {
        return new ResponseEntityDecoder(new SpringDecoder(this.messageConverters));
    }

    @Bean
    @ConditionalOnMissingBean
    public Encoder feignEncoder() {
        return new SpringEncoder(this.messageConverters);
    }

    @Bean
    @ConditionalOnMissingBean
    public Contract feignContract(ConversionService feignConversionService) {
        return new SpringMvcContract(this.parameterProcessors, feignConversionService);
    }

...//省略代碼
}

重寫配置： 你能夠重寫FeignClientsConfiguration中的bean，從而達到自定義配置的目的，好比FeignClientsConfiguration的默認重試次數爲Retryer.NEVER_RETRY，即不重試，那麼但願作到重寫，寫個配置文件，注入feignRetryer的bean,代碼以下：

@Configuration
public class FeignConfig {

    @Bean
    public Retryer feignRetryer() {
        return new Retryer.Default(100, SECONDS.toMillis(1), 5);
    }

}

在上述代碼更改了該FeignClient的重試次數，重試間隔爲100ms，最大重試時間爲1s,重試次數爲5次。

Feign的工做原理

feign是一個僞客戶端，即它不作任何的請求處理。Feign經過處理註解生成request，從而實現簡化HTTP API開發的目的，即開發人員可使用註解的方式定製request api模板，在發送http request請求以前，feign經過處理註解的方式替換掉request模板中的參數，這種實現方式顯得更爲直接、可理解。

經過包掃描注入FeignClient的bean，該源碼在FeignClientsRegistrar類： 首先在啓動配置上檢查是否有@EnableFeignClients註解，若是有該註解，則開啓包掃描，掃描被@FeignClient註解接口。代碼以下：

private void registerDefaultConfiguration(AnnotationMetadata metadata,
            BeanDefinitionRegistry registry) {
        Map<String, Object> defaultAttrs = metadata
                .getAnnotationAttributes(EnableFeignClients.class.getName(), true);

        if (defaultAttrs != null && defaultAttrs.containsKey("defaultConfiguration")) {
            String name;
            if (metadata.hasEnclosingClass()) {
                name = "default." + metadata.getEnclosingClassName();
            }
            else {
                name = "default." + metadata.getClassName();
            }
            registerClientConfiguration(registry, name,
                    defaultAttrs.get("defaultConfiguration"));
        }
    }

程序啓動後經過包掃描，當類有@FeignClient註解，將註解的信息取出，連同類名一塊兒取出，賦給BeanDefinitionBuilder，而後根據BeanDefinitionBuilder獲得beanDefinition，最後beanDefinition式注入到ioc容器中，源碼以下：

public void registerFeignClients(AnnotationMetadata metadata,
            BeanDefinitionRegistry registry) {
        ClassPathScanningCandidateComponentProvider scanner = getScanner();
        scanner.setResourceLoader(this.resourceLoader);

        Set<String> basePackages;

        Map<String, Object> attrs = metadata
                .getAnnotationAttributes(EnableFeignClients.class.getName());
        AnnotationTypeFilter annotationTypeFilter = new AnnotationTypeFilter(
                FeignClient.class);
        final Class<?>[] clients = attrs == null ? null
                : (Class<?>[]) attrs.get("clients");
        if (clients == null || clients.length == 0) {
            scanner.addIncludeFilter(annotationTypeFilter);
            basePackages = getBasePackages(metadata);
        }
        else {
            final Set<String> clientClasses = new HashSet<>();
            basePackages = new HashSet<>();
            for (Class<?> clazz : clients) {
                basePackages.add(ClassUtils.getPackageName(clazz));
                clientClasses.add(clazz.getCanonicalName());
            }
            AbstractClassTestingTypeFilter filter = new AbstractClassTestingTypeFilter() {
                @Override
                protected boolean match(ClassMetadata metadata) {
                    String cleaned = metadata.getClassName().replaceAll("\\$", ".");
                    return clientClasses.contains(cleaned);
                }
            };
            scanner.addIncludeFilter(
                    new AllTypeFilter(Arrays.asList(filter, annotationTypeFilter)));
        }

        for (String basePackage : basePackages) {
            Set<BeanDefinition> candidateComponents = scanner
                    .findCandidateComponents(basePackage);
            for (BeanDefinition candidateComponent : candidateComponents) {
                if (candidateComponent instanceof AnnotatedBeanDefinition) {
                    // verify annotated class is an interface
                    AnnotatedBeanDefinition beanDefinition = (AnnotatedBeanDefinition) candidateComponent;
                    AnnotationMetadata annotationMetadata = beanDefinition.getMetadata();
                    Assert.isTrue(annotationMetadata.isInterface(),
                            "@FeignClient can only be specified on an interface");

                    Map<String, Object> attributes = annotationMetadata
                            .getAnnotationAttributes(
                                    FeignClient.class.getCanonicalName());

                    String name = getClientName(attributes);
                    registerClientConfiguration(registry, name,
                            attributes.get("configuration"));

                    registerFeignClient(registry, annotationMetadata, attributes);
                }
            }
        }
    }


private void registerFeignClient(BeanDefinitionRegistry registry,
            AnnotationMetadata annotationMetadata, Map<String, Object> attributes) {
        String className = annotationMetadata.getClassName();
        BeanDefinitionBuilder definition = BeanDefinitionBuilder
                .genericBeanDefinition(FeignClientFactoryBean.class);
        validate(attributes);
        definition.addPropertyValue("url", getUrl(attributes));
        definition.addPropertyValue("path", getPath(attributes));
        String name = getName(attributes);
        definition.addPropertyValue("name", name);
        definition.addPropertyValue("type", className);
        definition.addPropertyValue("decode404", attributes.get("decode404"));
        definition.addPropertyValue("fallback", attributes.get("fallback"));
        definition.addPropertyValue("fallbackFactory", attributes.get("fallbackFactory"));
        definition.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE);

        String alias = name + "FeignClient";
        AbstractBeanDefinition beanDefinition = definition.getBeanDefinition();

        boolean primary = (Boolean)attributes.get("primary"); // has a default, won't be null

        beanDefinition.setPrimary(primary);

        String qualifier = getQualifier(attributes);
        if (StringUtils.hasText(qualifier)) {
            alias = qualifier;
        }

        BeanDefinitionHolder holder = new BeanDefinitionHolder(beanDefinition, className,
                new String[] { alias });
        BeanDefinitionReaderUtils.registerBeanDefinition(holder, registry);
    }

注入bean以後，經過jdk的代理，當請求Feign Client的方法時會被攔截，代碼在ReflectiveFeign類，代碼以下：

public <T> T newInstance(Target<T> target) {
    Map<String, MethodHandler> nameToHandler = targetToHandlersByName.apply(target);
    Map<Method, MethodHandler> methodToHandler = new LinkedHashMap<Method, MethodHandler>();
    List<DefaultMethodHandler> defaultMethodHandlers = new LinkedList<DefaultMethodHandler>();

    for (Method method : target.type().getMethods()) {
      if (method.getDeclaringClass() == Object.class) {
        continue;
      } else if(Util.isDefault(method)) {
        DefaultMethodHandler handler = new DefaultMethodHandler(method);
        defaultMethodHandlers.add(handler);
        methodToHandler.put(method, handler);
      } else {
        methodToHandler.put(method, nameToHandler.get(Feign.configKey(target.type(), method)));
      }
    }
    InvocationHandler handler = factory.create(target, methodToHandler);
    T proxy = (T) Proxy.newProxyInstance(target.type().getClassLoader(), new Class<?>[]{target.type()}, handler);

    for(DefaultMethodHandler defaultMethodHandler : defaultMethodHandlers) {
      defaultMethodHandler.bindTo(proxy);
    }
    return proxy;
  }

在SynchronousMethodHandler類進行攔截處理，當被FeignClient的方法被攔截會根據參數生成RequestTemplate對象，該對象就是http請求的模板，代碼以下：

@Override
  public Object invoke(Object[] argv) throws Throwable {
    RequestTemplate template = buildTemplateFromArgs.create(argv);
    Retryer retryer = this.retryer.clone();
    while (true) {
      try {
        return executeAndDecode(template);
      } catch (RetryableException e) {
        retryer.continueOrPropagate(e);
        if (logLevel != Logger.Level.NONE) {
          logger.logRetry(metadata.configKey(), logLevel);
        }
        continue;
      }
    }
  }

其中有個executeAndDecode()方法，該方法是通RequestTemplate生成Request請求對象，而後根據用client獲取response。

Object executeAndDecode(RequestTemplate template) throws Throwable {
    Request request = targetRequest(template);
    ...//省略代碼
    response = client.execute(request, options);
    ...//省略代碼

}

Client組件 其中Client組件是一個很是重要的組件，Feign最終發送request請求以及接收response響應，都是由Client組件完成的，其中Client的實現類，只要有Client.Default，該類由HttpURLConnnection實現網絡請求，另外還支持HttpClient、Okhttp.

首先來看如下在FeignRibbonClient的自動配置類，FeignRibbonClientAutoConfiguration ，主要在工程啓動的時候注入一些bean,其代碼以下：

@ConditionalOnClass({ ILoadBalancer.class, Feign.class })
@Configuration
@AutoConfigureBefore(FeignAutoConfiguration.class)
public class FeignRibbonClientAutoConfiguration {

@Bean
    @ConditionalOnMissingBean
    public Client feignClient(CachingSpringLoadBalancerFactory cachingFactory,
            SpringClientFactory clientFactory) {
        return new LoadBalancerFeignClient(new Client.Default(null, null),
                cachingFactory, clientFactory);
    }

}

在缺失配置feignClient的狀況下，會自動注入new Client.Default(),跟蹤Client.Default()源碼，它使用的網絡請求框架爲HttpURLConnection，代碼以下：

@Override
    public Response execute(Request request, Options options) throws IOException {
      HttpURLConnection connection = convertAndSend(request, options);
      return convertResponse(connection).toBuilder().request(request).build();
    }

怎麼在feign中使用HttpClient，查看FeignRibbonClientAutoConfiguration的源碼

@ConditionalOnClass({ ILoadBalancer.class, Feign.class })
@Configuration
@AutoConfigureBefore(FeignAutoConfiguration.class)
public class FeignRibbonClientAutoConfiguration {
...//省略代碼

@Configuration
    @ConditionalOnClass(ApacheHttpClient.class)
    @ConditionalOnProperty(value = "feign.httpclient.enabled", matchIfMissing = true)
    protected static class HttpClientFeignLoadBalancedConfiguration {

        @Autowired(required = false)
        private HttpClient httpClient;

        @Bean
        @ConditionalOnMissingBean(Client.class)
        public Client feignClient(CachingSpringLoadBalancerFactory cachingFactory,
                SpringClientFactory clientFactory) {
            ApacheHttpClient delegate;
            if (this.httpClient != null) {
                delegate = new ApacheHttpClient(this.httpClient);
            }
            else {
                delegate = new ApacheHttpClient();
            }
            return new LoadBalancerFeignClient(delegate, cachingFactory, clientFactory);
        }
    }

...//省略代碼
}

從代碼@ConditionalOnClass(ApacheHttpClient.class)註解可知道，只須要在pom文件加上HttpClient的classpath就好了，另外須要在配置文件上加上feign.httpclient.enabled爲true，從 @ConditionalOnProperty註解可知，這個能夠不寫，在默認的狀況下就爲true.

在pom文件加上：

<dependency>
    <groupId>com.netflix.feign</groupId>
    <artifactId>feign-httpclient</artifactId>
    <version>RELEASE</version>
</dependency>

同理，若是想要feign使用Okhttp，則只須要在pom文件上加上feign-okhttp的依賴：

<dependency>
    <groupId>com.netflix.feign</groupId>
    <artifactId>feign-okhttp</artifactId>
    <version>RELEASE</version>
</dependency>

feign的負載均衡是怎麼樣實現的呢？ 經過上述的FeignRibbonClientAutoConfiguration類配置Client的類型(httpurlconnection，okhttp和httpclient)時候，可知最終向容器注入的是LoadBalancerFeignClient，即負載均衡客戶端。如今來看下LoadBalancerFeignClient的代碼：

@Override
    public Response execute(Request request, Request.Options options) throws IOException {
        try {
            URI asUri = URI.create(request.url());
            String clientName = asUri.getHost();
            URI uriWithoutHost = cleanUrl(request.url(), clientName);
            FeignLoadBalancer.RibbonRequest ribbonRequest = new FeignLoadBalancer.RibbonRequest(
                    this.delegate, request, uriWithoutHost);

            IClientConfig requestConfig = getClientConfig(options, clientName);
            return lbClient(clientName).executeWithLoadBalancer(ribbonRequest,
                    requestConfig).toResponse();
        }
        catch (ClientException e) {
            IOException io = findIOException(e);
            if (io != null) {
                throw io;
            }
            throw new RuntimeException(e);
        }
    }

其中有個executeWithLoadBalancer()方法，即經過負載均衡的方式請求。

public T executeWithLoadBalancer(final S request, final IClientConfig requestConfig) throws ClientException {
        RequestSpecificRetryHandler handler = getRequestSpecificRetryHandler(request, requestConfig);
        LoadBalancerCommand<T> command = LoadBalancerCommand.<T>builder()
                .withLoadBalancerContext(this)
                .withRetryHandler(handler)
                .withLoadBalancerURI(request.getUri())
                .build();

        try {
            return command.submit(
                new ServerOperation<T>() {
                    @Override
                    public Observable<T> call(Server server) {
                        URI finalUri = reconstructURIWithServer(server, request.getUri());
                        S requestForServer = (S) request.replaceUri(finalUri);
                        try {
                            return Observable.just(AbstractLoadBalancerAwareClient.this.execute(requestForServer, requestConfig));
                        } 
                        catch (Exception e) {
                            return Observable.error(e);
                        }
                    }
                })
                .toBlocking()
                .single();
        } catch (Exception e) {
            Throwable t = e.getCause();
            if (t instanceof ClientException) {
                throw (ClientException) t;
            } else {
                throw new ClientException(e);
            }
        }

    }

其中服務在submit()方法上，點擊submit進入具體的方法,這個方法是LoadBalancerCommand的方法：

Observable<T> o = 
                (server == null ? selectServer() : Observable.just(server))
                .concatMap(new Func1<Server, Observable<T>>() {
                    @Override
                    // Called for each server being selected
                    public Observable<T> call(Server server) {
                        context.setServer(server);

        }}

上述代碼中有個selectServe()，該方法是選擇服務的進行負載均衡的方法，代碼以下：

private Observable<Server> selectServer() {
        return Observable.create(new OnSubscribe<Server>() {
            @Override
            public void call(Subscriber<? super Server> next) {
                try {
                    Server server = loadBalancerContext.getServerFromLoadBalancer(loadBalancerURI, loadBalancerKey);   
                    next.onNext(server);
                    next.onCompleted();
                } catch (Exception e) {
                    next.onError(e);
                }
            }
        });
    }

最終負載均衡交給loadBalancerContext來處理，即以前講述的Ribbon，在這裏再也不重複。

總結

總到來講，Feign的源碼實現的過程以下：

首先經過@EnableFeignCleints註解開啓FeignCleint 根據Feign的規則實現接口，並加@FeignCleint註解 程序啓動後，會進行包掃描，掃描全部的@ FeignCleint的註解的類，並將這些信息注入到ioc容器中。 當接口的方法被調用，經過jdk的代理，來生成具體的RequesTemplate RequesTemplate在生成Request Request交給Client去處理，其中Client能夠是HttpUrlConnection、HttpClient也能夠是Okhttp 最後Client被封裝到LoadBalanceClient類，這個類結合類Ribbon作到了負載均衡。