Spring源码之@Configuration注解解析类ConfigurationClassPostProcessor

1.前言

Spring注解开发中，我们只需求要类上加上@Configuration注解，然后在类中的方法上面加上@Bean注解即可完成Spring Bean组件的注册。相较于之前的xml配置文件定义注册组件简化了非常多。那么Spring底层是如何处理@Configuration注解来完成Spring组件的注册，下面通过源码一步一步进行分析。

2.准备工作

Spring版本：2.2.13.RELEASE

源码中涉及的类：

ConfigurationClassPostProcessor
ConfigurationClassParser
ConfigurationClass
BeanMethod
ConfigurationClassBeanDefinitionReader
ConfigurationClassEnhancer
ConfigurationClassUtils

说明：文中统一将被@Configuration注解标注的类称为配置类

3.涉及相关类说明

ConfigurationClassPostProcessor

　　配置类的后知处理器，其中实现了BeanDefinitionRegistryPostProcessor接口，可以拿到BeanDefinitionRegistry对象手动注册组件，也是整个解析流程的入口

ConfigurationClassParser

　　配置类解析器，解析配置类，封装成一个个的ConfigurationClass对象

ConfigurationClass

　　配置类经解析后的实体对象

BeanMethod

　　被@Bean注解标注的方法解析后的实体对象

ConfigurationClassBeanDefinitionReader

　　用于读取注册配置类中定义的组件

ConfigurationClassEnhancer

　　对配置类进行代理增强的角色类

ConfigurationClassUtils

　　配置类解析相关的工具类

4.源码流程分析

ConfigurationClassPostProcessor作为入口类，类的层次结构入上图

我们只需要关心BeanDefinitionRegistryPostProcessor和BeanFactoryPostProcessor两个接口的回调方法BeanFactoryPostProcessor和postProcessBeanFactory。两个方法的具体实现如下，可以看到两个方法的内部都调用了processConfigBeanDefinitions方法

下面针对此方法进行分析

 1 public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
 2         int registryId = System.identityHashCode(registry);
 3         if (this.registriesPostProcessed.contains(registryId)) {
 4             throw new IllegalStateException(
 5                     "postProcessBeanDefinitionRegistry already called on this post-processor against " + registry);
 6         }
 7         if (this.factoriesPostProcessed.contains(registryId)) {
 8             throw new IllegalStateException(
 9                     "postProcessBeanFactory already called on this post-processor against " + registry);
10         }
11         this.registriesPostProcessed.add(registryId);
12 
13         processConfigBeanDefinitions(registry);
14     }
15 
16 public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
17         int factoryId = System.identityHashCode(beanFactory);
18         if (this.factoriesPostProcessed.contains(factoryId)) {
19             throw new IllegalStateException(
20                     "postProcessBeanFactory already called on this post-processor against " + beanFactory);
21         }
22         this.factoriesPostProcessed.add(factoryId);
23         if (!this.registriesPostProcessed.contains(factoryId)) {
24             // BeanDefinitionRegistryPostProcessor hook apparently not supported...
25             // Simply call processConfigurationClasses lazily at this point then.
26             processConfigBeanDefinitions((BeanDefinitionRegistry) beanFactory);
27         }
28 
29         enhanceConfigurationClasses(beanFactory);
30         beanFactory.addBeanPostProcessor(new ImportAwareBeanPostProcessor(beanFactory));
31     }

4.1.ConfigurationClassPostProcessor.processConfigBeanDefinitions方法分析

