前面已经学习了两个Spring Cloud 组件：

  • Eureka：实现服务注册功能；
  • Ribbon：提供基于RestTemplate的HTTP客户端并且支持服务负载均衡功能。

通过这两个组件我们暂时可以完成服务注册和可配置负载均衡的服务调用。今天我们要学习的是Feign，那么Feign解决了什么问题呢？

相对于Eureka，Ribbon来说，Feign的地位好像不是那么重要，Feign是一个声明式的REST客户端，它的目的就是让REST调用更加简单。通过提供HTTP请求模板，让Ribbon请求的书写更加简单和便捷。另外，在Feign中整合了Ribbon，从而不需要显式的声明Ribbon的jar包。

前面在使用Ribbon+RestTemplate时，利用RestTemplate对http请求的封装处理，形成了一套模版化的调用方法。但是在实际开发中，由于对服务依赖的调用可能不止一处，往往一个接口会被多处调用，所以通常都会针对每个微服务自行封装一些客户端类来包装这些依赖服务的调用。所以，Feign在此基础上做了进一步封装，由他来帮助我们定义和实现依赖服务接口的定义。在Feign的实现下，我们只需创建一个接口并使用注解的方式来配置它(以前是Dao接口上面标注Mapper注解,现在是一个微服务接口上面标注一个Feign注解即可)，即可完成对服务提供方的接口绑定，简化了使用Spring Cloud Ribbon时，自动封装服务调用客户端的开发量。

Feign的使用：

1.引入依赖：

  1. <dependency>
  2.     <groupId>org.springframework.cloud</groupId>
  3.     <artifactId>spring-cloud-starter-openfeign</artifactId>
  4. </dependency>

另外，我们需要添加spring-cloud-dependencies：

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  4.     <modelVersion>4.0.0</modelVersion>
  5.     <parent>
  6.         <groupId>org.springframework.boot</groupId>
  7.         <artifactId>spring-boot-starter-parent</artifactId>
  8.         <version>2.2.0.RELEASE</version>
  9.         <relativePath/> <!-- lookup parent from repository -->
  10.     </parent>
  11.     <groupId>com.rickiyang.learn</groupId>
  12.     <artifactId>feign-consumer</artifactId>
  13.     <version>0.0.1-SNAPSHOT</version>
  14.     <name>feign-consumer</name>
  15.     <description>Demo project for Spring Boot</description>
  17.     <properties>
  18.         <java.version>1.8</java.version>
  19.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  20.         <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
  21.         <spring-cloud.version>Finchley.RELEASE</spring-cloud.version>
  22.     </properties>
  24.     <dependencies>
  25.         <dependency>
  26.             <groupId>org.springframework.boot</groupId>
  27.             <artifactId>spring-boot-starter</artifactId>
  28.         </dependency>
  29.         <dependency>
  30.             <groupId>org.springframework.boot</groupId>
  31.             <artifactId>spring-boot-starter-test</artifactId>
  32.             <scope>test</scope>
  33.         </dependency>
  34.         <dependency>
  35.             <groupId>org.springframework.cloud</groupId>
  36.             <artifactId>spring-cloud-starter-openfeign</artifactId>
  37.         </dependency>
  38.         <dependency>
  39.             <groupId>org.springframework.boot</groupId>
  40.             <artifactId>spring-boot-starter-web</artifactId>
  41.         </dependency>
  42.         <dependency>
  43.             <groupId>org.springframework.cloud</groupId>
  44.             <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
  45.         </dependency>
  46.         <dependency>
  47.             <groupId>org.springframework.cloud</groupId>
  48.             <artifactId>spring-cloud-starter-eureka</artifactId>
  49.         </dependency>
  51.     </dependencies>
  53.     <dependencyManagement>
  54.         <dependencies>
  55.             <dependency>
  56.                 <groupId>org.springframework.cloud</groupId>
  57.                 <artifactId>spring-cloud-dependencies</artifactId>
  58.                 <version>${spring-cloud.version}</version>
  59.                 <type>pom</type>
  60.                 <scope>import</scope>
  61.             </dependency>
  62.         </dependencies>
  63.     </dependencyManagement>
  65.     <build>
  66.         <plugins>
  67.             <plugin>
  68.                 <groupId>org.springframework.boot</groupId>
  69.                 <artifactId>spring-boot-maven-plugin</artifactId>
  70.             </plugin>
  71.         </plugins>
  72.     </build>
  74. </project>

2.接下来，我们需要在主类中添加 @EnableFeignClients：

  1. package com.rickiyang.learn;
  3. import org.springframework.boot.SpringApplication;
  4. import org.springframework.boot.autoconfigure.SpringBootApplication;
  5. import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
  6. import org.springframework.cloud.openfeign.EnableFeignClients;
  8. @EnableDiscoveryClient
  9. @EnableFeignClients
  10. @SpringBootApplication
  11. public class FeignConsumerApplication {
  13.     public static void main(String[] args) {
  14.         SpringApplication.run(FeignConsumerApplication.class, args);
  15.     }
  17. }

