enablefeignclients 注解_Spring Boot 中 @EnableXXX 注解的驱动逻辑探讨

最新推荐文章于 2024-04-16 07:54:14 发布

weixin_39613744

最新推荐文章于 2024-04-16 07:54:14 发布

阅读量158

点赞数

文章标签： enablefeignclients 注解

点击上方 IT牧场 ，选择 置顶或者星标

技术干货每日送达！

作者 | 温安适

来源 | https://juejin.im/post/5efdd689e51d4534af686ca9

工作中经常用到，如下注解：

@EnableEurekaClient
@EnableFeignClients
@EnableCircuitBreaker
@EnableHystrix

他们都是@Enable开头，各自实现不同的功能，解析这种@Enable的逻辑是什么呢？

@Enable驱动逻辑

找入口

@Enable的模块驱动，依赖于@Import实现。

@Import作用是装载导入类，主要包括@Configuration class,ImportSelector实现类,ImportBeanDefinitionRegistrar实现类。

XML时代，经常是@Import,,一起使用。

(注解配置)中大概率有我们需要找的逻辑。

根据 Spring Framework 2.0引入的可扩展的XML编程机制，XML Schema命名空间需要与Handler建立映射关系。

该关系配置在相对于classpath下的/META-INF/spring.handlers中。

查看ContextNamespaceHandler 源码

public class ContextNamespaceHandler extends NamespaceHandlerSupport {
   @Override
   public void init() {
       //省略其他代码
    registerBeanDefinitionParser("annotation-config", 
                    new AnnotationConfigBeanDefinitionParser());
  }
}复制代码

** 对应AnnotationConfigBeanDefinitionParser这个就是要找的入口**

找核心类

从AnnotationConfigBeanDefinitionParser的parse方法开始一路向下，找到

AnnotationConfigUtils.registerAnnotationConfigProcessors中注册了ConfigurationClassPostProcessor。

ConfigurationClassPostProcessor类注释说明

\1. 用于的引导处理@Configuration类

\2. context:annotation-config/或 context:component-scan/时会注册

否则需要手工编程

\3. ConfigurationClassPostProcessor第一优先级，保证

@Configuration}类中声明@Bean，在其他 BeanFactoryPostProcessor执行之前被注册

扩展

AnnotationConfigApplicationContext中new AnnotationBeanDefinitionReader也调用了 AnnotationConfigUtils .

registerAnnotationConfigProcessors

从类注释中，可以看出ConfigurationClassPostProcessor就是要找的核心类

找核心方法

查看 ConfigurationClassPostProcessor 的层级关系为

Aware系列注入相应资源，Ordered设置优先级，值得关注的就是

postProcessBeanDefinitionRegistry了。

postProcessBeanDefinitionRegistry其内部有2个方法

postProcessBeanDefinitionRegistry在BeanDefinition注册之后，BeanFactoryPostProcessor执行之前，修改或重写BeanDefinition
继承自BeanFactoryPostProcessor的postProcessBeanFactory，BeanDefinition加载之后，Bean实例化之前，重写或添加BeanDefinition，修改BeanFactory

浏览2个方法，都有processConfigBeanDefinitions，从名称可以看出是处理配置类Bean定义

ConfigurationClassPostProcessor#processConfigBeanDefinitions就是要找的核心方法

梳理流程

