Spring Cloud 负载平衡器架构选型

优质博文：IT-BLOG-CN
我们这次项目主要从RestTemplate 和 Feign 进行选型分析。
一、Spring Cloud Feign分析

   Feign是另外一种客户端负载平衡实现。
  我在该模块写了Feign Client的示例代码。
【1】spring-cloud-web-demo-api为服务的sdk模块
【2】spring-cloud-web-demo-service为提供接口服务的模块
【3】spring-cloud-web-demo-client为模拟调用服务的模块
首先在spring-cloud-web-demo-api模块，定义Feign API。spring-cloud-web-demo为spring-cloud-web-demo-service暴露的服务名。

1. @FeignClient(value = "spring-cloud-web-demo")
2. public interface UserFeign {
4.     @GetMapping(value = "/user/getUserById", produces = "application/json;charset=utf-8")
5.     Object getUserById(@RequestParam(value = "id", required = false) Long id);
7.     //省略
8. }

复制代码

然后通过ClientAutoConfiguration主动装配。（client直接引入api包就可以使用，不需要再EnableFeignClients）

1. @Configuration
2. @EnableFeignClients("net.teaho.demo.spring.cloud.web.api")
3. public class ClientAutoConfiguration {
4. }
6. org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
7. net.teaho.demo.spring.cloud.web.api.config.ClientAutoConfiguration

复制代码

在service模块如以往Spring MVC般实现api模块接口即可。

1. @RestController
2. public class UserController implements UserFeign {
4.     private static final Logger logger = LoggerFactory.getLogger(UserController.class);
6.     @Override
7.     public Object getUserById(Long id) {
8.         return "{"id":1, "name": "test"}";
9.     }
11.     //省略
12. }

复制代码

在Client模块，注入bean后直接调用。

1. @Component
2. @Slf4j
3. public class TestService {
4.     @Autowired
5.     private RestTemplate restTemplate;
7.     public Object getOneUser(){
8.         return userController.getUserById(1L);
9.     }
10. }

复制代码

二、RestTemplate分析

写了具有客户端负载平衡能力的RestTemplate的哀求代码。
类似这样定义：

1. @Bean
2. @LoadBalanced
3. public RestTemplate restTemplate() {
4.     return new RestTemplate();
5. }

复制代码

RestTemplate毕竟是如何使用注册中央实现客户端负载平衡的呢？
实现方式： 就是将上面所说的LoadBalancerInterceptor负载平衡拦截器加到标注了@LoadBalanced的RestTemplate实例中。 LoadBalancerInterceptor拦截器会在执行过程中获取并设置适合的目的哀求实例，重新构造哀求URI。

1. // 将配置中标注了@LoadBalanced的RestTemplate注入到这里
2. @LoadBalanced
3. @Autowired(required = false)
4. private List<RestTemplate> restTemplates = Collections.emptyList();
6. //将注册的RestTemplateCustomizer（RestTemplate自定义器）集合处理上面的restTemplates集合
7. @Bean
8. public SmartInitializingSingleton loadBalancedRestTemplateInitializerDeprecated(
9.         final ObjectProvider<List<RestTemplateCustomizer>> restTemplateCustomizers) {
10.     return () -> restTemplateCustomizers.ifAvailable(customizers -> {
11.         for (RestTemplate restTemplate : LoadBalancerAutoConfiguration.this.restTemplates) {
12.             for (RestTemplateCustomizer customizer : customizers) {
13.                 customizer.customize(restTemplate);
14.             }
15.         }
16.     });
17. }

复制代码

三、技能选型

最终选择使用OpenFeign，下面说说缘故原由。
和RestTemplate比起来，OpenFeign显得更适合Spring Boot微服务。
Open Feign相当于（HTTP）RPC，相比起RestTemplate，它直接显式将API声明以JAVA接口形式标识出来。 并且因为底层用的动态署理，它还可以（无感知地）更换底层实现。好比，github上就有更换底层逻辑的repo – Open Feign+Dubbo的RPC实现。
通过sdk包的形式，方便了调用，不需要像RestTemplate一样，客户端自行拼接上一串哀求参数。在代码编写上也清晰。
要使用就必须知道OpenFeign是怎么实现的呢？
四、OpenFeign 初始化分析