3.再来看一下用Feign写的HTTP请求的格式：

  1. package com.rickiyang.learn.service;
  3. import com.rickiyang.learn.entity.Person;
  4. import org.springframework.cloud.openfeign.FeignClient;
  5. import org.springframework.web.bind.annotation.*;
  7. /**
  8.  * @author: rickiyang
  9.  * @date: 2019/10/5
  10.  * @description:
  11.  */
  12. @FeignClient(name= "eureka-client")
  13. public interface HelloRemote {
  15.     @RequestMapping(value = "/hello/{name}")
  16.     String hello(@PathVariable(value = "name") String name);
  18.     @PostMapping(value ="/add",produces = "application/json; charset=UTF-8")
  19.     String addPerson(@RequestBody Person person);
  21.     @GetMapping("/getPerson/{id}")
  22.     String getPerson(@PathVariable("id") Integer id);
  24. }

用FeignClient注解申明要调用的服务是哪个，该服务中的方法都有我们常见的Restful方式的API来声明，这种方式大家是不是感觉像是在写Restful接口一样。

代码示例：点击这里。

note：

示例代码的正确打开方式：先启动服务端，然后启动一个client端，再次启动 feign-consumer，调用 feign-consumer中的接口即可。

还记得在Ribbon学习的时候使用RestTemplate发起HTTP请求的方式吗：

  1. restTemplate.getForEntity("http://eureka-client/hello/" + name, String.class).getBody();

将整个的请求URL和参数都放在一起，虽然没有什么问题，总归不是那么优雅。使用Feign之后你可以使用Restful方式进行调用，写起来也会更加清晰。

Feign调用过程分析

上面简单介绍了Feign的使用方式，大家可以结合着代码示例运行一下，了解基本的使用方式。接下来我们一起分析Feign的调用过程，我们带着两个问题去跟踪：

1.请求如何被Feign 统一托管；

2.Feign如何分发请求。

这两个问题应该就涵盖了Feign的功能，下面就出发去一探究竟。

我们还和以前一样从一个入口进行深入，首先看启动类上的 @EnableFeignClients 注解：

  1. package org.springframework.cloud.openfeign;
  3. import java.lang.annotation.Documented;
  4. import java.lang.annotation.ElementType;
  5. import java.lang.annotation.Retention;
  6. import java.lang.annotation.RetentionPolicy;
  7. import java.lang.annotation.Target;
  9. import org.springframework.context.annotation.Import;
  11. /**
  12.  * Scans for interfaces that declare they are feign clients (via {@link FeignClient
  13.  * <code>@FeignClient</code>}). Configures component scanning directives for use with
  14.  * {@link org.springframework.context.annotation.Configuration
  15.  * <code>@Configuration</code>} classes.
  16.  *
  17.  * @author Spencer Gibb
  18.  * @author Dave Syer
  19.  * @since 1.0
  20.  */
  21. @Retention(RetentionPolicy.RUNTIME)
  22. @Target(ElementType.TYPE)
  23. @Documented
  24. @Import(FeignClientsRegistrar.class)
  25. public @interface EnableFeignClients {
  27.     //等价于basePackages属性，更简洁的方式
  28. 	String[] value() default {};
  29.     //指定多个包名进行扫描
  30. 	String[] basePackages() default {};
  32.     //指定多个类或接口的class,扫描时会在这些指定的类和接口所属的包进行扫描
  33. 	Class<?>[] basePackageClasses() default {};
  35. 	 //为所有的Feign Client设置默认配置类
  36. 	Class<?>[] defaultConfiguration() default {};
  38. 	 //指定用@FeignClient注释的类列表。如果该项配置不为空，则不会进行类路径扫描
  39. 	Class<?>[] clients() default {};
  40. }

注释上说了该注解用于扫描 FeignClient 声明的类。我们用 FeignClient 注解去声明一个 Eureka 客户端，那么猜想这里应该是取到我们声明的Eureka client名称，然后去访问Eureka server获取服务提供者。

同样的，为所有Feign Client 也支持文件属性的配置，如下 :

  1. feign:
  2.   client:
  3.     config:
  4.     # 默认为所有的feign client做配置(注意和上例github-client是同级的)
  5.       default:
  6.         connectTimeout: 5000                        # 连接超时时间
  7.         readTimeout: 5000                           # 读超时时间设置

注 : 如果通过Java代码进行了配置，又通过配置文件进行了配置，则配置文件的中的Feign配置会覆盖Java代码的配置。

但也可以设置feign.client.defalult-to-properties=false，禁用掉feign配置文件的方式让Java配置生效。

注意到类头声明的 @Import 注解引用的 FeignClientsRegistrar 类，这个类的作用是在 EnableFeignClients 初始化的时候扫描该注解对应的配置。

