一. 核心注解
@EnableFeignClients
String[] basePackages 等同 String[] value()
指定要扫描的包路径，一般用于当项目引用其他的jar，通过指定此属性来扫描jar包内的@FeignClient。例如：@EnableFeignClients(basePackages = {"com.xxx.service", "com.xxx.service2"})
Class<?>[] clients()
指定加载的带有@FeignClient的类，主动指定后，将不会在classpath下扫描。例如：@EnableFeignClients(clients = {Service1.class, Service2.class})
Class<?>[] defaultConfiguration()
指定全局的configuration，使用@Configuration进行配置。例如：@EnableFeignClients(defaultConfiguration = {Configuration1.class, Configuration1.class})
@FeignClient
String value() 等同 String name()
给当前feignClient设置value
String contextId()
会顶替作为feignClient的name
String qualifier()
等同给feignClient设置注解@Qualifier
String path()
指定统一的调用前缀
String url()
设置调用的绝对url或者主机名
boolean decode404() default false
是否来解码404，而不是抛出FeignExceptions，默认false
Class<?>[] configuration()
定义feignClient的配置类，可重写内部的bean来修改feignClient的调用实现，如feign.codec.Decoder、feign.codec.Encoder、feign.Contract
Class<?> fallback() default void.class;
Class<?> fallbackFactory() default void.class;
指定fallback时的处理类，必须是一个spring的bean。当调用失败时，会调用相同的fallback实现类的方法。
boolean primary() default true;
指定为primary的bean
二. 源码分析
首先，我们想要使用feign，需要在SpringApplication的启动类上加入@EnableFeignClients，看下这个注解的定义。
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
@Import(FeignClientsRegistrar.class)
public @interface EnableFeignClients { ... }
可以看到有@Import(FeignClientsRegistrar.class)，在分析一下FeignClientsRegistrar，是ImportBeanDefinitionRegistrar的实现类。
class FeignClientsRegistrar implements ImportBeanDefinitionRegistrar,
ResourceLoaderAware, EnvironmentAware {...}
需要重写一个关键的方法：registerBeanDefinitions
AnnotationMetadata 是注解的元信息，包含了当前类的所有注解信息
BeanDefinitionRegistry 用于注册bean的registry，详细参考BeanDefinitionRegistry-源码分析
1. registerDefaultConfiguration 实现分析
@Override
public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
registerDefaultConfiguration(metadata, registry);
registerFeignClients(metadata, registry);
}
该方法做了两件事，注册defaultConfiguration和注册所有的加了@FeignClient的bean。其中defaultConfiguration也就是在最开始提到的EnableFeignClients的一个属性。
private void registerDefaultConfiguration(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
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"));
}
}
首先通过注解元信息中判断EnableFeignClients是否有属性defaultConfiguration(可以值为null，但一定有这个属性)，再设置name，hasEnclosingClass是判断当前metadata的Class是不是一个内部/嵌套类或是在方法中的local class。
一般来说，这里的name = default.com.xxx.XXXApplication (default.启动类名)。
接着调用registerClientConfiguration。
private void registerClientConfiguration(BeanDefinitionRegistry registry, Object name, Object configuration) {
BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(FeignClientSpecification.class);
builder.addConstructorArgValue(name);
builder.addConstructorArgValue(configuration);
registry.registerBeanDefinition(
name + "." + FeignClientSpecification.class.getSimpleName(),
builder.getBeanDefinition());
}
public static BeanDefinitionBuilder genericBeanDefinition(Class<?> beanClass) {
BeanDefinitionBuilder builder = new BeanDefinitionBuilder(new GenericBeanDefinition());
builder.beanDefinition.setBeanClass(beanClass);
return builder;
}
先定义了BeanDefinitionBuilder，也就是专门用于构造BeanDefinition的构造器，将一个普通的类定义为BeanDefinition。
这里将FeignClientSpecification定义成BeanDefinition，并设置了构造方法的两个参数值，name和configuration。最后将这个beanDefinition注册到spring容器中。注册名：name = default.com.xxx.XXXApplication.FeignClientSpecification
至此，FeignClientsRegistrar.registerBeanDefinitions的第一个方法执行完成，接下来看看registerFeignClients的实现。
2. registerFeignClients 实现分析
public void registerFeignClients(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
ClassPathScanningCandidateComponentProvider scanner = getScanner();
scanner.setResourceLoader(this.resourceLoader);
Set<String> basePackages;
Map<String, Object> attrs = metadata
.getAnnotationAttributes(EnableFeignClients.class.getName());
AnnotationTypeFilter annotationTypeFilter = new AnnotationTypeFilter(
FeignClient.class);
final Class<?>[] clients = attrs == null ? null
: (Class<?>[]) attrs.get("clients");
if (clients == null || clients.length == 0) {
scanner.addIncludeFilter(annotationTypeFilter);
basePackages = getBasePackages(metadata);
}
else {
final Set<String> clientClasses = new HashSet<>();
basePackages = new HashSet<>();
for (Class<?> clazz : clients) {
basePackages.add(ClassUtils.getPackageName(clazz));
clientClasses.add(clazz.getCanonicalName());
}
AbstractClassTestingTypeFilter filter = new AbstractClassTestingTypeFilter() {
@Override
protected boolean match(ClassMetadata metadata) {
String cleaned = metadata.getClassName().replaceAll("\\$", ".");
return clientClasses.contains(cleaned);
}
};
scanner.addIncludeFilter(
new AllTypeFilter(Arrays.asList(filter, annotationTypeFilter)));
}
for (String basePackage : basePackages) {
Set<BeanDefinition> candidateComponents = scanner
.findCandidateComponents(basePackage);
for (BeanDefinition candidateComponent : candidateComponents) {
if (candidateComponent instanceof AnnotatedBeanDefinition) {
// verify annotated class is an interface
AnnotatedBeanDefinition beanDefinition = (AnnotatedBeanDefinition) candidateComponent;
AnnotationMetadata annotationMetadata = beanDefinition.getMetadata();
Assert.isTrue(annotationMetadata.isInterface(),
"@FeignClient can only be specified on an interface");
Map<String, Object> attributes = annotationMetadata
.getAnnotationAttributes(
FeignClient.class.getCanonicalName());
String name = getClientName(attributes);
registerClientConfiguration(registry, name,
attributes.get("configuration"));
registerFeignClient(registry, annotationMetadata, attributes);
}
}
}
}
首先获取了ClassPathScanningCandidateComponentProvider，并设置了资源加载的路径。ClassPathScanningCandidateComponentProvider看名字也大概知道这个类用于在classPath下扫描满足一定条件的class类。
整个方法的上半部分比较容易理解，就是在判断是否在@EnableFeignClients中指定了clients的属性，本文最初也写到，如果指定了clients，则只会加载指定的几个class，同时还需要这几个class有@FeignClient的注解。如果没有指定，则设置basePackages为启动类所在的包路径，扫描当前包和所有子包，即
com/xxx/**/*.class
筛选条件最终会封装成TypeFilter，添加到scanner中，后续扫描出的所有class将根据设置的条件进行过滤。
后半部分则是根据basePackages来扫描指定路径下的class文件，将过滤后的BeanDefinition进行注册。
这里有一个关键方法：Set<BeanDefinition> candidateComponents = scanner.findCandidateComponents(basePackage); 即扫描指定路径下的所有class，同时按照要求进行过滤，过滤条件是且的关系。
private Set<BeanDefinition> scanCandidateComponents(String basePackage) {
Set<BeanDefinition> candidates = new LinkedHashSet<>();
try {
String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
resolveBasePackage(basePackage) + '/' + this.resourcePattern;
Resource[] resources = getResourcePatternResolver().getResources(packageSearchPath);
boolean traceEnabled = logger.isTraceEnabled();
boolean debugEnabled = logger.isDebugEnabled();
for (Resource resource : resources) {
if (resource.isReadable()) {
try {
MetadataReader metadataReader = getMetadataReaderFactory().getMetadataReader(resource);
if (isCandidateComponent(metadataReader)) {
ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);
sbd.setResource(resource);
sbd.setSource(resource);
if (isCandidateComponent(sbd)) {
candidates.add(sbd);
}
//省略下面一系列log输出的判断
}
catch (IOException ex) {
throw new BeanDefinitionStoreException("I/O failure during classpath scanning", ex);
}
return candidates;
}
首先根据路径扫描.class的字节码文件，resources数组即为扫描结果的类资源文件，读取文件流封装成MetadataReader。
isCandidateComponent 这个方法则是将扫描结果进行过滤，将不符合条件的结果去掉。
protected boolean isCandidateComponent(MetadataReader metadataReader) throws IOException {
for (TypeFilter tf : this.excludeFilters) {
if (tf.match(metadataReader, getMetadataReaderFactory())) {
return false;
}
}
for (TypeFilter tf : this.includeFilters) {
if (tf.match(metadataReader, getMetadataReaderFactory())) {
return isConditionMatch(metadataReader);
}
}
return false;
}
比如我们这里添加了includeFilters的过滤条件：
- 要求包含@FeignClient的注解
- 启动参数profiles里指定了local (这一条并不作为filter，而是一种condition)
这里tf.match会根据TypeFilter的match方法进行判断，过滤@FeignClient的条件，再通过isConditionMatch来判断是否满足condition的条件。
假如我们其中的一个FeignClient指定为@Profile("!local")，也会被上述条件过滤掉。
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Conditional(ProfileCondition.class)
public @interface Profile {
@Profile 其实是一种@Conditional,对应的实现类是ProfileCondition.class
一系列的条件都满足后，这些metadataReader会被封装成ScannedGenericBeanDefinition返回，findCandidateComponents执行完成。
获得BeanDefinition的Set集合后，遍历每一个对象，注册ClientConfiguration和FeignClient。
最后的registerFeignClient方法就是将每个feignClient的类定义成FeignClientFactoryBean，由BeanDefinitionBuilder进行属性填充，最后封装成BeanDefinition进行注册。BeanDefinition的beanName是contextId或name + “FeignClient”
private void registerFeignClient(BeanDefinitionRegistry registry,
AnnotationMetadata annotationMetadata, Map<String, Object> attributes) {
String className = annotationMetadata.getClassName();
BeanDefinitionBuilder definition = BeanDefinitionBuilder
.genericBeanDefinition(FeignClientFactoryBean.class);
validate(attributes);
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);
definition.addPropertyValue("decode404", attributes.get("decode404"));
definition.addPropertyValue("fallback", attributes.get("fallback"));
definition.addPropertyValue("fallbackFactory", attributes.get("fallbackFactory"));
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;
}
BeanDefinitionHolder holder = new BeanDefinitionHolder(beanDefinition, className,
new String[] { alias });
BeanDefinitionReaderUtils.registerBeanDefinition(holder, registry);
}
三. 总结
至此，关于@EnableFeignClients的启动加载过程就分析完成。
总结一下：
- 注册默认的defaultConfiguration
- 根据是否指定了client决定要扫描的类范围
- 将扫描的结果进行过滤
- 将结果列表封装FeignClientFactoryBean的BeanDefinition注册到spring容器中。
四. 后续
下一篇将分析FeignClientFactoryBean如何实现feign的调用。
