SpringCloudRPC远程调用核心原理：FeignRPC动态代理实例创建流程

package org.springframework.cloud.openfeign;
...
class FeignClientFactoryBean implements FactoryBean<Object>, InitializingBean, ApplicationContextAware {
 private Class<?> type; //RPC接口的class对象
 private String name; //RPC接口配置的远程provider微服务名称，如demo-provider
 private String url; //RPC接口配置的url值，由 @FeignClient注解负责配置
 private String path; //RPC接口配置的path值，由 @FeignClient注解负责配置
 private boolean decode404;
 private ApplicationContext applicationContext;
 private Class<?> fallback;
 private Class<?> fallbackFactory;
 ...
 //获取IOC容器的Feign.Builder建造者Bean
 protected Builder feign(FeignContext context) {
 FeignLoggerFactory loggerFactory = this.get(context, FeignLoggerFactory.class);
 Logger logger = loggerFactory.create(this.type);
 //从IOC容器获取Feign.Builder实例
//并且设置编码器、解码器、日志器、方法解析器
 Builder builder = ((Builder)this.get(context, Builder.class))
 .logger(logger)
 .encoder((Encoder)this.get(context, Encoder.class))
 .decoder((Decoder)this.get(context, Decoder.class))
 .contract((Contract)this.get(context,Contract.class));
 this.configureFeign(context, builder);
 return builder;
 }
 //通过ID或者类型获取IOC容器Bean时调用
 public Object getObject() throws Exception {
 //委托到 getTarget 方法
 return this.getTarget();
 }
 //委托方法：获取RPC动态代理Bean
 <T> T getTarget() {
 FeignContext context = (FeignContext)this.applicationContext.
getBean(FeignContext.class);
 //获取Feign.Builder建造者实例
 Builder builder = this.feign(context);
 String url;
 ...
 }
 ...
}

class FeignClientsRegistrar implements ImportBeanDefinitionRegistrar, ... {
 ...
 //为每一个RPC客户端接口注册一个beanDefinition，其beanClass为FeignClientFactoryBean
 private void registerFeignClient(BeanDefinitionRegistry registry,
 AnnotationMetadata annotationMetadata,
 Map<String, Object> attributes) {
 String className = annotationMetadata.getClassName();
 BeanDefinitionBuilder definition =
 BeanDefinitionBuilder.genericBeanDefinition(FeignClientFactoryBean.class);
 this.validate(attributes);
 //RPC接口配置的url值
 definition.addPropertyValue("url", this.getUrl(attributes));
 //RPC接口配置的path值
 definition.addPropertyValue("path", this.getPath(attributes));
 String name = this.getName(attributes);
 definition.addPropertyValue("name", name); //RPC接口配置的远程provider名称
 definition.addPropertyValue("type", className); //RPC接口的全路径类名
 definition.addPropertyValue("decode404", attributes.get("decode404"));
 definition.addPropertyValue("fallback", attributes.get("fallback"));
 definition.addPropertyValue("fallbackFactory", attributes.get("fallbackFactory"));
 definition.setAutowireMode(2);
 //别名
 String alias = name + "FeignClient";
 AbstractBeanDefinition beanDefinition = definition.getBeanDefinition();
 //RPC接口配置的primary值
 boolean primary = (Boolean)attributes.get("primary");
 beanDefinition.setPrimary(primary);
 String qualifier = this.getQualifier(attributes);
 if (StringUtils.hasText(qualifier)) {
 alias = qualifier;
 }
 BeanDefinitionHolder holder = new BeanDefinitionHolder(beanDefinition, className, new String[]{alias});
 BeanDefinitionReaderUtils.registerBeanDefinition(holder, registry);
 }
}

package org.springframework.cloud.openfeign;
//省略import
//Feign客户端的配置类
@Configuration
public class FeignClientsConfiguration {
 //容器实例：请求结果解码器
 @Bean
 @ConditionalOnMissingBean
 public Decoder feignDecoder() {
 return new OptionalDecoder(new ResponseEntityDecoder(
new SpringDecoder(this.messageConverters)));
}
 //容器实例：请求编码器
 @Bean
 @ConditionalOnMissingBean
 public Encoder feignEncoder() {
 return new SpringEncoder(this.messageConverters);
 }
 //容器实例：请求重试实例，如果没有定制，就默认返回NEVER_RETRY（不重试）实例
 @Bean
 @ConditionalOnMissingBean
 public Retryer feignRetryer() {
 return Retryer.NEVER_RETRY;
} //容器实例：Feign.Builder客户端建造者实例，以“请求重试实例”作为参数进行初始化
 @Bean
 @Scope("prototype")
 @ConditionalOnMissingBean
 public Builder feignBuilder(Retryer retryer) {
 return Feign.builder().retryer(retryer);
 }
...
}