流程图如下：

看看前面例子里我们引入的OpenFeign的东西
【1】@EnableFeignClients(“net.teaho.demo.spring.cloud.web.api”)
【2】@FeignClient(value = “spring-cloud-web-demo”) 还有主动装配引入的
【3】FeignRibbonClientAutoConfiguration
【4】FeignClientsConfiguration
我们就从这两个注解开始分析源码。
【1】首先看@FeignClient注解。

1. //给接口标注成一个REST调用方
2. @Target(ElementType.TYPE)
3. @Retention(RetentionPolicy.RUNTIME)
4. @Documented
5. public @interface FeignClient {
6.     //服务名，可以带协议前缀，也可以用${property.name}关联一个配置值。
7.     @AliasFor("name")
8.     String value() default "";
10.     @Deprecated
11.     String serviceId() default "";
13.     //bean name
14.     String contextId() default "";
16.     @AliasFor("value")
17.     String name() default "";
19.     /**
20.      * Sets the <code>@Qualifier</code> value for the feign client.
21.      */
22.     String qualifier() default "";
23.     //直接指定一个地址，比如http://localhost:12345，一般用于调试
24.     String url() default "";
26.     boolean decode404() default false;
28.     /**
29.      * A custom <code>@Configuration</code> for the feign client. Can contain override
30.      * <code>@Bean</code> definition for the pieces that make up the client, for instance
31.      * {@link feign.codec.Decoder}, {@link feign.codec.Encoder}, {@link feign.Contract}.
32.      *
33.      * @see FeignClientsConfiguration for the defaults
34.      */
35.     //可用于覆盖FeignClient默认设置
36.     Class<?>[] configuration() default {};
37.     //回滚类，像我的例子中定义的回滚类必须实现UserFeign接口，看https://cloud.spring.io/spring-cloud-static/Greenwich.SR5/single/spring-cloud.html#spring-cloud-feign-hystrix-fallback
38.     Class<?> fallback() default void.class;
39.     //如果需要对异常做诊断可用此属性，https://cloud.spring.io/spring-cloud-static/Greenwich.SR5/single/spring-cloud.html#spring-cloud-feign-hystrix-fallback
40.     Class<?> fallbackFactory() default void.class;
41.     //路径前缀
42.     String path() default "";
43.     //标记bean是否为primary
44.     boolean primary() default true;
45. }

复制代码

【2】接下来重点关注@EnableFeignClients注解是如何扫描FeignClient接口的。

1. @Retention(RetentionPolicy.RUNTIME)
2. @Target(ElementType.TYPE)
3. @Documented
4. @Import(FeignClientsRegistrar.class)
5. public @interface EnableFeignClients {
7.     //省略
8. }

复制代码

嗯，发现没有，就是FeignClientsRegistrar做处理惩罚的。来分析下重点方法registerFeignClients和registerFeignClient