接着看 FeignClient 注解：

  1. package org.springframework.cloud.openfeign;
  2. import java.lang.annotation.Documented;
  3. import java.lang.annotation.ElementType;
  4. import java.lang.annotation.Retention;
  5. import java.lang.annotation.RetentionPolicy;
  6. import java.lang.annotation.Target;
  8. import org.springframework.core.annotation.AliasFor;
  10. @Target(ElementType.TYPE)
  11. @Retention(RetentionPolicy.RUNTIME)
  12. @Documented
  13. public @interface FeignClient {
  15.     //指定Feign Client的名称，如果项目使用了 Ribbon，name属性会作为微服务的名称，用于服务发现
  16. 	@AliasFor("name")
  17. 	String value() default "";
  18. 	//用serviceId做服务发现已经被废弃，所以不推荐使用该配置
  19. 	@Deprecated
  20. 	String serviceId() default "";
  21. 	//指定Feign Client的serviceId，如果项目使用了 Ribbon，将使用serviceId用于服务发现,但上面可以看到serviceId做服务发现已经被废弃，所以也不推荐使用该配置
  22. 	@AliasFor("value")
  23. 	String name() default "";
  24. 	//为Feign Client 新增注解@Qualifier
  25. 	String qualifier() default "";
  26.     //请求地址的绝对URL，或者解析的主机名
  27. 	String url() default "";
  28.     //调用该feign client发生了常见的404错误时，是否调用decoder进行解码异常信息返回,否则抛出FeignException
  29. 	boolean decode404() default false;
  30.      //Feign Client设置默认配置类
  31. 	Class<?>[] configuration() default {};
  32.     //定义容错的处理类，当调用远程接口失败或超时时，会调用对应接口的容错逻辑,fallback 指定的类必须实现@FeignClient标记的接口。实现的法方法即对应接口的容错处理逻辑
  33. 	Class<?> fallback() default void.class;
  34.     //工厂类，用于生成fallback 类示例，通过这个属性我们可以实现每个接口通用的容错逻辑，减少重复的代码
  35. 	Class<?> fallbackFactory() default void.class;
  36.     //定义当前FeignClient的所有方法映射加统一前缀
  37. 	String path() default "";
  38.     //是否将此Feign代理标记为一个Primary Bean，默认为ture
  39. 	boolean primary() default true;
  40. }