package feign;
...
public abstract class Feign {
 ...
 //建造者方法
 public static Builder builder() {
 return new Builder();
 }
 //内部类：建造者类
 public static class Builder {
...
//创建RPC客户端的动态代理实例
 public <T> T target(Target<T> target) {
 return build().newInstance(target);
}
//建造方法
public Feign build() {
 //方法处理器工厂的实例
 SynchronousMethodHandler.Factory synchronousMethodHandlerFactory =
 new SynchronousMethodHandler.Factory(client,
 retryer,
 requestInterceptors,
 logger,
 logLevel, decode404);
 //RPC方法解析器
 ParseHandlersByName handlersByName = new ParseHandlersByName
(contract, options, encoder, decoder, errorDecoder, synchronousMethodHandlerFactory);
 //反射式Feign实例
 return new ReflectiveFeign(handlersByName, invocationHandlerFactory);
 }
 }

package feign;
//省略import
public class ReflectiveFeign extends Feign {
 //方法解析器
private final ParseHandlersByName targetToHandlersByName;
//调用处理器工厂
private final InvocationHandlerFactory factory;
 ...
 //创建RPC客户端动态代理实例
 public <T> T newInstance(Target<T> target) {
 //方法解析: 方法名和方法处理器的映射
 Map<String, MethodHandler> nameToHandler = targetToHandlersByName.apply(target);
//方法反射对象和方法处理器的映射
 Map<Method, MethodHandler> methodToHandler = new LinkedHashMap<Method, MethodHandler>();
 ...
//创建一个InvocationHandler调用处理器
 InvocationHandler handler = factory.create(target, methodToHandler);
//最后调用JDK的Proxy.newProxyInstance创建代理对象
T proxy = (T) Proxy.newProxyInstance(
target.type().getClassLoader(), new Class<?>[]{target.type()}, handler);
 ...
 //返回代理对象
 return proxy;
 }

package feign;
//省略import
public class ReflectiveFeign extends Feign {
 ...
 //内部类：方法解析器
 static final class ParseHandlersByName {
 //同步方法处理器工厂
 private final SynchronousMethodHandler.Factory factory;
...
 //RPC接口元数据解析
public Map<String, MethodHandler> apply(Target key) {
 //解析RPC方法元数据，返回一个方法元数据列表
 List<MethodMetadata> metadata =
contract.parseAndValidatateMetadata(key.type());
 Map<String, MethodHandler> result =
 new LinkedHashMap<String, MethodHandler>();
 //迭代RPC方法元数据列表
 for (MethodMetadata md : metadata) {
 ...
 //通过方法处理器工厂factory创建SynchronousMethodHandler同步方法处理实例
 result.put(md.configKey(),
 factory.create(key, md, buildTemplate, options, decoder, errorDecoder));
 }
 return result;
 }
 }

package feign;
//省略import
final class SynchronousMethodHandler implements MethodHandler {...
 static class Factory {
 public MethodHandler create(
 Target<?> target, MethodMetadata md,
 feign.RequestTemplate.Factory buildTemplateFromArgs,
 Options options, Decoder decoder, ErrorDecoder errorDecoder)
 {
 return new SynchronousMethodHandler(
 target, this.client, this.retryer, this.requestInterceptors,
 this.logger, this.logLevel, md, buildTemplateFromArgs, options,
 decoder, errorDecoder, this.decode404);
 }
...
}

package feign;
//调用处理器工厂接口
public interface InvocationHandlerFactory {
 InvocationHandler create(Target target, Map<Method, MethodHandler> dispatch);
...
 //默认实现类
 static final class Default implements InvocationHandlerFactory {
 //通过内部类FeignInvocationHandler构造一个默认的调用处理器
 @Override
 public InvocationHandler create(Target target, Map<Method, MethodHandler> dispatch) {
 return new ReflectiveFeign.FeignInvocationHandler(target, dispatch);
 }
 }
}

public interface GitHub {
 @RequestLine("GET /repos/{owner}/{repo}/contributors")
 List<Contributor> getContributors(@Param("owner") String owner, @Param("repo") String repository);
 class Contributor {
 String login;
 int contributions;
 }
}