1. class FeignClientsRegistrar implements ImportBeanDefinitionRegistrar,
2.         ResourceLoaderAware, EnvironmentAware {
4.     public void registerFeignClients(AnnotationMetadata metadata,
5.             BeanDefinitionRegistry registry) {
6.         //classPath扫描器
7.         ClassPathScanningCandidateComponentProvider scanner = getScanner();
8.         scanner.setResourceLoader(this.resourceLoader);
9.         //ClassPathScanningCandidateComponentProvider扫描的basePackage集合
10.         Set<String> basePackages;
12.         Map<String, Object> attrs = metadata
13.                 .getAnnotationAttributes(EnableFeignClients.class.getName());
14.         //扫描器用于扫描标注了@FeignClient类的拦截器
15.         AnnotationTypeFilter annotationTypeFilter = new AnnotationTypeFilter(
16.                 FeignClient.class);
17.         final Class<?>[] clients = attrs == null ? null
18.                 : (Class<?>[]) attrs.get("clients");
19.         //clients属性为空，以@EnableFeignClients的value、basePackage等为根包扫描
20.         if (clients == null || clients.length == 0) {
21.             scanner.addIncludeFilter(annotationTypeFilter);
22.             basePackages = getBasePackages(metadata);
23.         }
24.         //@EnableFeignClients的clients属性不为空，解析clients的类和根包
25.         else {
26.             final Set<String> clientClasses = new HashSet<>();
27.             basePackages = new HashSet<>();
28.             for (Class<?> clazz : clients) {
29.                 basePackages.add(ClassUtils.getPackageName(clazz));
30.                 clientClasses.add(clazz.getCanonicalName());
31.             }
32.             AbstractClassTestingTypeFilter filter = new AbstractClassTestingTypeFilter() {
33.                 @Override
34.                 protected boolean match(ClassMetadata metadata) {
35.                     String cleaned = metadata.getClassName().replaceAll("\\$", ".");
36.                     return clientClasses.contains(cleaned);
37.                 }
38.             };
39.             scanner.addIncludeFilter(
40.                     new AllTypeFilter(Arrays.asList(filter, annotationTypeFilter)));
41.         }
43.         //1.根据basePackage找到目标@FeignClient接口
44.         //2.检查是否为接口
45.         //3.将找到的接口注册为FeignClientFactoryBean
46.         for (String basePackage : basePackages) {
47.             Set<BeanDefinition> candidateComponents = scanner
48.                     .findCandidateComponents(basePackage);
49.             for (BeanDefinition candidateComponent : candidateComponents) {
50.                 if (candidateComponent instanceof AnnotatedBeanDefinition) {
51.                     // verify annotated class is an interface
52.                     AnnotatedBeanDefinition beanDefinition = (AnnotatedBeanDefinition) candidateComponent;
53.                     AnnotationMetadata annotationMetadata = beanDefinition.getMetadata();
54.                     Assert.isTrue(annotationMetadata.isInterface(),
55.                             "@FeignClient can only be specified on an interface");
57.                     Map<String, Object> attributes = annotationMetadata
58.                             .getAnnotationAttributes(
59.                                     FeignClient.class.getCanonicalName());
61.                     String name = getClientName(attributes);
62.                     registerClientConfiguration(registry, name,
63.                             attributes.get("configuration"));
65.                     registerFeignClient(registry, annotationMetadata, attributes);
66.                 }
67.             }
68.         }
69.     }
71.     private String getClientName(Map<String, Object> client) {
72.         if (client == null) {
73.             return null;
74.         }
75.         String value = (String) client.get("contextId");
76.         if (!StringUtils.hasText(value)) {
77.             value = (String) client.get("value");
78.         }
79.         if (!StringUtils.hasText(value)) {
80.             value = (String) client.get("name");
81.         }
82.         if (!StringUtils.hasText(value)) {
83.             value = (String) client.get("serviceId");
84.         }
85.         if (StringUtils.hasText(value)) {
86.             return value;
87.         }
89.         throw new IllegalStateException("Either 'name' or 'value' must be provided in @"
90.                 + FeignClient.class.getSimpleName());
91.     }
93.     private void registerFeignClient(BeanDefinitionRegistry registry,
94.             AnnotationMetadata annotationMetadata, Map<String, Object> attributes) {
95.         String className = annotationMetadata.getClassName();
96.         BeanDefinitionBuilder definition = BeanDefinitionBuilder
97.                 .genericBeanDefinition(FeignClientFactoryBean.class);
98.         validate(attributes);
99.         definition.addPropertyValue("url", getUrl(attributes));
100.         definition.addPropertyValue("path", getPath(attributes));
101.         String name = getName(attributes);
102.         definition.addPropertyValue("name", name);
103.         String contextId = getContextId(attributes);
104.         definition.addPropertyValue("contextId", contextId);
105.         definition.addPropertyValue("type", className);
106.         definition.addPropertyValue("decode404", attributes.get("decode404"));
107.         definition.addPropertyValue("fallback", attributes.get("fallback"));
108.         definition.addPropertyValue("fallbackFactory", attributes.get("fallbackFactory"));
109.         definition.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE);
111.         String alias = contextId + "FeignClient";
112.         AbstractBeanDefinition beanDefinition = definition.getBeanDefinition();
114.         boolean primary = (Boolean)attributes.get("primary"); // has a default, won't be null
116.         beanDefinition.setPrimary(primary);
118.         String qualifier = getQualifier(attributes);
119.         if (StringUtils.hasText(qualifier)) {
120.             alias = qualifier;
121.         }
123.         BeanDefinitionHolder holder = new BeanDefinitionHolder(beanDefinition, className,
124.                 new String[] { alias });
125.         BeanDefinitionReaderUtils.registerBeanDefinition(holder, registry);
126.     }
127. }