public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
        // 待处理配置类集合
        List<BeanDefinitionHolder> configCandidates = new ArrayList<>();
        // 获取所有组件名称
        String[] candidateNames = registry.getBeanDefinitionNames();

        for (String beanName : candidateNames) {
            // 获取组件定义信息
            BeanDefinition beanDef = registry.getBeanDefinition(beanName);
            // 判断组件是否已经被作为一个配置类处理过
            if (beanDef.getAttribute(ConfigurationClassUtils.CONFIGURATION_CLASS_ATTRIBUTE) != null) {
                if (logger.isDebugEnabled()) {
                    logger.debug("Bean definition has already been processed as a configuration class: " + beanDef);
                }
            }
            // 判断组件是否为候选的配置类，如果是则加入待处理集合。checkConfigurationClassCandidate下面具体分析
            else if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {
                configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));
            }
        }

        // 如果待处理配置类为空，直接返回
        if (configCandidates.isEmpty()) {
            return;
        }

        // 对所有配置类进行排序
        configCandidates.sort((bd1, bd2) -> {
            int i1 = ConfigurationClassUtils.getOrder(bd1.getBeanDefinition());
            int i2 = ConfigurationClassUtils.getOrder(bd2.getBeanDefinition());
            return Integer.compare(i1, i2);
        });
       // 初始化配置类解析器
        ConfigurationClassParser parser = new ConfigurationClassParser(
                this.metadataReaderFactory, this.problemReporter, this.environment,
                this.resourceLoader, this.componentScanBeanNameGenerator, registry);

        Set<BeanDefinitionHolder> candidates = new LinkedHashSet<>(configCandidates);do {
            // 解析每一个配置类
            parser.parse(candidates);
            // 验证每一个配置类
            parser.validate();
            // 获取解析后的所有配置类实体ConfigurationClass
            Set<ConfigurationClass> configClasses = new LinkedHashSet<>(parser.getConfigurationClasses());
            // 初始化配置类中定义的组件读取者
            if (this.reader == null) {
                this.reader = new ConfigurationClassBeanDefinitionReader(
                        registry, this.sourceExtractor, this.resourceLoader, this.environment,
                        this.importBeanNameGenerator, parser.getImportRegistry());
            }

            // 读取配置类中所有被@Bean注解标注的方法，并将每个方法封装成BeanDefinition注册到容器中
            this.reader.loadBeanDefinitions(configClasses);
        }
        while (!candidates.isEmpty());
    }

4.2.ConfigurationClassUtils.checkConfigurationClassCandidate方法分析

public static boolean checkConfigurationClassCandidate(
            BeanDefinition beanDef, MetadataReaderFactory metadataReaderFactory) {

        // 获取组件的全限定类名
        String className = beanDef.getBeanClassName();
        if (className == null || beanDef.getFactoryMethodName() != null) {
            return false;
        }

        // 下面这一大段代码都是在获取组件类的元数据信息AnnotationMetadata，这里不详细介绍
        AnnotationMetadata metadata;
        if (beanDef instanceof AnnotatedBeanDefinition &&
                className.equals(((AnnotatedBeanDefinition) beanDef).getMetadata().getClassName())) {
            // Can reuse the pre-parsed metadata from the given BeanDefinition...
            metadata = ((AnnotatedBeanDefinition) beanDef).getMetadata();
        }
        else if (beanDef instanceof AbstractBeanDefinition && ((AbstractBeanDefinition) beanDef).hasBeanClass()) {
            // Check already loaded Class if present...
            // since we possibly can't even load the class file for this Class.
            Class<?> beanClass = ((AbstractBeanDefinition) beanDef).getBeanClass();
            if (BeanFactoryPostProcessor.class.isAssignableFrom(beanClass) ||
                    BeanPostProcessor.class.isAssignableFrom(beanClass) ||
                    AopInfrastructureBean.class.isAssignableFrom(beanClass) ||
                    EventListenerFactory.class.isAssignableFrom(beanClass)) {
                return false;
            }
            metadata = AnnotationMetadata.introspect(beanClass);
        }
        else {
            try {
                MetadataReader metadataReader = metadataReaderFactory.getMetadataReader(className);
                metadata = metadataReader.getAnnotationMetadata();
            }
            catch (IOException ex) {
                if (logger.isDebugEnabled()) {
                    logger.debug("Could not find class file for introspecting configuration annotations: " +
                            className, ex);
                }
                return false;
            }
        }

        // 获取组件类的@Configuration注解属性，如果组件类上不存在@Configuration注解，则返回空
        Map<String, Object> config = metadata.getAnnotationAttributes(Configuration.class.getName());
        // 如果存在，并且proxyBeanMethods属性的值为true，则标注当前配置类为full，即需要代理增强，为一个代理类
        if (config != null && !Boolean.FALSE.equals(config.get("proxyBeanMethods"))) {
            beanDef.setAttribute(CONFIGURATION_CLASS_ATTRIBUTE, CONFIGURATION_CLASS_FULL);
        }
        // 如果存在，并且isConfigurationCandidate返回true，则标注当前配置类为lite，即不需要代理增强，为一个普通类
        else if (config != null || isConfigurationCandidate(metadata)) {
            beanDef.setAttribute(CONFIGURATION_CLASS_ATTRIBUTE, CONFIGURATION_CLASS_LITE);
        }
        // 组件类不存在@Configuration注解，直接返回false
        else {
            return false;
        }

        // 获取配置类的排序顺序，设置到组件定义属性中
        Integer order = getOrder(metadata);
        if (order != null) {
            beanDef.setAttribute(ORDER_ATTRIBUTE, order);
        }

        return true;
    }