同样在 FeignClientsRegistrar 类中也会去扫描 FeignClient 注解对应的配置信息。我们直接看 FeignClientsRegistrar 的逻辑：

  1. class FeignClientsRegistrar implements ImportBeanDefinitionRegistrar,
  2. 		ResourceLoaderAware, EnvironmentAware {
  4. 	// patterned after Spring Integration IntegrationComponentScanRegistrar
  5. 	// and RibbonClientsConfigurationRegistgrar
  7. 	private ResourceLoader resourceLoader;
  9. 	private Environment environment;
  11. 	public FeignClientsRegistrar() {
  12. 	}
  14. 	@Override
  15. 	public void setResourceLoader(ResourceLoader resourceLoader) {
  16. 		this.resourceLoader = resourceLoader;
  17. 	}
  19.    //在这个重载的方法里面做了两件事情：
  20.    //1.将EnableFeignClients注解对应的配置属性注入
  21.    //2.将FeignClient注解对应的属性注入
  22. 	@Override
  23. 	public void registerBeanDefinitions(AnnotationMetadata metadata,
  24. 			BeanDefinitionRegistry registry) {
  25.         //注入EnableFeignClients注解对应的配置属性
  26. 		registerDefaultConfiguration(metadata, registry);
  27.        //注入FeignClient注解对应的属性
  28. 		registerFeignClients(metadata, registry);
  29. 	}
  31.    /**
  32.    * 拿到 EnableFeignClients注解 defaultConfiguration 字段的值
  33.    * 然后进行注入
  34.    *
  35.    **/
  36. 	private void registerDefaultConfiguration(AnnotationMetadata metadata,
  37. 			BeanDefinitionRegistry registry) {
  38. 		Map<String, Object> defaultAttrs = metadata
  39. 				.getAnnotationAttributes(EnableFeignClients.class.getName(), true);
  41. 		if (defaultAttrs != null && defaultAttrs.containsKey("defaultConfiguration")) {
  42. 			String name;
  43. 			if (metadata.hasEnclosingClass()) {
  44. 				name = "default." + metadata.getEnclosingClassName();
  45. 			}
  46. 			else {
  47. 				name = "default." + metadata.getClassName();
  48. 			}
  49. 			registerClientConfiguration(registry, name,
  50. 					defaultAttrs.get("defaultConfiguration"));
  51. 		}
  52. 	}
  54. 	public void registerFeignClients(AnnotationMetadata metadata,
  55. 								 BeanDefinitionRegistry registry) {
  56.         // 获取ClassPath扫描器
  57.         ClassPathScanningCandidateComponentProvider scanner = getScanner();
  58.         // 为扫描器设置资源加载器
  59.         scanner.setResourceLoader(this.resourceLoader);
  61.         Set<String> basePackages;
  62.         // 1. 从@EnableFeignClients注解中获取到配置的各个属性值
  63.         Map<String, Object> attrs = metadata
  64.                 .getAnnotationAttributes(EnableFeignClients.class.getName());
  65.         // 2. 注解类型过滤器，只过滤@FeignClient
  66.         AnnotationTypeFilter annotationTypeFilter = new AnnotationTypeFilter(
  67.                 FeignClient.class);
  68.         // 3. 从1. 中的属性值中获取clients属性的值
  69.         final Class<?>[] clients = attrs == null ? null
  70.                 : (Class<?>[]) attrs.get("clients");
  71.         if (clients == null || clients.length == 0) {
  72.             // 扫描器设置过滤器且获取需要扫描的基础包集合
  73.             scanner.addIncludeFilter(annotationTypeFilter);
  74.             basePackages = getBasePackages(metadata);
  75.         }else {
  76.             // clients属性值不为null，则将其clazz路径转为包路径
  77.             final Set<String> clientClasses = new HashSet<>();
  78.             basePackages = new HashSet<>();
  79.             for (Class<?> clazz : clients) {
  80.                 basePackages.add(ClassUtils.getPackageName(clazz));
  81.                 clientClasses.add(clazz.getCanonicalName());
  82.             }
  83.             AbstractClassTestingTypeFilter filter = new AbstractClassTestingTypeFilter() {
  84.                 @Override
  85.                 protected boolean match(ClassMetadata metadata) {
  86.                     String cleaned = metadata.getClassName().replaceAll("\\$", ".");
  87.                     return clientClasses.contains(cleaned);
  88.                 }
  89.             };
  90.             scanner.addIncludeFilter(
  91.                     new AllTypeFilter(Arrays.asList(filter, annotationTypeFilter)));
  92.         }
  94.         // 3. 扫描基础包，且满足过滤条件下的接口封装成BeanDefinition
  95.         for (String basePackage : basePackages) {
  96.             Set<BeanDefinition> candidateComponents = scanner
  97.                     .findCandidateComponents(basePackage);
  98.             // 遍历扫描到的bean定义
  99.             for (BeanDefinition candidateComponent : candidateComponents) {
  100.                 if (candidateComponent instanceof AnnotatedBeanDefinition) {
  101.                     // 并校验扫描到的bean定义类是一个接口
  102.                     AnnotatedBeanDefinition beanDefinition = (AnnotatedBeanDefinition) candidateComponent;
  103.                     AnnotationMetadata annotationMetadata = beanDefinition.getMetadata();
  104.                     Assert.isTrue(annotationMetadata.isInterface(),
  105.                             "@FeignClient can only be specified on an interface");
  107.                     // 获取@FeignClient注解上的各个属性值
  108.                     Map<String, Object> attributes = annotationMetadata
  109.                             .getAnnotationAttributes(
  110.                                     FeignClient.class.getCanonicalName());
  112.                     String name = getClientName(attributes);
  113.                     // 可以看到这里也注册了一个FeignClient的配置bean
  114.                     registerClientConfiguration(registry, name,
  115.                             attributes.get("configuration"));
  116.                     // 注册bean定义到spring中
  117.                     registerFeignClient(registry, annotationMetadata, attributes);
  118.                 }
  119.             }
  120.         }
  121. 	}
  123.    /**
  124.    * 注册bean
  125.    **/
  126. 	private void registerFeignClient(BeanDefinitionRegistry registry,
  127.        AnnotationMetadata annotationMetadata, Map<String, Object> attributes) {
  128.         // 1.获取类名称，也就是本例中的FeignService接口
  129.         String className = annotationMetadata.getClassName();
  131.         // 2.BeanDefinitionBuilder的主要作用就是构建一个AbstractBeanDefinition
  132.         // AbstractBeanDefinition类最终被构建成一个BeanDefinitionHolder
  133.         // 然后注册到Spring中
  134.         // 注意：beanDefinition类为FeignClientFactoryBean，故在Spring获取类的时候实际返回的是
  135.         // FeignClientFactoryBean类
  136.         BeanDefinitionBuilder definition = BeanDefinitionBuilder
  137.             .genericBeanDefinition(FeignClientFactoryBean.class);
  138.         validate(attributes);
  140.         // 3.添加FeignClientFactoryBean的属性，
  141.         // 这些属性也都是我们在@FeignClient中定义的属性
  142.         definition.addPropertyValue("url", getUrl(attributes));
  143.         definition.addPropertyValue("path", getPath(attributes));
  144.         String name = getName(attributes);
  145.         definition.addPropertyValue("name", name);
  146.         definition.addPropertyValue("type", className);
  147.         definition.addPropertyValue("decode404", attributes.get("decode404"));
  148.         definition.addPropertyValue("fallback", attributes.get("fallback"));
  149.         definition.addPropertyValue("fallbackFactory", attributes.get("fallbackFactory"));
  150.         definition.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE);
  152.         // 4.设置别名 name就是我们在@FeignClient中定义的name属性
  153.         String alias = name + "FeignClient";
  154.         AbstractBeanDefinition beanDefinition = definition.getBeanDefinition();
  156.         boolean primary = (Boolean)attributes.get("primary"); // has a default, won't be null
  158.         beanDefinition.setPrimary(primary);
  160.         String qualifier = getQualifier(attributes);
  161.         if (StringUtils.hasText(qualifier)) {
  162.             alias = qualifier;
  163.         }
  165.         // 5.定义BeanDefinitionHolder，
  166.         // 在本例中 名称为FeignService，类为FeignClientFactoryBean
  167.         BeanDefinitionHolder holder = new BeanDefinitionHolder(beanDefinition, className, new String[] { alias });
  168.         BeanDefinitionReaderUtils.registerBeanDefinition(holder, registry);
  169. 	}
  171. 	private void validate(Map<String, Object> attributes) {
  172. 		AnnotationAttributes annotation = AnnotationAttributes.fromMap(attributes);
  173. 		// This blows up if an aliased property is overspecified
  174. 		// FIXME annotation.getAliasedString("name", FeignClient.class, null);
  175. 		Assert.isTrue(
  176. 			!annotation.getClass("fallback").isInterface(),
  177. 			"Fallback class must implement the interface annotated by @FeignClient"
  178. 		);
  179. 		Assert.isTrue(
  180. 			!annotation.getClass("fallbackFactory").isInterface(),
  181. 			"Fallback factory must produce instances of fallback classes that implement the interface annotated by @FeignClient"
  182. 		);
  183. 	}
  185.    ......
  186.    ......
  187.    ......
  188. }