复制代码

可以看到最后注册beanDefinition时，我们看到注册了FeignClientFactoryBean这一FactoryBean。 我们看看工厂bean FeignClientFactoryBean是如何构造对象的。

1. class FeignClientFactoryBean implements FactoryBean<Object>, InitializingBean,
2.         ApplicationContextAware {
4. //省略
6.     @Override
7.     public Object getObject() throws Exception {
8.         return getTarget();
9.     }
11.     <T> T getTarget() {
12.         //1.获取FeignContext，在FeignAutoConfiguration声明
13.         FeignContext context = applicationContext.getBean(FeignContext.class);
14.         //2.构造Feign builder
15.         Feign.Builder builder = feign(context);
17.         //3.如果没有设置url参数
18.         if (!StringUtils.hasText(this.url)) {
19.             if (!this.name.startsWith("http")) {
20.                 url = "http://" + this.name;
21.             }
22.             else {
23.                 url = this.name;
24.             }
25.             //4.设置path
26.             url += cleanPath();
27.             //5.获取Client（用于执行最终HTTP/HTTPS请求，比如LoadBalancerFeignClient），
28.             //构造反射实例
29.             return (T) loadBalance(builder, context, new HardCodedTarget<>(this.type,
30.                     this.name, url));
31.         }
32.         //存在url参数，构造非loadBalance的请求实例（target）
33.         if (StringUtils.hasText(this.url) && !this.url.startsWith("http")) {
34.             this.url = "http://" + this.url;
35.         }
36.         String url = this.url + cleanPath();
37.         Client client = getOptional(context, Client.class);
38.         if (client != null) {
39.             if (client instanceof LoadBalancerFeignClient) {
40.                 // not load balancing because we have a url,
41.                 // but ribbon is on the classpath, so unwrap
42.                 client = ((LoadBalancerFeignClient)client).getDelegate();
43.             }
44.             builder.client(client);
45.         }
46.         Targeter targeter = get(context, Targeter.class);
47.         return (T) targeter.target(this, builder, context, new HardCodedTarget<>(
48.                 this.type, this.name, url));
49.     }
51.     //在FeignContext中获取一些在FeignClientsConfiguration中声明，Feign需要用到的组件
52.     protected Feign.Builder feign(FeignContext context) {
53.         FeignLoggerFactory loggerFactory = get(context, FeignLoggerFactory.class);
54.         Logger logger = loggerFactory.create(this.type);
56.         // @formatter:off
57.         Feign.Builder builder = get(context, Feign.Builder.class)
58.                 // required values
59.                 .logger(logger)
60.                 .encoder(get(context, Encoder.class))
61.                 .decoder(get(context, Decoder.class))
62.                 .contract(get(context, Contract.class));
63.         // @formatter:on
65.         configureFeign(context, builder);
67.         return builder;
68.     }
71.     protected <T> T loadBalance(Feign.Builder builder, FeignContext context,
72.             HardCodedTarget<T> target) {
73.         //获取Client
74.         Client client = getOptional(context, Client.class);
75.         if (client != null) {
76.             builder.client(client);
77.             //从Context获取Targeter，Targeter用于生成最终target实例（对应我的例子是被调用的通过反射生成的UserFeign实例）
78.             Targeter targeter = get(context, Targeter.class);
79.             return targeter.target(this, builder, context, target);
80.         }
82.         throw new IllegalStateException(
83.                 "No Feign Client for loadBalancing defined. Did you forget to include spring-cloud-starter-netflix-ribbon?");
84.     }
87. //省略
89. }

复制代码