public static boolean isConfigurationCandidate(AnnotationMetadata metadata) {
   // 如果配置类为一个接口，则不处理
   if (metadata.isInterface()) {
      return false;
   }

   /*
    * 判断配置类是否存在（@Component，ComponentScan，@Import，ImportResource）注解
    * 如果存在上述任意一个注解，则返回true
    */
   for (String indicator : candidateIndicators) {
      if (metadata.isAnnotated(indicator)) {
         return true;
      }
   }

   // 如果上述四个注解都不存在，则判断配置类中是否存在被@Bean标注的方法
   return hasBeanMethods(metadata);
}

4.3.ConfigurationClassParser.parse方法分析

public void parse(Set<BeanDefinitionHolder> configCandidates) {
        for (BeanDefinitionHolder holder : configCandidates) {
            // 循环每一个配置类的定义信息，然后调用parse方法，下面三个parse重载方法逻辑一样
            BeanDefinition bd = holder.getBeanDefinition();
            try {
                if (bd instanceof AnnotatedBeanDefinition) {
                    parse(((AnnotatedBeanDefinition) bd).getMetadata(), holder.getBeanName());
                }
                else if (bd instanceof AbstractBeanDefinition && ((AbstractBeanDefinition) bd).hasBeanClass()) {
                    parse(((AbstractBeanDefinition) bd).getBeanClass(), holder.getBeanName());
                }
                else {
                    parse(bd.getBeanClassName(), holder.getBeanName());
                }
            }
            catch (BeanDefinitionStoreException ex) {
                throw ex;
            }
            catch (Throwable ex) {
                throw new BeanDefinitionStoreException(
                        "Failed to parse configuration class [" + bd.getBeanClassName() + "]", ex);
            }
        }

        this.deferredImportSelectorHandler.process();
    }

    protected final void parse(@Nullable String className, String beanName) throws IOException {
        Assert.notNull(className, "No bean class name for configuration class bean definition");
        MetadataReader reader = this.metadataReaderFactory.getMetadataReader(className);
        // 将配置类封装成ConfigurationClass后调用processConfigurationClass
        processConfigurationClass(new ConfigurationClass(reader, beanName), DEFAULT_EXCLUSION_FILTER);
    }

    protected final void parse(Class<?> clazz, String beanName) throws IOException {
        // 将配置类封装成ConfigurationClass后调用processConfigurationClass
        processConfigurationClass(new ConfigurationClass(clazz, beanName), DEFAULT_EXCLUSION_FILTER);
    }

    protected final void parse(AnnotationMetadata metadata, String beanName) throws IOException {
        // 将配置类封装成ConfigurationClass后调用processConfigurationClass
        processConfigurationClass(new ConfigurationClass(metadata, beanName), DEFAULT_EXCLUSION_FILTER);
    }

4.4.ConfigurationClassParser.processConfigurationClass方法分析

protected void processConfigurationClass(ConfigurationClass configClass, Predicate<String> filter) throws IOException {
        // 判断配置类是否有@Condition注解，如果有的话根据条件判断是否成立
        if (this.conditionEvaluator.shouldSkip(configClass.getMetadata(), ConfigurationPhase.PARSE_CONFIGURATION)) {
            return;
        }
　　　　 // 递归处理配置类和其所有父类
        SourceClass sourceClass = asSourceClass(configClass, filter);
        do {
            sourceClass = doProcessConfigurationClass(configClass, sourceClass, filter);
        }
        while (sourceClass != null);
        
    }