public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
   List configCandidates = new ArrayList<>();
   String[] candidateNames = registry.getBeanDefinitionNames();for (String beanName : candidateNames) {
      BeanDefinition beanDef = registry.getBeanDefinition(beanName);if (ConfigurationClassUtils.isFullConfigurationClass(beanDef) ||
            ConfigurationClassUtils.isLiteConfigurationClass(beanDef)) {if (logger.isDebugEnabled()) {
            logger.debug("Bean definition has already been processed as a configuration class: " + beanDef);
         }
      }else if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {
         configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));
      }
   }// 没有找到 @Configuration classes 立即返回if (configCandidates.isEmpty()) {return;
   }//根据@Order 值进行排序
   configCandidates.sort((bd1, bd2) -> {int i1 = ConfigurationClassUtils.getOrder(bd1.getBeanDefinition());int i2 = ConfigurationClassUtils.getOrder(bd2.getBeanDefinition());return Integer.compare(i1, i2);
   });//通过封闭的应用程序上下文， 检测任何自定义bean名称生成策略
   supplied through the enclosing application context
   SingletonBeanRegistry sbr = null;if (registry instanceof SingletonBeanRegistry) {
      sbr = (SingletonBeanRegistry) registry;if (!this.localBeanNameGeneratorSet) {
         BeanNameGenerator generator = (BeanNameGenerator) sbr.getSingleton(CONFIGURATION_BEAN_NAME_GENERATOR);if (generator != null) {this.componentScanBeanNameGenerator = generator;this.importBeanNameGenerator = generator;
         }
      }
   }if (this.environment == null) {this.environment = new StandardEnvironment();
   }// 解析@Configuration class
   ConfigurationClassParser parser = new ConfigurationClassParser(this.metadataReaderFactory, this.problemReporter, this.environment,this.resourceLoader, this.componentScanBeanNameGenerator, registry);
   Set candidates = new LinkedHashSet<>(configCandidates);
   Set alreadyParsed = new HashSet<>(configCandidates.size());do {
      parser.parse(candidates);
      parser.validate();
      Set configClasses = new LinkedHashSet<>(parser.getConfigurationClasses());
      configClasses.removeAll(alreadyParsed);// 读ConfigurationClass的信息，创建BeanDefinitionif (this.reader == null) {this.reader = new ConfigurationClassBeanDefinitionReader(
               registry, this.sourceExtractor, this.resourceLoader, this.environment,this.importBeanNameGenerator, parser.getImportRegistry());
      }this.reader.loadBeanDefinitions(configClasses);
      alreadyParsed.addAll(configClasses);
      candidates.clear();if (registry.getBeanDefinitionCount() > candidateNames.length) {
         String[] newCandidateNames = registry.getBeanDefinitionNames();
         Set oldCandidateNames = new HashSet<>(Arrays.asList(candidateNames));
         Set alreadyParsedClasses = new HashSet<>();for (ConfigurationClass configurationClass : alreadyParsed) {
            alreadyParsedClasses.add(configurationClass.getMetadata().getClassName());
         }for (String candidateName : newCandidateNames) {if (!oldCandidateNames.contains(candidateName)) {
               BeanDefinition bd = registry.getBeanDefinition(candidateName);if (ConfigurationClassUtils.checkConfigurationClassCandidate(bd, this.metadataReaderFactory) &&
                     !alreadyParsedClasses.contains(bd.getBeanClassName())) {
                  candidates.add(new BeanDefinitionHolder(bd, candidateName));
               }
            }
         }
         candidateNames = newCandidateNames;
      }
   }while (!candidates.isEmpty());// 将ImportRegistry注册为bean以支持importware@Configuration类if (sbr != null && !sbr.containsSingleton(IMPORT_REGISTRY_BEAN_NAME)) {
      sbr.registerSingleton(IMPORT_REGISTRY_BEAN_NAME, parser.getImportRegistry());
   }if (this.metadataReaderFactory instanceof CachingMetadataReaderFactory) {// Clear cache in externally provided MetadataReaderFactory; this is a no-op// for a shared cache since it'll be cleared by the ApplicationContext.
      ((CachingMetadataReaderFactory) this.metadataReaderFactory).clearCache();
   }
}复制代码

ConfigurationClassPostProcessor#processConfigBeanDefinitions核心如下：

根据@Order 值进行排序
解析@Configuration class 为ConfigurationClass对象
读ConfigurationClass的信息，创建BeanDefinition
将ImportRegistry注册为bean以支持importware@Configuration类

重点关注解析方法

ConfigurationClassParser#parse方法负责解析@Configuration class 为ConfigurationClass对象

查阅其源码如下：

ConfigurationClassParser#doProcessConfigurationClass代码如下：

protected final SourceClass doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass)throws IOException {

   if (configClass.getMetadata().isAnnotated(Component.class.getName())) {
      // Recursively process any member (nested) classes first
      processMemberClasses(configClass, sourceClass);
   }

   // Process any @PropertySource annotations
   for (AnnotationAttributes propertySource : AnnotationConfigUtils.attributesForRepeatable(
         sourceClass.getMetadata(), PropertySources.class,
         org.springframework.context.annotation.PropertySource.class)) {
      if (this.environment instanceof ConfigurableEnvironment) {
         processPropertySource(propertySource);
      }
      else {
         logger.info("Ignoring @PropertySource annotation on [" + sourceClass.getMetadata().getClassName() +
               "]. Reason: Environment must implement ConfigurableEnvironment");
      }
   }

   // Process any @ComponentScan annotations
   Set componentScans = AnnotationConfigUtils.attributesForRepeatable(
         sourceClass.getMetadata(), ComponentScans.class, ComponentScan.class);if (!componentScans.isEmpty() &&
         !this.conditionEvaluator.shouldSkip(sourceClass.getMetadata(), ConfigurationPhase.REGISTER_BEAN)) {for (AnnotationAttributes componentScan : componentScans) {// The config class is annotated with @ComponentScan -> perform the scan immediately
         Set scannedBeanDefinitions =this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());// Check the set of scanned definitions for any further config classes and parse recursively if neededfor (BeanDefinitionHolder holder : scannedBeanDefinitions) {
            BeanDefinition bdCand = holder.getBeanDefinition().getOriginatingBeanDefinition();if (bdCand == null) {
               bdCand = holder.getBeanDefinition();
            }if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) {
               parse(bdCand.getBeanClassName(), holder.getBeanName());
            }
         }
      }
   }// Process any @Import annotations
   processImports(configClass, sourceClass, getImports(sourceClass), true);// Process any @ImportResource annotations
   AnnotationAttributes importResource =
         AnnotationConfigUtils.attributesFor(sourceClass.getMetadata(), ImportResource.class);if (importResource != null) {
      String[] resources = importResource.getStringArray("locations");
      Class extends BeanDefinitionReader> readerClass = importResource.getClass("reader");for (String resource : resources) {
         String resolvedResource = this.environment.resolveRequiredPlaceholders(resource);
         configClass.addImportedResource(resolvedResource, readerClass);
      }
   }// Process individual @Bean methods
   Set beanMethods = retrieveBeanMethodMetadata(sourceClass);for (MethodMetadata methodMetadata : beanMethods) {
      configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
   }// Process default methods on interfaces
   processInterfaces(configClass, sourceClass);// Process superclass, if anyif (sourceClass.getMetadata().hasSuperClass()) {
      String superclass = sourceClass.getMetadata().getSuperClassName();if (superclass != null && !superclass.startsWith("java") &&
            !this.knownSuperclasses.containsKey(superclass)) {this.knownSuperclasses.put(superclass, configClass);// Superclass found, return its annotation metadata and recursereturn sourceClass.getSuperClass();
      }
   }// No superclass -> processing is completereturn null;
}复制代码