在非调试环境下（即我们没设置url参数）， 我们来看看targeter.target(this, builder, context, target)做了什么。
Targeter接口是构造被哀求的署理bean的类。有两个实现类HystrixTargeter、DefaultTargeter。
HystrixTargeter会比默认的多设置一些回滚措施，用到Feign的Contract属性， 我会先从DefaultTargeter说起。
DefaultTargeter会通过Feign.Builder#target(Target target)生成实例。我们来看看代码。

1. public abstract class Feign {
2. //省略
4.   public static class Builder {
6.     private final List<RequestInterceptor> requestInterceptors =
7.         new ArrayList<RequestInterceptor>();
8.     private Logger.Level logLevel = Logger.Level.NONE;
9.     private Contract contract = new Contract.Default();
10.     private Client client = new Client.Default(null, null);
11.     private Retryer retryer = new Retryer.Default();
12.     private Logger logger = new NoOpLogger();
13.     private Encoder encoder = new Encoder.Default();
14.     private Decoder decoder = new Decoder.Default();
15.     private QueryMapEncoder queryMapEncoder = new QueryMapEncoder.Default();
16.     private ErrorDecoder errorDecoder = new ErrorDecoder.Default();
17.     private Options options = new Options();
18.     private InvocationHandlerFactory invocationHandlerFactory =
19.         new InvocationHandlerFactory.Default();
20.     private boolean decode404;
21.     private boolean closeAfterDecode = true;
22.     private ExceptionPropagationPolicy propagationPolicy = NONE;
24.     //省略
26.     public <T> T target(Class<T> apiType, String url) {
27.       return target(new HardCodedTarget<T>(apiType, url));
28.     }
30.     public <T> T target(Target<T> target) {
31.       return build().newInstance(target);
32.     }
33.     //默认实现就是创建一个ReflectiveFeign实例
34.     public Feign build() {
36.       SynchronousMethodHandler.Factory synchronousMethodHandlerFactory =
37.           new SynchronousMethodHandler.Factory(client, retryer, requestInterceptors, logger,
38.               logLevel, decode404, closeAfterDecode, propagationPolicy);
39.       ParseHandlersByName handlersByName =
40.           new ParseHandlersByName(contract, options, encoder, decoder, queryMapEncoder,
41.               errorDecoder, synchronousMethodHandlerFactory);
42.       return new ReflectiveFeign(handlersByName, invocationHandlerFactory, queryMapEncoder);
43.     }
44.   }
46. //省略
47. }

复制代码

在解读ReflectiveFeign前介绍几个概念：
1、InvocationHandlerFactory 是控制反射方法分发的接口,create方法返回InvocationHandler。
2、InvocationHandlerFactory.MethodHandler 最终将对署理类方法调用转换成HTTP哀求的地方，请看实现类SynchronousMethodHandler
3、InvocationHandlerFactory.Default 默认实现，作为构造参数传入ReflectiveFeign，create方法创建的是new ReflectiveFeign.FeignInvocationHandler(target, dispatch)。
4、ReflectiveFeign.ParseHandlersByName 作为构造参数传入ReflectiveFeign，核心方法apply(Target key)先将标注了@FeignClient的接口的方法解析出待处理惩罚的元数据List, 然后创建出方法名和方法处理惩罚器的map映射Map<String, MethodHandler>String是方法名，方法处理惩罚器通过SynchronousMethodHandler.Factory#create创建。
5、FeignInvocationHandler 为处理惩罚一样平常方法的处理惩罚器
6、DefaultMethodHandler 为处理惩罚接口默认方法的处理惩罚器
有了以上介绍，接下来简朴分析ReflectiveFeign的newInstance方法。