在这里做了两件事情：

  1. 将EnableFeignClients注解对应的配置属性注入；
  2. 将FeignClient注解对应的属性注入。

生成FeignClient对应的bean，注入到Spring 的IOC容器。

在registerFeignClient方法中构造了一个BeanDefinitionBuilder对象，BeanDefinitionBuilder的主要作用就是构建一个AbstractBeanDefinition，AbstractBeanDefinition类最终被构建成一个BeanDefinitionHolder 然后注册到Spring中。

beanDefinition类为FeignClientFactoryBean，故在Spring获取类的时候实际返回的是FeignClientFactoryBean类。

FeignClientFactoryBean作为一个实现了FactoryBean的工厂类，那么每次在Spring Context 创建实体类的时候会调用它的getObject()方法。

  1. public Object getObject() throws Exception {
  2.     FeignContext context = applicationContext.getBean(FeignContext.class);
  3.     Feign.Builder builder = feign(context);
  5.     if (!StringUtils.hasText(this.url)) {
  6.         String url;
  7.         if (!this.name.startsWith("http")) {
  8.             url = "http://" + this.name;
  9.         }
  10.         else {
  11.             url = this.name;
  12.         }
  13.         url += cleanPath();
  14.         return loadBalance(builder, context, new HardCodedTarget<>(this.type, this.name, url));
  15.     }
  16.     if (StringUtils.hasText(this.url) && !this.url.startsWith("http")) {
  17.         this.url = "http://" + this.url;
  18.     }
  19.     String url = this.url + cleanPath();
  20.     Client client = getOptional(context, Client.class);
  21.     if (client != null) {
  22.         if (client instanceof LoadBalancerFeignClient) {
  23.             // not lod balancing because we have a url,
  24.             // but ribbon is on the classpath, so unwrap
  25.             client = ((LoadBalancerFeignClient)client).getDelegate();
  26.         }
  27.         builder.client(client);
  28.     }
  29.     Targeter targeter = get(context, Targeter.class);
  30.     return targeter.target(this, builder, context, new HardCodedTarget<>(
  31.         this.type, this.name, url));
  32. }

这里的getObject()其实就是将@FeinClient中设置value值进行组装起来，此时或许会有疑问，因为在配置FeignClientFactoryBean类时特意说过并没有将Configuration传过来，那么Configuration中的属性是如何配置的呢？看其第一句是：

  1. FeignContext context = applicationContext.getBean(FeignContext.class);

从Spring容器中获取FeignContext.class的类，我们可以看下这个类是从哪加载的。点击该类查看被引用的地方，可以找到在FeignAutoConfiguration类中有声明bean：

  1. @Configuration
  2. @ConditionalOnClass(Feign.class)
  3. @EnableConfigurationProperties({FeignClientProperties.class, FeignHttpClientProperties.class})
  4. public class FeignAutoConfiguration {
  6. 	@Autowired(required = false)
  7. 	private List<FeignClientSpecification> configurations = new ArrayList<>();
  9. 	@Bean
  10. 	public HasFeatures feignFeature() {
  11. 		return HasFeatures.namedFeature("Feign", Feign.class);
  12. 	}
  14. 	@Bean
  15. 	public FeignContext feignContext() {
  16. 		FeignContext context = new FeignContext();
  17. 		context.setConfigurations(this.configurations);
  18. 		return context;
  19. 	}
  20.     ......
  21.     ......
  22.     ......
  24. }

从上面的代码中可以看到在set属性的时候将 FeignClientSpecification 类型的类全部加入此类的属性中。还记得在上面分析registerFeignClients方法的时候里面有一行代码调用：registerClientConfiguration()方法：

  1. private void registerClientConfiguration(BeanDefinitionRegistry registry, Object name,
  2.                                          Object configuration) {
  3.     BeanDefinitionBuilder builder = BeanDefinitionBuilder
  4.         .genericBeanDefinition(FeignClientSpecification.class);
  5.     builder.addConstructorArgValue(name);
  6.     builder.addConstructorArgValue(configuration);
  7.     registry.registerBeanDefinition(
  8.         name + "." + FeignClientSpecification.class.getSimpleName(),
  9.         builder.getBeanDefinition());
  10. }