4.5.ConfigurationClassParser.doProcessConfigurationClass方法分析

protected final SourceClass doProcessConfigurationClass(
            ConfigurationClass configClass, SourceClass sourceClass, Predicate<String> filter)
            throws IOException {

        // 判断配置类上的注解层次中是否包含@Component注解，如果包含则递归获取内部类进行处理
        if (configClass.getMetadata().isAnnotated(Component.class.getName())) {
            // 递归处理所有的内部类
            processMemberClasses(configClass, sourceClass, filter);
        }

        // 处理配置类上注解层次中的所有@PropertySource注解
        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");
            }
        }

        // 处理配置类上注解层次中的所有@ComponentScan注解
        Set<AnnotationAttributes> 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<BeanDefinitionHolder> scannedBeanDefinitions =
                        this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());
                // Check the set of scanned definitions for any further config classes and parse recursively if needed
                for (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());
                    }
                }
            }
        }

        // 处理配置类上注解层次中的所有@Import注解
        processImports(configClass, sourceClass, getImports(sourceClass), filter, true);

        // 处理配置类上注解层次中的所有@ImportResource注解
        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);
            }
        }

        // 处理配置类中的所有标注了@Bean注解的方法，并封装成BeanMethod添加到配置类的实体ConfigurationClass中
        Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(sourceClass);
        for (MethodMetadata methodMetadata : beanMethods) {
            configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
        }

        // Process default methods on interfaces
        processInterfaces(configClass, sourceClass);

        // 如果有父类，则返回父类
        if (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 recurse
                return sourceClass.getSuperClass();
            }
        }

        // 没有父类，返回null
        return null;
    }

4.6.ConfigurationClassBeanDefinitionReader.loadBeanDefinitions方法分析

public void loadBeanDefinitions(Set<ConfigurationClass> configurationModel) {
        // 可跟踪记录的条件评估者，也就是解析@Conditon注解的作用，并且可以记录满足@Condition和不满足@Condition的原因
        TrackedConditionEvaluator trackedConditionEvaluator = new TrackedConditionEvaluator();
        for (ConfigurationClass configClass : configurationModel) {
            // 从配置类中加载组件定义信息
            loadBeanDefinitionsForConfigurationClass(configClass, trackedConditionEvaluator);
        }
}

   
private void loadBeanDefinitionsForConfigurationClass(ConfigurationClass configClass, TrackedConditionEvaluator trackedConditionEvaluator) {

        // 处理配置类上的@Condition注解
        if (trackedConditionEvaluator.shouldSkip(configClass)) {
            String beanName = configClass.getBeanName();
            if (StringUtils.hasLength(beanName) && this.registry.containsBeanDefinition(beanName)) {
                this.registry.removeBeanDefinition(beanName);
            }
            this.importRegistry.removeImportingClass(configClass.getMetadata().getClassName());
            return;
        }

        // 判断当前配置类是否是通过@Import注解导入的
        if (configClass.isImported()) {
            registerBeanDefinitionForImportedConfigurationClass(configClass);
        }
        // 获取配置类中的所有@Bean注解标注的方法
        for (BeanMethod beanMethod : configClass.getBeanMethods()) {
            // 从@Bean标注的方法加载组件定义信息
            loadBeanDefinitionsForBeanMethod(beanMethod);
        }

        loadBeanDefinitionsFromImportedResources(configClass.getImportedResources());
        loadBeanDefinitionsFromRegistrars(configClass.getImportBeanDefinitionRegistrars());
}

4.7.ConfigurationClassBeanDefinitionReader.loadBeanDefinitionsForBeanMethod方法分析