1. public class ReflectiveFeign extends Feign {
2.   private final ParseHandlersByName targetToHandlersByName;
3.   private final InvocationHandlerFactory factory;
4.   private final QueryMapEncoder queryMapEncoder;
6.   ReflectiveFeign(ParseHandlersByName targetToHandlersByName, InvocationHandlerFactory factory,
7.       QueryMapEncoder queryMapEncoder) {
8.     this.targetToHandlersByName = targetToHandlersByName;
9.     this.factory = factory;
10.     this.queryMapEncoder = queryMapEncoder;
11.   }
13.   ..
14.   /**
15.    * creates an api binding to the {@code target}. As this invokes reflection, care should be taken
16.    * to cache the result.
17.    */
18.   @SuppressWarnings("unchecked")
19.   @Override
20.   public <T> T newInstance(Target<T> target) {
21.     //创建方法名和方法处理器的map映射
22.     Map<String, MethodHandler> nameToHandler = targetToHandlersByName.apply(target);
23.     Map<Method, MethodHandler> methodToHandler = new LinkedHashMap<Method, MethodHandler>();
24.     List<DefaultMethodHandler> defaultMethodHandlers = new LinkedList<DefaultMethodHandler>();
26.     for (Method method : target.type().getMethods()) {
27.       if (method.getDeclaringClass() == Object.class) {
28.         continue;
29.       //判断是否为接口的默认方法，DefaultMethodHandler的处理逻辑是直接调用会原接口的default方法
30.       } else if (Util.isDefault(method)) {
31.         DefaultMethodHandler handler = new DefaultMethodHandler(method);
32.         defaultMethodHandlers.add(handler);
33.         methodToHandler.put(method, handler);
34.       } else {
35.         //方法处理map
36.         methodToHandler.put(method, nameToHandler.get(Feign.configKey(target.type(), method)));
37.       }
38.     }
39.     InvocationHandler handler = factory.create(target, methodToHandler);
40.     //jdk动态代理创建对象
41.     T proxy = (T) Proxy.newProxyInstance(target.type().getClassLoader(),
42.         new Class<?>[] {target.type()}, handler);
43.     //将默认方法处理器也绑定到代理对象上
44.     for (DefaultMethodHandler defaultMethodHandler : defaultMethodHandlers) {
45.       defaultMethodHandler.bindTo(proxy);
46.     }
47.     return proxy;
48.   }
50.   static class FeignInvocationHandler implements InvocationHandler {
52.     private final Target target;
53.     private final Map<Method, MethodHandler> dispatch;
56.     //省略
58.     @Override
59.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
60.       //自定义的equals、hashCode和toString的处理
61.       if ("equals".equals(method.getName())) {
62.         try {
63.           Object otherHandler =
64.               args.length > 0 && args[0] != null ? Proxy.getInvocationHandler(args[0]) : null;
65.           return equals(otherHandler);
66.         } catch (IllegalArgumentException e) {
67.           return false;
68.         }
69.       } else if ("hashCode".equals(method.getName())) {
70.         return hashCode();
71.       } else if ("toString".equals(method.getName())) {
72.         return toString();
73.       }
74.       //分发调用到对应方法的InvocationHandlerFactory.MethodHandler
75.       return dispatch.get(method).invoke(args);
76.     }
78.     //省略
80. }

复制代码

初始化完成。
五、OpenFeign 执行分析

上图是OpenFeign构造的署理对象被调用时的时序图。
1、署理对象被执行
2、找到对应SynchronousMethodHandler进行方法调用。
3、构造RequestTemplate
4、LoadBalancerFeignClient执行负载哀求
5、FeignLoadBalancer通过ILoadBalancer选择合适Server，通过Server重组URI，通过RibbonRequest持有的Client执行实际HTTP哀求包装成Response。
6、SynchronousMethodHandler通过Decoder将哀求响应用Decoder解码成最终效果。
下面介绍执行过程中涉及到源码中的部分组件。
1、RequestTemplate 是一个HTTP哀求内容的抽象。
2、RequestTemplate.Factory 将方法参数解析成RequestTemplate。
3、Retryer 我在上面的时序图没有标注出来，实际上它在SynchronousMethodHandler的执行中控制重试逻辑。
4、RequestInterceptor 在SynchronousMethodHandler发起执行中，会使用该拦截器对RequestTemplate进行处理惩罚。这是一个拓展点。
5、Logger 执行哀求时打日记（在debug时打）。默认为Logger.Level.NONE即不打日记，可以增加bean覆盖。

• Logger.Level.NONE 不打印信息
  
• Logger.Level.BASIC 打印哀求url和响应码。
  
• Logger.Level.HEADERS 打印BASIC信息外加header信息
  
• Logger.Level.FULL 打印所有
  