在注册BeanDefinition的时候， configuration 其实也被作为参数，传给了 FeignClientSpecification。 所以这时候在FeignContext中是带着configuration配置信息的。

至此我们已经完成了配置属性的装配工作，那么是如何执行的呢？我们可以看getObject()最后一句可以看到返回了Targeter.target的方法。

  1. return targeter.target(this, builder, context, new HardCodedTarget<>(this.type, this.name, url));

那么这个Targeter是哪来的？我们还是看上面的FeignAutoConfiguration类，可以看到其中有两个Targeter类，一个是DefaultTargeter，一个是HystrixTargeter。当配置了feign.hystrix.enabled = true的时候，Spring容器中就会配置HystrixTargeter此类，如果为false那么Spring容器中配置的就是DefaultTargeter。

我们以DefaultTargeter为例介绍一下接下来是如何通过创建代理对象的：

  1. class DefaultTargeter implements Targeter {
  3. 	@Override
  4. 	public <T> T target(FeignClientFactoryBean factory, Feign.Builder feign, FeignContext context,
  5. 						Target.HardCodedTarget<T> target) {
  6. 		return feign.target(target);
  7. 	}
  8. }
  10. public static class Builder {
  12.     public <T> T target(Target<T> target) {
  13.       return build().newInstance(target);
  14.     }
  16.     public Feign build() {
  17.       SynchronousMethodHandler.Factory synchronousMethodHandlerFactory =
  18.           new SynchronousMethodHandler.Factory(client, retryer, requestInterceptors, logger,
  19.                                                logLevel, decode404);
  20.       ParseHandlersByName handlersByName =
  21.           new ParseHandlersByName(contract, options, encoder, decoder,
  22.                                   errorDecoder, synchronousMethodHandlerFactory);
  23.       return new ReflectiveFeign(handlersByName, invocationHandlerFactory);
  24.     }
  25.  }

在target方法中有个参数：Feign.Builder：

  1. public static class Builder {
  3.     private final List<RequestInterceptor> requestInterceptors =
  4.         new ArrayList<RequestInterceptor>();
  5.     private Logger.Level logLevel = Logger.Level.NONE;
  6.     private Contract contract = new Contract.Default();
  7.     private Client client = new Client.Default(null, null);
  8.     private Retryer retryer = new Retryer.Default();
  9.     private Logger logger = new NoOpLogger();
  10.     private Encoder encoder = new Encoder.Default();
  11.     private Decoder decoder = new Decoder.Default();
  12.     private ErrorDecoder errorDecoder = new ErrorDecoder.Default();
  13.     private Options options = new Options();
  14.     private InvocationHandlerFactory invocationHandlerFactory =
  15.         new InvocationHandlerFactory.Default();
  16.     private boolean decode404;
  18.     ......
  19.     ......
  20.     ......
  21. }

构建feign.builder时会向FeignContext获取配置的Encoder，Decoder等各种信息 。Builder中的参数来自于配置文件的 feign.client.config里面的属性。

查看ReflectiveFeign类中newInstance方法是返回一个代理对象：

  1. public <T> T newInstance(Target<T> target) {
  2.     //为每个方法创建一个SynchronousMethodHandler对象，并放在 Map 里面
  3.     Map<String, MethodHandler> nameToHandler = targetToHandlersByName.apply(target);
  4.     Map<Method, MethodHandler> methodToHandler = new LinkedHashMap<Method, MethodHandler>();
  5.     List<DefaultMethodHandler> defaultMethodHandlers = new LinkedList<DefaultMethodHandler>();
  7.     for (Method method : target.type().getMethods()) {
  8.         if (method.getDeclaringClass() == Object.class) {
  9.             continue;
  10.         } else if(Util.isDefault(method)) {
  11.             //如果是 default 方法，说明已经有实现了，用 DefaultHandler
  12.             DefaultMethodHandler handler = new DefaultMethodHandler(method);
  13.             defaultMethodHandlers.add(handler);
  14.             methodToHandler.put(method, handler);
  15.         } else {
  16.             //否则就用上面的 SynchronousMethodHandler
  17.             methodToHandler.put(method, nameToHandler.get(Feign.configKey(target.type(), method)));
  18.         }
  19.     }
  20.     // 设置拦截器
  21.     // 创建动态代理，factory 是 InvocationHandlerFactory.Default，创建出来的是
  22.     // ReflectiveFeign.FeignInvocationHanlder，也就是说后续对方法的调用都会进入到该对象的 inovke 方法
  23.     InvocationHandler handler = factory.create(target, methodToHandler);
  24.     // 创建动态代理对象
  25.     T proxy = (T) Proxy.newProxyInstance(target.type().getClassLoader(), new Class<?>[]{target.type()}, handler);
  27.     for(DefaultMethodHandler defaultMethodHandler : defaultMethodHandlers) {
  28.         defaultMethodHandler.bindTo(proxy);
  29.     }
  30.     return proxy;
  31. }

