feign:（推薦使用）
Feign是受到Retrofit，JAXRS-2.0和WebSocket的影響，它是一個jav的到http客戶端綁定的開源項目。 Feign的主要目標是將Java Http 客戶端變得簡單.減少配置文件，實現基於注解零配置調用
源碼分析：
feign的實現：
1>啟動類加注解：@EnableFeignClients
2> feign實現：
3> 接口調用
這是feign的實現過程：這是代碼實現，注意還需要配置文件，又不懂的參考我博客 springcloud 入門 3 （服務之間的調用）
源碼層次：
1>源碼入口：@FeignClient
note：在正式進入源碼之前，我先介紹一個包：spring-cloud-openfeign-core.后面所有的源碼基本上都在這個包里。為啥我要先介紹一下呢。因為以前總說feign整合了ribbon，那我們從哪看出來呢？
下面我來帶大家看一下包結構就清楚了。
剩下的自己可以更進一步去追源碼，看是怎么封裝整合的！在這我就不往下追了，
2> Feign源碼實現：
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
Feign的工作原理
feign是一個偽客戶端，即它不做任何的請求處理。Feign通過處理注解生成request，從而實現簡化HTTP API開發的目的，即開發人員可以使用注解的方式定制request api模板，在發送http request請求之前，feign通過處理注解的方式替換掉request模板中的參數，這種實現方式顯得更為直接、可理解。通過包掃描注入FeignClient的bean，該源碼在FeignClientsRegistrar類：
首先在啟動配置上檢查是否有@EnableFeignClients注解，如果有該注解，則開啟包掃描，掃描被@FeignClient注解接口
1 private void registerDefaultConfiguration(AnnotationMetadata metadata, 2 BeanDefinitionRegistry registry) { 3 Map<String, Object> defaultAttrs = metadata 4 .getAnnotationAttributes(EnableFeignClients.class.getName(), true); 5 6 if (defaultAttrs != null && defaultAttrs.containsKey("defaultConfiguration")) { 7 String name; 8 if (metadata.hasEnclosingClass()) { 9 name = "default." + metadata.getEnclosingClassName(); 10 } 11 else { 12 name = "default." + metadata.getClassName(); 13 } 14 registerClientConfiguration(registry, name, 15 defaultAttrs.get("defaultConfiguration")); 16 } 17 }
程序啟動后通過包掃描，當類有@FeignClient注解，將注解的信息取出，連同類名一起取出，賦給BeanDefinitionBuilder，然后根據BeanDefinitionBuilder得到beanDefinition，最后beanDefinition式注入到ioc容器中，源碼如下：
1 public void registerFeignClients(AnnotationMetadata metadata, 2 BeanDefinitionRegistry registry) { 3 ClassPathScanningCandidateComponentProvider scanner = getScanner(); 4 scanner.setResourceLoader(this.resourceLoader); 5 6 Set<String> basePackages; 7 8 Map<String, Object> attrs = metadata 9 .getAnnotationAttributes(EnableFeignClients.class.getName()); 10 AnnotationTypeFilter annotationTypeFilter = new AnnotationTypeFilter( 11 FeignClient.class); 12 final Class<?>[] clients = attrs == null ? null 13 : (Class<?>[]) attrs.get("clients"); 14 if (clients == null || clients.length == 0) { 15 scanner.addIncludeFilter(annotationTypeFilter); 16 basePackages = getBasePackages(metadata); 17 } 18 else { 19 final Set<String> clientClasses = new HashSet<>(); 20 basePackages = new HashSet<>(); 21 for (Class<?> clazz : clients) { 22 basePackages.add(ClassUtils.getPackageName(clazz)); 23 clientClasses.add(clazz.getCanonicalName()); 24 } 25 AbstractClassTestingTypeFilter filter = new AbstractClassTestingTypeFilter() { 26 @Override 27 protected boolean match(ClassMetadata metadata) { 28 String cleaned = metadata.getClassName().replaceAll("\\$", "."); 29 return clientClasses.contains(cleaned); 30 } 31 }; 32 scanner.addIncludeFilter( 33 new AllTypeFilter(Arrays.asList(filter, annotationTypeFilter))); 34 } 35 36 for (String basePackage : basePackages) { 37 Set<BeanDefinition> candidateComponents = scanner 38 .findCandidateComponents(basePackage); 39 for (BeanDefinition candidateComponent : candidateComponents) { 40 if (candidateComponent instanceof AnnotatedBeanDefinition) { 41 // verify annotated class is an interface 42 AnnotatedBeanDefinition beanDefinition = (AnnotatedBeanDefinition) candidateComponent; 43 AnnotationMetadata annotationMetadata = beanDefinition.getMetadata(); 44 Assert.isTrue(annotationMetadata.isInterface(), 45 "@FeignClient can only be specified on an interface"); 46 47 Map<String, Object> attributes = annotationMetadata 48 .getAnnotationAttributes( 49 FeignClient.class.getCanonicalName()); 50 51 String name = getClientName(attributes); 52 registerClientConfiguration(registry, name, 53 attributes.get("configuration")); 54 55 registerFeignClient(registry, annotationMetadata, attributes); 56 } 57 } 58 } 59 } 60 61 62 private void registerFeignClient(BeanDefinitionRegistry registry, 63 AnnotationMetadata annotationMetadata, Map<String, Object> attributes) { 64 String className = annotationMetadata.getClassName(); 65 BeanDefinitionBuilder definition = BeanDefinitionBuilder 66 .genericBeanDefinition(FeignClientFactoryBean.class); 67 validate(attributes); 68 definition.addPropertyValue("url", getUrl(attributes)); 69 definition.addPropertyValue("path", getPath(attributes)); 70 String name = getName(attributes); 71 definition.addPropertyValue("name", name); 72 definition.addPropertyValue("type", className); 73 definition.addPropertyValue("decode404", attributes.get("decode404")); 74 definition.addPropertyValue("fallback", attributes.get("fallback")); 75 definition.addPropertyValue("fallbackFactory", attributes.get("fallbackFactory")); 76 definition.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE); 77 78 String alias = name + "FeignClient"; 79 AbstractBeanDefinition beanDefinition = definition.getBeanDefinition(); 80 81 boolean primary = (Boolean)attributes.get("primary"); // has a default, won't be null 82 83 beanDefinition.setPrimary(primary); 84 85 String qualifier = getQualifier(attributes); 86 if (StringUtils.hasText(qualifier)) { 87 alias = qualifier; 88 } 89 90 BeanDefinitionHolder holder = new BeanDefinitionHolder(beanDefinition, className, 91 new String[] { alias }); 92 BeanDefinitionReaderUtils.registerBeanDefinition(holder, registry); 93 }
注入bean之后，通過jdk的代理，當請求Feign Client的方法時會被攔截，代碼在ReflectiveFeign類，代碼如下：
1 public <T> T newInstance(Target<T> target) { 2 Map<String, MethodHandler> nameToHandler = targetToHandlersByName.apply(target); 3 Map<Method, MethodHandler> methodToHandler = new LinkedHashMap<Method, MethodHandler>(); 4 List<DefaultMethodHandler> defaultMethodHandlers = new LinkedList<DefaultMethodHandler>(); 5 6 for (Method method : target.type().getMethods()) { 7 if (method.getDeclaringClass() == Object.class) { 8 continue; 9 } else if(Util.isDefault(method)) { 10 DefaultMethodHandler handler = new DefaultMethodHandler(method); 11 defaultMethodHandlers.add(handler); 12 methodToHandler.put(method, handler); 13 } else { 14 methodToHandler.put(method, nameToHandler.get(Feign.configKey(target.type(), method))); 15 } 16 } 17 InvocationHandler handler = factory.create(target, methodToHandler); 18 T proxy = (T) Proxy.newProxyInstance(target.type().getClassLoader(), new Class<?>[]{target.type()}, handler); 19 20 for(DefaultMethodHandler defaultMethodHandler : defaultMethodHandlers) { 21 defaultMethodHandler.bindTo(proxy); 22 } 23 return proxy; 24 }
在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，代碼如下：
1 @Override 2 public Response execute(Request request, Options options) throws IOException { 3 HttpURLConnection connection = convertAndSend(request, options); 4 return convertResponse(connection).toBuilder().request(request).build(); 5 }
怎么在feign中使用HttpClient，查看FeignRibbonClientAutoConfiguration的源碼
1 @ConditionalOnClass({ ILoadBalancer.class, Feign.class }) 2 @Configuration 3 @AutoConfigureBefore(FeignAutoConfiguration.class) 4 public class FeignRibbonClientAutoConfiguration { 5 ...//省略代碼 6 7 @Configuration 8 @ConditionalOnClass(ApacheHttpClient.class) 9 @ConditionalOnProperty(value = "feign.httpclient.enabled", matchIfMissing = true) 10 protected static class HttpClientFeignLoadBalancedConfiguration { 11 12 @Autowired(required = false) 13 private HttpClient httpClient; 14 15 @Bean 16 @ConditionalOnMissingBean(Client.class) 17 public Client feignClient(CachingSpringLoadBalancerFactory cachingFactory, 18 SpringClientFactory clientFactory) { 19 ApacheHttpClient delegate; 20 if (this.httpClient != null) { 21 delegate = new ApacheHttpClient(this.httpClient); 22 } 23 else { 24 delegate = new ApacheHttpClient(); 25 } 26 return new LoadBalancerFeignClient(delegate, cachingFactory, clientFactory); 27 } 28 } 29 30 ...//省略代碼 31 }
從代碼@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的代碼：
1 @Override 2 public Response execute(Request request, Request.Options options) throws IOException { 3 try { 4 URI asUri = URI.create(request.url()); 5 String clientName = asUri.getHost(); 6 URI uriWithoutHost = cleanUrl(request.url(), clientName); 7 FeignLoadBalancer.RibbonRequest ribbonRequest = new FeignLoadBalancer.RibbonRequest( 8 this.delegate, request, uriWithoutHost); 9 10 IClientConfig requestConfig = getClientConfig(options, clientName); 11 return lbClient(clientName).executeWithLoadBalancer(ribbonRequest, 12 requestConfig).toResponse(); 13 } 14 catch (ClientException e) { 15 IOException io = findIOException(e); 16 if (io != null) { 17 throw io; 18 } 19 throw new RuntimeException(e); 20 } 21 }
其中有個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來處理，
總結
總到來說，Feign的源碼實現的過程如下：
- 首先通過@EnableFeignCleints注解開啟FeignCleint
- 根據Feign的規則實現接口，並加@FeignCleint注解
- 程序啟動后，會進行包掃描，掃描所有的@ FeignCleint的注解的類，並將這些信息注入到ioc容器中。
- 當接口的方法被調用，通過jdk的代理，來生成具體的RequesTemplate
- RequesTemplate在生成Request
- Request交給Client去處理，其中Client可以是HttpUrlConnection、HttpClient也可以是Okhttp
- 最后Client被封裝到LoadBalanceClient類，這個類結合類Ribbon做到了負載均衡。