6、LoadBalancerFeignClient Client接口的实现类，是具有负载平衡能力的Client。Client接口为执行HTTP的接口，Client.Default是最终发出HTTP哀求的类。

7、FeignLoadBalancer FeignLoadBalancer通过ILoadBalancer选择合适Server，通过Server重组URI，通过RibbonRequest持有的Client执行实际HTTP哀求包装成Response。
8、LoadBalancerCommand ribbon的rxJava实现，执行负载流程逻辑的组件。
9、ILoadBalancer ribbon的负载平衡器抽象。
熔断： 在FeignClientsConfiguration中， 当配置了feign.hystrix.enabled,Feign Builder使用HystrixFeign.builder()。
以是build的时候新建HystrixInvocationHandler和HystrixDelegatingContract实例。

1. Feign build(final FallbackFactory<?> nullableFallbackFactory) {
2.    super.invocationHandlerFactory(new InvocationHandlerFactory() {
3.      @Override
4.      public InvocationHandler create(Target target,
5.                                      Map<Method, MethodHandler> dispatch) {
6.        return new HystrixInvocationHandler(target, dispatch, setterFactory,
7.            nullableFallbackFactory);
8.      }
9.    });
10.    super.contract(new HystrixDelegatingContract(contract));
11.    return super.build();
12. }

复制代码

来看看HystrixInvocationHandler的hystrix调用代码

1. final class HystrixInvocationHandler implements InvocationHandler {
2.    //省略
4.   @Override
5.   public Object invoke(final Object proxy, final Method method, final Object[] args)
6.       throws Throwable {
7.    //省略
8.     HystrixCommand<Object> hystrixCommand =
9.         new HystrixCommand<Object>(setterMethodMap.get(method)) {
11.           //实际执行
12.           @Override
13.           protected Object run() throws Exception {
14.             try {
15.               return HystrixInvocationHandler.this.dispatch.get(method).invoke(args);
16.             } catch (Exception e) {
17.               throw e;
18.             } catch (Throwable t) {
19.               throw (Error) t;
20.             }
21.           }
23.           @Override
24.           protected Object getFallback() {
25.             if (fallbackFactory == null) {
26.               return super.getFallback();
27.             }
28.             try {
29.               //用配置的fallbackFactory创建fallback实例
30.               Object fallback = fallbackFactory.create(getExecutionException());
31.               Object result = fallbackMethodMap.get(method).invoke(fallback, args);
32.               //根据fallback对象的returntype解析包装内的结果返回
33.               if (isReturnsHystrixCommand(method)) {
34.                 return ((HystrixCommand) result).execute();
35.               } else if (isReturnsObservable(method)) {
36.                 // Create a cold Observable
37.                 return ((Observable) result).toBlocking().first();
38.               } else if (isReturnsSingle(method)) {
39.                 // Create a cold Observable as a Single
40.                 return ((Single) result).toObservable().toBlocking().first();
41.               } else if (isReturnsCompletable(method)) {
42.                 ((Completable) result).await();
43.                 return null;
44.               } else {
45.                 return result;
46.               }
47.             } catch (IllegalAccessException e) {
48.               // shouldn't happen as method is public due to being an interface
49.               throw new AssertionError(e);
50.             } catch (InvocationTargetException e) {
51.               // Exceptions on fallback are tossed by Hystrix
52.               throw new AssertionError(e.getCause());
53.             }
54.           }
55.         };
57.     //根据方法的return去返回结果
58.     if (Util.isDefault(method)) {
59.       return hystrixCommand.execute();
60.     } else if (isReturnsHystrixCommand(method)) {
61.       return hystrixCommand;
62.     } else if (isReturnsObservable(method)) {
63.       // Create a cold Observable
64.       return hystrixCommand.toObservable();
65.     } else if (isReturnsSingle(method)) {
66.       // Create a cold Observable as a Single
67.       return hystrixCommand.toObservable().toSingle();
68.     } else if (isReturnsCompletable(method)) {
69.       return hystrixCommand.toObservable().toCompletable();
70.     }
71.     return hystrixCommand.execute();
72.   }
74.    //省略
75. }

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。