这个方法大概的逻辑是：

  1. 根据target，解析生成MethodHandler对象；
  2. 对MethodHandler对象进行分类整理，整理成两类：default 方法和 SynchronousMethodHandler 方法；
  3. 通过jdk动态代理生成代理对象，这里是最关键的地方；
  4. 将DefaultMethodHandler绑定到代理对象。

最终都是执行了SynchronousMethodHandler拦截器中的invoke方法：

  1. @Override
  2.   public Object invoke(Object[] argv) throws Throwable {
  3.     RequestTemplate template = buildTemplateFromArgs.create(argv);
  4.     Retryer retryer = this.retryer.clone();
  5.     while (true) {
  6.       try {
  7.         return executeAndDecode(template);
  8.       } catch (RetryableException e) {
  9.         retryer.continueOrPropagate(e);
  10.         if (logLevel != Logger.Level.NONE) {
  11.           logger.logRetry(metadata.configKey(), logLevel);
  12.         }
  13.         continue;
  14.       }
  15.     }
  16.   }

invoke方法方法首先生成 RequestTemplate 对象，应用 encoder，decoder 以及 retry 等配置，下面有一个死循环调用：executeAndDecode，从名字上看就是执行调用逻辑并对返回结果解析。

  1. Object executeAndDecode(RequestTemplate template) throws Throwable {
  2.     //根据  RequestTemplate生成Request对象
  3.     Request request = targetRequest(template);
  5.     if (logLevel != Logger.Level.NONE) {
  6.         logger.logRequest(metadata.configKey(), logLevel, request);
  7.     }
  9.     Response response;
  10.     long start = System.nanoTime();
  11.     try {
  12.         // 调用client对象的execute()方法执行http调用逻辑,
  13.         //execute()内部可能设置request对象，也可能不设置，所以需要response.toBuilder().request(request).build();这一行代码
  14.         response = client.execute(request, options);
  15.         // ensure the request is set. TODO: remove in Feign 10
  16.         response.toBuilder().request(request).build();
  17.     } catch (IOException e) {
  18.         if (logLevel != Logger.Level.NONE) {
  19.             logger.logIOException(metadata.configKey(), logLevel, e, elapsedTime(start));
  20.         }
  21.         // IOException的时候，包装成 RetryableException异常,上面的while循环 catch里捕捉的就是这个异常
  22.         throw errorExecuting(request, e);
  23.     }
  24.     //统计 执行调用花费的时间
  25.     long elapsedTime = TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - start);
  27.     boolean shouldClose = true;
  28.     try {
  29.         if (logLevel != Logger.Level.NONE) {
  30.             response =
  31.                 logger.logAndRebufferResponse(metadata.configKey(), logLevel, response, elapsedTime);
  32.             // ensure the request is set. TODO: remove in Feign 10
  33.             response.toBuilder().request(request).build();
  34.         }
  35.         //如果元数据返回类型是 Response，直接返回回去即可，不需要decode()解码
  36.         if (Response.class == metadata.returnType()) {
  37.             if (response.body() == null) {
  38.                 return response;
  39.             }
  40.             if (response.body().length() == null ||
  41.                 response.body().length() > MAX_RESPONSE_BUFFER_SIZE) {
  42.                 shouldClose = false;
  43.                 return response;
  44.             }
  45.             // Ensure the response body is disconnected
  46.             byte[] bodyData = Util.toByteArray(response.body().asInputStream());
  47.             return response.toBuilder().body(bodyData).build();
  48.         }
  49.         //主要对2xx和404等进行解码，404需要特别的开关控制。其他情况，使用errorDecoder进行解码，以异常的方式返回
  50.         if (response.status() >= 200 && response.status() < 300) {
  51.             if (void.class == metadata.returnType()) {
  52.                 return null;
  53.             } else {
  54.                 return decode(response);
  55.             }
  56.         } else if (decode404 && response.status() == 404 && void.class != metadata.returnType()) {
  57.             return decode(response);
  58.         } else {
  59.             throw errorDecoder.decode(metadata.configKey(), response);
  60.         }
  61.     } catch (IOException e) {
  62.         if (logLevel != Logger.Level.NONE) {
  63.             logger.logIOException(metadata.configKey(), logLevel, e, elapsedTime);
  64.         }
  65.         throw errorReading(request, response, e);
  66.     } finally {
  67.         if (shouldClose) {
  68.             ensureClosed(response.body());
  69.         }
  70.     }
  71. }

这里主要就是使用：client.execute(request, options) 来发起调用，下面基本都是处理返回结果的逻辑。到此我们的整个调用生态已经解析完毕。

我们可以整理一下上面的分析：

首先调用接口为什么会直接发送请求？

原因就是Spring扫描了@FeignClient注解，并且根据配置的信息生成代理类，调用的接口实际上调用的是生成的代理类。

其次请求是如何被Feign接管的？

  1. Feign通过扫描@EnableFeignClients注解中配置包路径，扫描@FeignClient注解并将注解配置的信息注入到Spring容器中，类型为FeignClientFactoryBean；
  2. 然后通过FeignClientFactoryBean的getObject()方法得到不同动态代理的类并为每个方法创建一个SynchronousMethodHandler对象；
  3. 为每一个方法创建一个动态代理对象， 动态代理的实现是 ReflectiveFeign.FeignInvocationHanlder，代理被调用的时候，会根据当前调用的方法，转到对应的 SynchronousMethodHandler。