ConfigurationClassParser#doProcessConfigurationClass(ConfigurationClass,AnnatationMetatdata)将@PropertySource， @ComponentScan， @Import，@ImportResource，@Bean等一起处理了。

看到这里基本逻辑已经理清了，但是有一个疑问

@Configuration中的@Bean没有其他特殊处理吗？

浏览代码解决疑问

![img](data:image/svg+xml;utf8,)

从上边浏览的代码可以看到完全模式，会被AOP增强

那什么是完全模式呢？在ConfigurationClassUtils找到如下方法：

public class ConfigurationClassUtils{
//省略其他方法
public static boolean isFullConfigurationCandidate(AnnotationMetadata metadata) {
   return metadata.isAnnotated(Configuration.class.getName());
}
}复制代码

即 @Configuration class是完全模式，@Component，@Bean是轻量级模式

那AOP增强了作用是什么呢？查看 ConfigurationClassEnhancer 的类注释如下：

/**

* Enhances {@link

Configuration

} classes by generating a CGLIB subclass which

* interacts with the Spring container to respect bean scoping semantics for

* {@code @Bean} methods. Each such {@code @Bean} method will be overridden in

* the generated subclass, only delegating to the actual {@code @Bean} method

* implementation if the container actually requests the construction of a new

* instance. Otherwise, a call to such an {@code @Bean} method serves as a

* reference back to the container, obtaining the corresponding bean by name.

* @author Chris Beams

* @author Juergen Hoeller

* @since 3.0

* @see #enhance

* @see

ConfigurationClassPostProcessor

*/

class ConfigurationClassEnhancer {

大概意思如下：

通过CGLIB增强@Configuration class。

每个@Bean方法会生成子类。

首次被调用时，@Bean方法会被执行用于创建bean实例；

再次被调用时，不会再执行创建bean实例，而是根据bean名称返回首次该方法被执行时创建的bean实例。

总结

1.ConfigurationClassPostProcessor负责筛选@Component Class、@Configuration Class以及@Bean定义的Bean，**

2.ConfigurationClassParser从候选的Bean定义中解析出ConfigurationClass集合，随后被3.ConfigurationClassBeanDefinitionReader转换为BeanDefinition

4.ConfigurationClassParser的解析顺序，

@PropertySource->@ComponentScan->@Import->@ImportResource->@Bean->接口的默认方法->处理父类

5.@Configuration class是完全模式，@Component，@Bean是轻量级模式

6.CGLIB增强@Configuration class。每个@Bean方法会生成子类。

首次被调用时，@Bean方法会被执行用于创建bean实例；

再次被调用时，不会再执行创建bean实例，而是根据bean名称返回首次该方法被执行时创建的bean实例。

干货分享

最近将个人学习笔记整理成册，使用PDF分享。关注我，回复如下代码，即可获得百度盘地址，无套路领取！

•001：《Java并发与高并发解决方案》学习笔记；•002：《深入JVM内核——原理、诊断与优化》学习笔记；•003：《Java面试宝典》•004：《Docker开源书》•005：《Kubernetes开源书》•006：《DDD速成(领域驱动设计速成)》•007：全部•008：加技术群讨论

近期热文

•LinkedBlockingQueue vs ConcurrentLinkedQueue•解读Java 8 中为并发而生的 ConcurrentHashMap•Redis性能监控指标汇总•最全的DevOps工具集合，再也不怕选型了！•微服务架构下，解决数据库跨库查询的一些思路•聊聊大厂面试官必问的 MySQL 锁机制

关注我

喜欢就点个"在看"呗^_^

weixin_39613744

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
enablefeignclients 注解_Spring Boot 中 @EnableXXX 注解的驱动逻辑探讨

点击上方IT牧场，选择置顶或者星标技术干货每日送达！作者 |温安适来源 |https://juejin.im/post/5efdd689e51d4534af686ca9工作中经常用到，如下注解：@EnableEurekaClient@EnableFeignClients@EnableCircuitBreaker@EnableHystrix他们都是@Enable开头，各自实现不同...
复制链接

扫一扫