private void loadBeanDefinitionsForBeanMethod(BeanMethod beanMethod) {
        // 获取配置类信息
        ConfigurationClass configClass = beanMethod.getConfigurationClass();
        MethodMetadata metadata = beanMethod.getMetadata();
        // 获取方法名
        String methodName = metadata.getMethodName();

        // 处理方法上的@Conditional注解
        if (this.conditionEvaluator.shouldSkip(metadata, ConfigurationPhase.REGISTER_BEAN)) {
            configClass.skippedBeanMethods.add(methodName);
            return;
        }
        if (configClass.skippedBeanMethods.contains(methodName)) {
            return;
        }

        // 获取方法上@Bean注解的属性信息
        AnnotationAttributes bean = AnnotationConfigUtils.attributesFor(metadata, Bean.class);
        Assert.state(bean != null, "No @Bean annotation attributes");

        // 处理@Bean注解的name属性，如果此属性为空，则组件的名称为方法名
        List<String> names = new ArrayList<>(Arrays.asList(bean.getStringArray("name")));
        String beanName = (!names.isEmpty() ? names.remove(0) : methodName);

        // 将name属性的值注册为此组件的别名
        for (String alias : names) {
            this.registry.registerAlias(beanName, alias);
        }
　　　　 // 将@Bean方法封装成BeanDefinition
        ConfigurationClassBeanDefinition beanDef = new ConfigurationClassBeanDefinition(configClass, metadata, beanName);
        beanDef.setSource(this.sourceExtractor.extractSource(metadata, configClass.getResource()));

        // 如果@Bean方法为静态方法
        if (metadata.isStatic()) {
            // static @Bean method
            if (configClass.getMetadata() instanceof StandardAnnotationMetadata) {
                beanDef.setBeanClass(((StandardAnnotationMetadata) configClass.getMetadata()).getIntrospectedClass());
            }
            else {
                beanDef.setBeanClassName(configClass.getMetadata().getClassName());
            }
            beanDef.setUniqueFactoryMethodName(methodName);
        }
        // 如果@Bean方法为实例方法
        else {
            beanDef.setFactoryBeanName(configClass.getBeanName());
            beanDef.setUniqueFactoryMethodName(methodName);
        }

        beanDef.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_CONSTRUCTOR);
        beanDef.setAttribute(org.springframework.beans.factory.annotation.RequiredAnnotationBeanPostProcessor.
                SKIP_REQUIRED_CHECK_ATTRIBUTE, Boolean.TRUE);

        /*
            处理@Bean方法上的公共注解(@Lazy,@Primary,@DependsOn,@Role,@Description)
            这里稍微解释一下这几个注解
                @Lazy：组件是否为懒加载，组件的创建可以在项目启动Spring容器刷新的时候创建，也可以在第一次获取组件的时候(BeanFactory.getBean)创建。后者则为懒加载
                @Primary：如果一个接口在容器中有多个实现类的时候，在使用@Autowired依赖注入的时候优先使用被@Primary注解标注的实现类
                @DependsOn：创建此组件时依赖的其他组件，在创建此组件时，先创建完成依赖的其他组件
                @Role：组件的角色，Spring框架底层使用。开发者一般不用
                @Description：可以为组件定义添加描述，相当于一个描述信息，仅此而已
        */
        AnnotationConfigUtils.processCommonDefinitionAnnotations(beanDef, metadata);

        // 下面一段都是处理@Bean注解的各个属性
        Autowire autowire = bean.getEnum("autowire");
        if (autowire.isAutowire()) {
            beanDef.setAutowireMode(autowire.value());
        }

        boolean autowireCandidate = bean.getBoolean("autowireCandidate");
        if (!autowireCandidate) {
            beanDef.setAutowireCandidate(false);
        }

        String initMethodName = bean.getString("initMethod");
        if (StringUtils.hasText(initMethodName)) {
            beanDef.setInitMethodName(initMethodName);
        }

        String destroyMethodName = bean.getString("destroyMethod");
        beanDef.setDestroyMethodName(destroyMethodName);
　　　　 // 将组件定义注册到容器中
        this.registry.registerBeanDefinition(beanName, beanDefToRegister);
    }

posted @ 2022-02-23 14:47 DreamPig丶阅读(161) 评论(0) 编辑收藏举报

刷新页面返回顶部

DreamPig