这样我们发出的请求就能够被已经配置好各种参数的Feign handler进行处理，从而被Feign托管。

请求如何被Feign分发的？

上一个问题已经回答了Feign将每个方法都封装成为代理对象，那么当该方法被调用时，真正执行逻辑的是封装好的代理对象进行处理，执行对应的服务调用逻辑。

Spring Cloud Feign 调用过程分析的更多相关文章

  1. Bug集锦-Spring Cloud Feign调用其它接口报错

    问题描述 Spring Cloud Feign调用其它服务报错,错误提示如下:Failed to instantiate [java.util.List]: Specified class is an ...

  2. Spring Boot 和 Spring Cloud Feign调用服务及传递参数踩坑记录

    背景 :在Spring Cloud Netflix栈中,各个微服务都是以HTTP接口的形式暴露自身服务的,因此在调用远程服务时就必须使用HTTP客户端.我们可以使用JDK原生的URLConnectio ...

  3. spring cloud feign 调用接口报错"No message available

    There was an unexpected error (type=Internal Server Error, status=500). status 404 reading HelloServ ...

  4. Spring cloud Feign 调用端不生效

    如果提供方的接口经过测试是没问题的话. 消费方启动类加上@EnableFeignClients 注意定义的接口如果不和启动类在同一个包路径下,需要加basePackages 即:@EnableFeig ...

  5. spring cloud feign 调用服务注意问题

    服务端 rest api @RequestMapping(value = "/phone") public ResponsePhone getPhone(@RequestParam ...

  6. Spring Boot 和 Spring Cloud Feign调用服务及传递参数踩坑记录（转）

    https://blog.csdn.net/uotail/article/details/84673347

  7. Spring cloud Feign 深度学习与应用

    简介 Spring Cloud Feign是一个声明式的Web Service客户端,它的目的就是让Web Service调用更加简单.Feign提供了HTTP请求的模板,通过编写简单的接口和插入注解 ...

  8. 笔记：Spring Cloud Feign 声明式服务调用

    在实际开发中,对于服务依赖的调用可能不止一处,往往一个接口会被多处调用,所以我们通常会针对各个微服务自行封装一些客户端类来包装这些依赖服务的调用,Spring Cloud Feign 在此基础上做了进 ...

  9. 第六章：声明式服务调用：Spring Cloud Feign

    Spring Cloud Feign 是基于 Netflix Feign 实现的,整合了 Spring Cloud Ribbon 和 Spring Cloud Hystrix,除了提供这两者的强大功能 ...

随机推荐

  1. [摘抄] 2. module对象

    2. module对象 Node内部提供一个Module 构建函数,所有函数都是Module的实例. function Moudle(id,parent) { this.id = id; this.e ...

  2. const关键字总结

    在C语言中 const是C语言中总结 1.修饰的变量,使其具有常属性,使变量的值不能直接被改变.但是可以通过指针来间接的修改变量的值. 2.便于进行类型检查(在编译时进行类型检查),使编译对处理内容有 ...

  3. Android源码分析（四）-----Android源码编译及刷机步骤

    一 : 获取源码: 每个公司服务器地址不同,以如下源码地址为例: http://10.1.14.6/android/Qualcomm/msm89xx/branches/msm89xx svn环境执行: ...

  4. NumPy 之 存储文件和线性代数

    import numpy as np File Input and Output NumPy is able to save and load data to and from disk either ...

  5. Underscore——JS函数库

    转载请注明原文地址:https://www.cnblogs.com/ygj0930/p/10826065.html underscore是什么——它是一个js函数库 jQuery统一了不同浏览器之间的 ...

  6. DOM4j XML 工具类

    之前项目有跟客户系统对接一个webservice系统,该接口有传参和返回都是xml,所以找时间百度研究了一下dom4j,dom4j是一个Java的XML API,是jdom的升级品,用来读写XML文件 ...

  7. springboot集成mail实现邮件服务

    1,新建mailconfig类,对邮件服务固定配置进行实体封装: import java.util.Properties; import org.springframework.beans.facto ...

  8. java语言评价--java帝国

    “陛下您想想,我们有很多宝贝,” IO大臣根本不理线程大臣, 继续侃侃而谈:“ 比如IoC, AOP,反射.动态代理.泛型.注解.JDBC.JMS...... 还有我们引以为豪的JVM.这些东西,那些 ...

  9. oracle封装OracleHelper

    1.Oracle 封装类 using System; using System.Collections.Generic; using System.Linq; using System.Text; u ...

  10. BZOJ 3561: DZY Loves Math VI 莫比乌斯反演+复杂度分析

    推到了一个推不下去的形式,然后就不会了 ~ 看题解后傻了:我推的是对的,推不下去是因为不需要再推了. 复杂度看似很大,但其实是均摊 $O(n)$ 的,看来分析复杂度也是一个能力啊 ~ code: #i ...