Feign之EnableFeignClients引发的初步探索（一）
背景
（可以略过的废话）前段时间一个朋友在做spring security相关配置时遇到一些问题，请我帮忙解决一些问题，由于我自身并没有使用过security，所以花了一段时间去学习spring security的使用和解析了一下spring security源码。
时至今日，终于可以再次重新开始学习spring cloud相关的内容了~
1.@EnableFeignClients注解的默认配置
1.1 basePackages
扫描@FeignClient注解的包路径，扫描这些包下的所有类，获取被@FeignClient注解的接口，生成代理对象。
1.2 basePackageClasses
这个其实跟上面的很像，就是做一些标记类，然后这些标记类所在的包及其子包里的类都会被扫描。
1.3 defaultConfiguration
这个是对所有feign 客户端进行配置设定使用的。
可以覆写feign client的相关组件定义
feign.codec.Decoder ： 解码器，也就是feign远程调用其他接口获取结果后进行解码成对应的对象
feign.codec.Encoder ： 编码器，feign在远程调用之前，需要先将请求参数进行编码成对应的表单或者json之类的。
feign.Contract ：注解解释器，也就是用来解读@FeignClient标注的interface上的所有注解信息，转化为对应的url和参数。因为web框架比较多。每种注解不一致。feign是Netflix内部使用的，所以他们并没有对springmvc进行支持。后来openFeign中才添加对spring mvc的支持（也就是SpringMvcContract）。
1.4 clients
会基于这几个类和类所在的包进行扫描的。
2.FeignClientsRegistrar之EnableFeignClients导入
FeignClientsRegistrar实现了ImportBeanDefinitionRegistrar接口。
而对于spring来说，实现了ImportBeanDefinitionRegistrar的类，会在org.springframework.context.annotation.ConfigurationClassBeanDefinitionReader#loadBeanDefinitionsFromRegistrars方法中会进行registerBeanDefinitions方法的调用。
所在在FeignClientRegistrar中，我们只需要关注registerBeanDefinitions方法即可。
3.registerBeanDefinitions
@Override
public void registerBeanDefinitions(AnnotationMetadata metadata,
BeanDefinitionRegistry registry) {
// 默认配置注册
registerDefaultConfiguration(metadata, registry);
// 注册FeignClient
registerFeignClients(metadata, registry);
}
3.1 registerDefaultConfiguration 设置默认配置
private void registerDefaultConfiguration(AnnotationMetadata metadata,
BeanDefinitionRegistry registry) {
// 获取EnableFeignClients注解里面的参数信息
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"));
}
}
上面就是从注解中获取配置信息，然后将配置信息注入到spring容器中。
具体如何注入的呢？
首先通过BeanDefinitionBuilder构建一个FeignClientSpecification对象，然后注入上面生成的name和配置信息。
最后通过BeanDefinitionRegistry将由BeanDefinitionBuilder构建出的FeignClientSpecification注入到spring容器中去。
从上面我们知道，如果我们要自定义编码器Encoder，解码器Decoder，注解解释器Contract时，实际上配置是交给FeignClientSpecification管理的。
其实这里可以深究一下FeignClientSpecification 这个东西在哪用了，毕竟我们如果对组件进行了修改或者自定义，那么如何融合到feign的流程中，也是很有比较有探究价值的。
从上图我们可以看到，总共只有6处使用到这个类。其中两处需要关注的地方我已经标注出来。
第一个使用地：
从这个类的名字可以看出，这是个自动装配类，还是Feign直接相关的自动装配。那么这个类所在的包的spring.factories就是我们后面探索的关键所在了。
这里可以看到，FeignClientSpecification 作为bean被Autowired到一个List集合中去了。那么后续的使用只需要关注configurations了。
这里就先不深入了，在后面探索spring.factories时，再深入研究。
第二个使用地：
FeignContext，见名知意，就是Feign的上下文。而上下文是跟作为泛型的FeignClientSpecification 有关的。
显然FeignContext也是有关于FeignClientSpecification 的操作的。
3.2 registerFeignClients 扫描@FeignClient生成代理对象注册到spring容器中
1.获取要扫描的包或者类
2.基于@EnableFeignClient的clients配置
final Set<String> clientClasses = new HashSet<>();
basePackages = new HashSet<>();
for (Class<?> clazz : clients) {
// 获取clients里面配置的class的包名，并加入到包扫描集合中
basePackages.add(ClassUtils.getPackageName(clazz));
// FeignClient类
clientClasses.add(clazz.getCanonicalName());
}
// 测试使用的
AbstractClassTestingTypeFilter filter = new AbstractClassTestingTypeFilter() {
@Override
protected boolean match(ClassMetadata metadata) {
String cleaned = metadata.getClassName().replaceAll("\\$", ".");
return clientClasses.contains(cleaned);
}
};
// 扫描器添加过滤器，一个是测试使用的，一个是基于FeignClient注解的过滤器
scanner.addIncludeFilter(
new AllTypeFilter(Arrays.asList(filter, annotationTypeFilter)));
所以上面其实就是干了一个事情，就是将clients配置的类所在的包路径提取出来，然后再走包扫描。
3.包扫描
for (String basePackage : basePackages) {
// 扫描出包含@FeignClient注解的类
Set<BeanDefinition> candidateComponents = scanner
.findCandidateComponents(basePackage);
for (BeanDefinition candidateComponent : candidateComponents) {
if (candidateComponent instanceof AnnotatedBeanDefinition) {
// 只要注解类bean声明
// verify annotated class is an interface
AnnotatedBeanDefinition beanDefinition = (AnnotatedBeanDefinition) candidateComponent;
AnnotationMetadata annotationMetadata = beanDefinition.getMetadata();
// 判断这个@FeignClient注解的这个class是不是interface
Assert.isTrue(annotationMetadata.isInterface(),
"@FeignClient can only be specified on an interface");
// 获取注解配置的属性信息
Map<String, Object> attributes = annotationMetadata
.getAnnotationAttributes(
FeignClient.class.getCanonicalName());
// 这里是获取客户端名称，用于注册到spring中去
String name = getClientName(attributes);
// 在EnableFeignClient中可以配置全局FeignClient的配置
// 在FeignClient中可以针对单个进行配置
// 这也就是为啥我们在FeignAutoConfiguration中看到FeignClientSpecification
// 是一个集合的原因了。
registerClientConfiguration(registry, name,
attributes.get("configuration"));
// 注册FeignClientFactoryBean到spring容器中
registerFeignClient(registry, annotationMetadata, attributes);
}
}
}
关于ClassPathScanningCandidateComponentProvider 如何扫描到@FeignClient类：
这里插入一个spring的知识点，ClassPathScanningCandidateComponentProvider 这个类就是用来基于路径来扫描合适的组件的。
这其中有个很重要的东西，就是我们如何通过类路径扫描类并获取到自己想要的组件呢？
就是通过ClassPathScanningCandidateComponentProvider 的isCandidateComponent方法来进行判断的。
从上面我们可以看到，我们创建了一个注解类型过滤器，并注入到了ClassPathScanningCandidateComponentProvider 的includeFilters中，然后在扫描的过程中通过通过AnnotationTypeFilter去匹配扫描出来的每个类。
至此，我们就知道如何获取@FeignClient注解的类了。
4.registerFeignClient 注册FeignClient到spring中
其实这里说将FeignClient注册到spring中其实，不是很正确。其实是注册了一个FeignClientFactoryBean到spring容器中去了。
private void registerFeignClient(BeanDefinitionRegistry registry,
AnnotationMetadata annotationMetadata, Map<String, Object> attributes) {
// 1.获取被@FeignClient注解的Interface的名称
String className = annotationMetadata.getClassName();
// 2.创建一个FeignClientFactoryBean的spring bean构建器
BeanDefinitionBuilder definition = BeanDefinitionBuilder
.genericBeanDefinition(FeignClientFactoryBean.class);
// 3.参数校验：主要是关于失败回调的配置
validate(attributes);
// 4.设置FeignClientFactoryBean 的各个参数
definition.addPropertyValue("url", getUrl(attributes));
definition.addPropertyValue("path", getPath(attributes));
// 获取服务名称
String name = getName(attributes);
definition.addPropertyValue("name", name);
String contextId = getContextId(attributes);
definition.addPropertyValue("contextId", contextId);
definition.addPropertyValue("type", className);
// 远程调用404是否解码
definition.addPropertyValue("decode404", attributes.get("decode404"));
// 失败回调
definition.addPropertyValue("fallback", attributes.get("fallback"));
// 失败回调工厂
definition.addPropertyValue("fallbackFactory", attributes.get("fallbackFactory"));
// 设置注入类型，通过类型进行注册（也就是className)
definition.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE);
// 别名
String alias = contextId + "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;
}
// 通过holder，可以通过className，也可以通过别名来获取这个FeignClient
BeanDefinitionHolder holder = new BeanDefinitionHolder(beanDefinition, className,
new String[] { alias });
// 5.注册FeignClientFactoryBean到spring容器中
BeanDefinitionReaderUtils.registerBeanDefinition(holder, registry);
}
从上面我们可以看到，我们可以看到所有关于FeignClient的信息都被封装到了FeignClientFactoryBean中，其实这个时候并没有创建FeignClient对象。
真正的FeignClient对象是在FeignClientFactoryBean里通过getObject()方法创建的。
这里其实又涉及到Spring的一个知识点：
关于FactoryBean对象，在spring初始化bean过程中会通过org.springframework.beans.factory.support.FactoryBeanRegistrySupport#getObjectFromFactoryBean 方法来对实现了FactoryBean的bean进行getObject()方法调用。通过这个getObject就能获取这个工厂bean创建的对象。
5.FeignClientFactoryBean#getObject获取真正的FeignClient
@Override
public Object getObject() throws Exception {
return getTarget();
}
<T> T getTarget() {
FeignContext context = applicationContext.getBean(FeignContext.class);
// 获取feign构建器
Feign.Builder builder = feign(context);
// 一般我们都是通过注册中心+feign来使用，所以基本都是进入下面这个判断
// 然后就返回了。
// 也就是说url我们都不会填的
if (!StringUtils.hasText(this.url)) {
// 这里就是判断是不是基于注册中心进行远程调用
if (!this.name.startsWith("http")) {
url = "http://" + this.name;
}
else {
url = this.name;
}
url += cleanPath();
// 将feign与负载均衡器和限流器进行结合，生成一个对象进行返回
// 这里层层包裹
// Targeter: 有两个实现DefaultTargeter，HystrixTargeter
// 默认为HystrixTargeter，这个其实针对的是HystrixFeign来进行配置的
// 最终这里会创建出一个this.type的代理对象，
// 这个对象持有LoadBalanceFeignClient
// 以及LoadBalancerFeignClient
// 这个里面的东西比较复杂，稍后单独开一篇解析一下
return (T) loadBalance(builder, context, new HardCodedTarget<>(this.type,
this.name, url));
}
// 下面的可以先不看了，一般走不到。
if (StringUtils.hasText(this.url) && !this.url.startsWith("http")) {
this.url = "http://" + this.url;
}
String url = this.url + cleanPath();
Client client = getOptional(context, Client.class);
if (client != null) {
if (client instanceof LoadBalancerFeignClient) {
// not load balancing because we have a url,
// but ribbon is on the classpath, so unwrap
// 指定了url，这个时候就不需要负载均衡了，所以要从负载均衡器中取出发送http请求的
// client
client = ((LoadBalancerFeignClient)client).getDelegate();
}
builder.client(client);
}
Targeter targeter = get(context, Targeter.class);
return (T) targeter.target(this, builder, context, new HardCodedTarget<>(
this.type, this.name, url));
}
基于建造者模式构建Feign
protected Feign.Builder feign(FeignContext context) {
// feign客户端日志工厂
FeignLoggerFactory loggerFactory = get(context, FeignLoggerFactory.class);
Logger logger = loggerFactory.create(this.type);
// @formatter:off
Feign.Builder builder = get(context, Feign.Builder.class)
// required values
.logger(logger) // feign独立日志配置
.encoder(get(context, Encoder.class)) // 编码器
.decoder(get(context, Decoder.class)) // 解码器
.contract(get(context, Contract.class)); // 注解解释器
// @formatter:on
// 设置一下配置
// 1.连接超时时间
// 2.重试次数
// 3.异常解码器
// 4.请求拦截器
// 5.404解码器是否开启设置
// 6. 自定义编码器
// 7. 自定义解码器
// 8. 自定义注解解码器（就是解析注解为url）
configureFeign(context, builder);
return builder;
}
4.小结
单从@EnableFeignClient注解引入，即可看到很多信息。其中最主要的就是Encoder，Decoder，Contract这三个组件。
还有FeignClientFactoryBean如何将Feign构建器，FeignContext，HysterixFeign，LoadBalancerFeignClient一起整合到带有@FeignClient注解的接口的代理类中。
举例说明：
@FeignClient
@RequestMapping("/user")
public interface ServiceAController{
@RequestMapping("/hello")
void sayHello();
}
流程：
1.在启动阶段首先会创建一个FeignClientFactoryBean，它包含ServiceAController的所有信息，其中包含@FeignClient注解的参数，类名等信息
2.FeignClientFactoryBean 会创建一个Feign.Builder ，也就是Feign的构建器，并往里面添加各种配置和组件
3.获取LoadBalancerFeignClient，添加到Feign.Builder中
4.获取HystrixTargeter，如果feign开启了Hystrix，则进行相关失败回调设置。
5.通过Feign.Builder.build()创建一个ReflectiveFeign对象。此时ReflectiveFeign对象中包含LoadBalancerFeignClient，FeignClientFactoryBean，hystrix配置等信息。
6.通过ReflectiveFeign.newInstance方法创建一个ServiceAController的代理对象，其中InvocationHandler为ReflectiveFeign的内部类，它在创建时会带入ReflectiveFeign所携带的内容。
至此，我们就了解了被@FeignClient注解的接口的代理类的实现方式了。
