ConfigurationClassPostProcessor 注解解析流程

1.Configuration是对哪些注解进行解析的？

1）@Component
2）@PropertySource
3）@ComponentScan、@ComponentScans
4）@import
5）@importResource
6）@Bean

2.ConfigurationClassPostProcessor是怎样被调用的？

1）我们先来看BeanFactoryPostProcessor 的执行，扫描所有的BeanDefinitionRegistryPostProcessor类型的BeanDefinition，查找到一个名为org.springframework.context.annotation.internalConfigurationAnnotationProcessor 的 BeanDefinition
但是这个名字对应的BeanDefinition到底是那个呢？

在下面的代码我们可以看到，在创建AnnotationConfigApplicationContext时候，构造方法中new了一个 AnnotatedBeanDefiniitonReader对象，里面调用了AnnotationConfigUtils方法，往BeanFactory中注册了一系列的内置BeanFactoryPostProcessor和BeanPostProcessor。

org.springframework.context.annotation.internalConfigurationAnnotationProcessor对应的类就是ConfigurationClassPostProcessor

image.png

    public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry, Environment environment) {
        Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
        Assert.notNull(environment, "Environment must not be null");
        this.registry = registry;
        this.conditionEvaluator = new ConditionEvaluator(registry, environment, null);
        AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
    }

public abstract class AnnotationConfigUtils {
/**
     * The bean name of the internally managed Configuration annotation processor.
     */
    public static final String CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME =
            "org.springframework.context.annotation.internalConfigurationAnnotationProcessor";

    /**
     * The bean name of the internally managed BeanNameGenerator for use when processing
     * {@link Configuration} classes. Set by {@link AnnotationConfigApplicationContext}
     * and {@code AnnotationConfigWebApplicationContext} during bootstrap in order to make
     * any custom name generation strategy available to the underlying
     * {@link ConfigurationClassPostProcessor}.
     * @since 3.1.1
     */
    public static final String CONFIGURATION_BEAN_NAME_GENERATOR =
            "org.springframework.context.annotation.internalConfigurationBeanNameGenerator";

    /**
     * The bean name of the internally managed Autowired annotation processor.
     */
    public static final String AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME =
            "org.springframework.context.annotation.internalAutowiredAnnotationProcessor";

    /**
     * The bean name of the internally managed Required annotation processor.
     * @deprecated as of 5.1, since no Required processor is registered by default anymore
     */
    @Deprecated
    public static final String REQUIRED_ANNOTATION_PROCESSOR_BEAN_NAME =
            "org.springframework.context.annotation.internalRequiredAnnotationProcessor";

    /**
     * The bean name of the internally managed JSR-250 annotation processor.
     */
    public static final String COMMON_ANNOTATION_PROCESSOR_BEAN_NAME =
            "org.springframework.context.annotation.internalCommonAnnotationProcessor";

    /**
     * The bean name of the internally managed JPA annotation processor.
     */
    public static final String PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME =
            "org.springframework.context.annotation.internalPersistenceAnnotationProcessor";

    private static final String PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME =
            "org.springframework.orm.jpa.support.PersistenceAnnotationBeanPostProcessor";

    /**
     * The bean name of the internally managed @EventListener annotation processor.
     */
    public static final String EVENT_LISTENER_PROCESSOR_BEAN_NAME =
            "org.springframework.context.event.internalEventListenerProcessor";

    /**
     * The bean name of the internally managed EventListenerFactory.
     */
    public static final String EVENT_LISTENER_FACTORY_BEAN_NAME =
            "org.springframework.context.event.internalEventListenerFactory";

    private static final boolean jsr250Present;

    private static final boolean jpaPresent;

    public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
            BeanDefinitionRegistry registry, @Nullable Object source) {

        // 获取beanFactory
        DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
        if (beanFactory != null) {
            if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {
                // //设置依赖比较器
                beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
            }
            if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {
                // //设置自动装配解析器
                beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
            }
        }

        // 创建BeanDefinitionHolder集合
        Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>(8);

        // 注册内部管理的用于处理@configuration注解的后置处理器的bean
        if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {
            RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
            def.setSource(source);
            // 注册BeanDefinition到注册表中
            beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
        }

        // 注册内部管理的用于处理@Autowired，@Value,@Inject以及@Lookup注解的后置处理器bean
        if (!registry.containsBeanDefinition(AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
            RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
            def.setSource(source);
            beanDefs.add(registerPostProcessor(registry, def, AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
        }

        // Check for JSR-250 support, and if present add the CommonAnnotationBeanPostProcessor.
        // 注册内部管理的用于处理JSR-250注解，例如@Resource,@PostConstruct,@PreDestroy的后置处理器bean
        if (jsr250Present && !registry.containsBeanDefinition(COMMON_ANNOTATION_PROCESSOR_BEAN_NAME)) {
            RootBeanDefinition def = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class);
            def.setSource(source);
            beanDefs.add(registerPostProcessor(registry, def, COMMON_ANNOTATION_PROCESSOR_BEAN_NAME));
        }

        // Check for JPA support, and if present add the PersistenceAnnotationBeanPostProcessor.
        // 注册内部管理的用于处理JPA注解的后置处理器bean
        if (jpaPresent && !registry.containsBeanDefinition(PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME)) {
            RootBeanDefinition def = new RootBeanDefinition();
            try {
                def.setBeanClass(ClassUtils.forName(PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME,
                        AnnotationConfigUtils.class.getClassLoader()));
            }
            catch (ClassNotFoundException ex) {
                throw new IllegalStateException(
                        "Cannot load optional framework class: " + PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME, ex);
            }
            def.setSource(source);
            beanDefs.add(registerPostProcessor(registry, def, PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME));
        }

        // 注册内部管理的用于处理@EventListener注解的后置处理器的bean
        if (!registry.containsBeanDefinition(EVENT_LISTENER_PROCESSOR_BEAN_NAME)) {
            RootBeanDefinition def = new RootBeanDefinition(EventListenerMethodProcessor.class);
            def.setSource(source);
            beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_PROCESSOR_BEAN_NAME));
        }

        // 注册内部管理用于生产ApplicationListener对象的EventListenerFactory对象
        if (!registry.containsBeanDefinition(EVENT_LISTENER_FACTORY_BEAN_NAME)) {
            RootBeanDefinition def = new RootBeanDefinition(DefaultEventListenerFactory.class);
            def.setSource(source);
            beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_FACTORY_BEAN_NAME));
        }

        return beanDefs;
    }
}

    private static void invokeBeanDefinitionRegistryPostProcessors(
            Collection<? extends BeanDefinitionRegistryPostProcessor> postProcessors, BeanDefinitionRegistry registry) {

        for (BeanDefinitionRegistryPostProcessor postProcessor : postProcessors) {
            postProcessor.postProcessBeanDefinitionRegistry(registry);
        }
    }

**3.ConfigurationClassPostProcessor怎样进行注解解析的？

1）processConfigBeanDefinitions方法

public class ConfigurationClassPostProcessor implements BeanDefinitionRegistryPostProcessor,
        PriorityOrdered, ResourceLoaderAware, BeanClassLoaderAware, EnvironmentAware {

    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
        // 根据对应的registry对象生成hashcode值，此对象只会操作一次，如果之前处理过则抛出异常
        int registryId = System.identityHashCode(registry);
        if (this.registriesPostProcessed.contains(registryId)) {
            throw new IllegalStateException(
                    "postProcessBeanDefinitionRegistry already called on this post-processor against " + registry);
        }
        if (this.factoriesPostProcessed.contains(registryId)) {
            throw new IllegalStateException(
                    "postProcessBeanFactory already called on this post-processor against " + registry);
        }
        // 将马上要进行处理的registry对象的id值放到已经处理的集合对象中
        this.registriesPostProcessed.add(registryId);

        // 处理配置类的bean定义信息
        processConfigBeanDefinitions(registry);
    }
      /**
     * 构建和验证一个类是否被@Configuration修饰，并做相关的解析工作
     *
     * 如果你对此方法了解清楚了，那么springboot的自动装配原理就清楚了
     *
     * Build and validate a configuration model based on the registry of
     * {@link Configuration} classes.
     */
    public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
        // 创建存放BeanDefinitionHolder的对象集合
        List<BeanDefinitionHolder> configCandidates = new ArrayList<>();
        // 当前registry就是DefaultListableBeanFactory，获取所有已经注册的BeanDefinition的beanName
        String[] candidateNames = registry.getBeanDefinitionNames();

        // 遍历所有要处理的beanDefinition的名称,筛选对应的beanDefinition（被注解修饰的）
        for (String beanName : candidateNames) {
            // 获取指定名称的BeanDefinition对象
            BeanDefinition beanDef = registry.getBeanDefinition(beanName);
            // 如果beanDefinition中的configurationClass属性不等于空，那么意味着已经处理过，输出日志信息
            if (beanDef.getAttribute(ConfigurationClassUtils.CONFIGURATION_CLASS_ATTRIBUTE) != null) {
                if (logger.isDebugEnabled()) {
                    logger.debug("Bean definition has already been processed as a configuration class: " + beanDef);
                }
            }
            // 判断当前BeanDefinition是否是一个配置类，并为BeanDefinition设置属性为lite或者full，此处设置属性值是为了后续进行调用
            // 如果Configuration配置proxyBeanMethods代理为true则为full
            // 如果加了@Bean、@Component、@ComponentScan、@Import、@ImportResource注解，则设置为lite
            // 如果配置类上被@Order注解标注，则设置BeanDefinition的order属性值
            else if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {
                // 添加到对应的集合对象中
                configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));
            }
        }

        // Return immediately if no @Configuration classes were found
        // 如果没有发现任何配置类，则直接返回
        if (configCandidates.isEmpty()) {
            return;
        }

        // Sort by previously determined @Order value, if applicable
        // 如果适用，则按照先前确定的@Order的值排序
        configCandidates.sort((bd1, bd2) -> {
            int i1 = ConfigurationClassUtils.getOrder(bd1.getBeanDefinition());
            int i2 = ConfigurationClassUtils.getOrder(bd2.getBeanDefinition());
            return Integer.compare(i1, i2);
        });

        // Detect any custom bean name generation strategy supplied through the enclosing application context
        // 判断当前类型是否是SingletonBeanRegistry类型
        SingletonBeanRegistry sbr = null;
        if (registry instanceof SingletonBeanRegistry) {
            // 类型的强制转换
            sbr = (SingletonBeanRegistry) registry;
            // 判断是否有自定义的beanName生成器
            if (!this.localBeanNameGeneratorSet) {
                // 获取自定义的beanName生成器
                BeanNameGenerator generator = (BeanNameGenerator) sbr.getSingleton(
                        AnnotationConfigUtils.CONFIGURATION_BEAN_NAME_GENERATOR);
                // 如果有自定义的命名生成策略
                if (generator != null) {
                    //设置组件扫描的beanName生成策略
                    this.componentScanBeanNameGenerator = generator;
                    // 设置import bean name生成策略
                    this.importBeanNameGenerator = generator;
                }
            }
        }

        // 如果环境对象等于空，那么就重新创建新的环境对象
        if (this.environment == null) {
            this.environment = new StandardEnvironment();
        }

        // Parse each @Configuration class
        // 实例化ConfigurationClassParser类，并初始化相关的参数，完成配置类的解析工作
        ConfigurationClassParser parser = new ConfigurationClassParser(
                this.metadataReaderFactory, this.problemReporter, this.environment,
                this.resourceLoader, this.componentScanBeanNameGenerator, registry);

        // 创建两个集合对象，
        // 存放相关的BeanDefinitionHolder对象
        Set<BeanDefinitionHolder> candidates = new LinkedHashSet<>(configCandidates);
        // 存放扫描包下的所有bean
        Set<ConfigurationClass> alreadyParsed = new HashSet<>(configCandidates.size());
        do {
            // 解析带有@Controller、@Import、@ImportResource、@ComponentScan、@ComponentScans、@Bean的BeanDefinition
            parser.parse(candidates);
            // 将解析完的Configuration配置类进行校验，1、配置类不能是final，2、@Bean修饰的方法必须可以重写以支持CGLIB
            parser.validate();

            // 获取所有的bean,包括扫描的bean对象，@Import导入的bean对象
            Set<ConfigurationClass> configClasses = new LinkedHashSet<>(parser.getConfigurationClasses());
            // 清除掉已经解析处理过的配置类
            configClasses.removeAll(alreadyParsed);

            // Read the model and create bean definitions based on its content
            // 判断读取器是否为空，如果为空的话，就创建完全填充好的ConfigurationClass实例的读取器
            if (this.reader == null) {
                this.reader = new ConfigurationClassBeanDefinitionReader(
                        registry, this.sourceExtractor, this.resourceLoader, this.environment,
                        this.importBeanNameGenerator, parser.getImportRegistry());
            }
            // 核心方法，将完全填充好的ConfigurationClass实例转化为BeanDefinition注册入IOC容器
            this.reader.loadBeanDefinitions(configClasses);
            // 添加到已经处理的集合中
            alreadyParsed.addAll(configClasses);

            candidates.clear();
            // 这里判断registry.getBeanDefinitionCount() > candidateNames.length的目的是为了知道reader.loadBeanDefinitions(configClasses)这一步有没有向BeanDefinitionMap中添加新的BeanDefinition
            // 实际上就是看配置类(例如AppConfig类会向BeanDefinitionMap中添加bean)
            // 如果有，registry.getBeanDefinitionCount()就会大于candidateNames.length
            // 这样就需要再次遍历新加入的BeanDefinition，并判断这些bean是否已经被解析过了，如果未解析，需要重新进行解析
            // 这里的AppConfig类向容器中添加的bean，实际上在parser.parse()这一步已经全部被解析了
            if (registry.getBeanDefinitionCount() > candidateNames.length) {
                String[] newCandidateNames = registry.getBeanDefinitionNames();
                Set<String> oldCandidateNames = new HashSet<>(Arrays.asList(candidateNames));
                Set<String> alreadyParsedClasses = new HashSet<>();
                for (ConfigurationClass configurationClass : alreadyParsed) {
                    alreadyParsedClasses.add(configurationClass.getMetadata().getClassName());
                }
                // 如果有未解析的类，则将其添加到candidates中，这样candidates不为空，就会进入到下一次的while的循环中
                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());

        // Register the ImportRegistry as a bean in order to support ImportAware @Configuration classes
        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();
        }
    }

}

调用processConfigBeanDefinitions方法
1）查找到BeanFactory中的所有BeanDefinition，进行循环遍历
查到是否有configurationClass属性，有的话证明已经被处理过
checkConfigurationClassCandidate：（
判断是否有@Configuration注解修饰，
如果被@Configuration修饰且需要被代理则设置属性为full，
如果被Component、@ComponentScan、@Import、@ImportResource标注 或者被有@Bean注解修饰的
方法则设置为lite
如果都没有就返回false
检测是否有order注解修饰，有的话就设置order属性）
将被注解修饰的添加到 configCandidates 集合中
对有order修饰的BeanDefinition进行排序
2）判断是否为SingletonBeanRegistry 类型，因为此时的BeanDefinitionRegistry为DefaultListableBeanFactory类型，而它实现了DefaultListableBeanFactory，ConfigurableListableBeanFactory继承ConfigurableBeanFactory 所以这个判断可以进来，然后强转为SingletonBeanRegistry 类型来判断是否有自定义的命名生成策略。

if (registry instanceof SingletonBeanRegistry) {

3）实例化一个ConfigurationClassParser 解析类，并初始化一系列的参数
进行解析！！！！
判断BeanDefintiion是什么类型的 （AnnotatedBeanDefinition类型，调用registry方法时已经设置过）

parser.parse(candidates);

    public void parse(Set<BeanDefinitionHolder> configCandidates) {
        // 循环遍历configCandidates
        for (BeanDefinitionHolder holder : configCandidates) {
            // 获取BeanDefinition
            BeanDefinition bd = holder.getBeanDefinition();
            // 根据BeanDefinition类型的不同，调用parse不同的重载方法，实际上最终都是调用processConfigurationClass()方法
            try {
                // 注解类型
                if (bd instanceof AnnotatedBeanDefinition) {
                    parse(((AnnotatedBeanDefinition) bd).getMetadata(), holder.getBeanName());
                }
                // 有class对象的
                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);
            }
        }

        // 执行找到的DeferredImportSelector
        // DeferredImportSelector是ImportSelector的一个子类
        // ImportSelector被设计成和@Import注解同样的效果，但是实现了ImportSelector的类可以条件性的决定导入某些配置
        // DeferredImportSelector的设计魔都是在所有其他的配置类被处理后才进行处理
        this.deferredImportSelectorHandler.process();
    }

4）processConfigurationClass方法
shouldSkip方法：判断metadata为空或者存在@Conditional注解，如果都没有就直接返回false，否则直接跳过
判断是否已经被处理过
解析各个注解：
1.@Component注解解析（@Configuration、 @Controller、@Service、 都继承于@Component注解）
1)查找内部类是否有配置类，如果有的话则递归调用processConfigurationClass方法进行解析

   private void processMemberClasses(ConfigurationClass configClass, SourceClass sourceClass,
           Predicate<String> filter) throws IOException {

       // 找到内部类，内部类中也可能是一个配置类
       Collection<SourceClass> memberClasses = sourceClass.getMemberClasses();
       // 如果不等于空的话
       if (!memberClasses.isEmpty()) {
           List<SourceClass> candidates = new ArrayList<>(memberClasses.size());
           // 循环判断内部类是不是配置类
           for (SourceClass memberClass : memberClasses) {
               if (ConfigurationClassUtils.isConfigurationCandidate(memberClass.getMetadata()) &&
                       !memberClass.getMetadata().getClassName().equals(configClass.getMetadata().getClassName())) {
                   candidates.add(memberClass);
               }
           }
           // 对配置类进行排序操作
           OrderComparator.sort(candidates);
           // 遍历符合规则的类
           for (SourceClass candidate : candidates) {
               if (this.importStack.contains(configClass)) {
                   // 出现配置类循环导入，则直接报错
                   this.problemReporter.error(new CircularImportProblem(configClass, this.importStack));
               }
               else {
                   // 将配置类入栈
                   this.importStack.push(configClass);
                   try {
                       // 调用processConfigurationClass方法，因为内部类中还可能包含内部类，所以需要在做循环解析，实际工作中是不会有这中情况的
                       processConfigurationClass(candidate.asConfigClass(configClass), filter);
                   }
                   finally {
                       // 解析完出栈
                       this.importStack.pop();
                   }
               }
           }
       }
   }

2.@PropertySource 注解解析
1）获取注解上的属性，并转换为Resouce对象添加为属性资源

    private void processPropertySource(AnnotationAttributes propertySource) throws IOException {
        // 获取name属性
        String name = propertySource.getString("name");
        if (!StringUtils.hasLength(name)) {
            name = null;
        }
        // 获取encoding属性
        String encoding = propertySource.getString("encoding");
        if (!StringUtils.hasLength(encoding)) {
            encoding = null;
        }
        // 获取value属性
        String[] locations = propertySource.getStringArray("value");
        Assert.isTrue(locations.length > 0, "At least one @PropertySource(value) location is required");
        boolean ignoreResourceNotFound = propertySource.getBoolean("ignoreResourceNotFound");

        Class<? extends PropertySourceFactory> factoryClass = propertySource.getClass("factory");
        PropertySourceFactory factory = (factoryClass == PropertySourceFactory.class ?
                DEFAULT_PROPERTY_SOURCE_FACTORY : BeanUtils.instantiateClass(factoryClass));

        for (String location : locations) {
            try {
                // 处理属性值的占位符
                String resolvedLocation = this.environment.resolveRequiredPlaceholders(location);
                // 讲指定位置的资源转换成resource对象
                Resource resource = this.resourceLoader.getResource(resolvedLocation);
                // 添加resource对象为属性资源
                addPropertySource(factory.createPropertySource(name, new EncodedResource(resource, encoding)));
            }
            catch (IllegalArgumentException | FileNotFoundException | UnknownHostException | SocketException ex) {
                // Placeholders not resolvable or resource not found when trying to open it
                if (ignoreResourceNotFound) {
                    if (logger.isInfoEnabled()) {
                        logger.info("Properties location [" + location + "] not resolvable: " + ex.getMessage());
                    }
                }
                else {
                    throw ex;
                }
            }
        }
    }

3.@ComponentScan、@ComponentScans注解解析
1)扫描路径下所包含的所有类并进行解析this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());解析后的BeanDefinition放入到scannedBeanDefinitions集合中
2)循环遍历解析出来的BeanDefinition是否还有@ComponentScan注解，如果有则递归调用processConfigurationClass方法进行解析

    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
                // 解析@ComponentScan和@ComponentScans配置的扫描的包所包含的类
                // 比如 basePackages = com.my, 那么在这一步会扫描出这个包及子包下的class，然后将其解析成BeanDefinition
                // (BeanDefinition可以理解为等价于BeanDefinitionHolder)
                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
                // 通过上一步扫描包com.my，有可能扫描出来的bean中可能也添加了ComponentScan或者ComponentScans注解.
                //所以这里需要循环遍历一次，进行递归(parse)，继续解析，直到解析出的类上没有ComponentScan和ComponentScans
                for (BeanDefinitionHolder holder : scannedBeanDefinitions) {
                    BeanDefinition bdCand = holder.getBeanDefinition().getOriginatingBeanDefinition();
                    if (bdCand == null) {
                        bdCand = holder.getBeanDefinition();
                    }
                    // 判断是否是一个配置类，并设置full或lite属性
                    if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) {
                        // 通过递归方法进行解析
                        parse(bdCand.getBeanClassName(), holder.getBeanName());
                    }
                }
            }
        }

    public Set<BeanDefinitionHolder> parse(AnnotationAttributes componentScan, final String declaringClass) {
        // 创建对应的扫描类
        ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(this.registry,
                componentScan.getBoolean("useDefaultFilters"), this.environment, this.resourceLoader);

        // 获取@ComponentScan的参数，并进行参数的设置工作
        Class<? extends BeanNameGenerator> generatorClass = componentScan.getClass("nameGenerator");
        boolean useInheritedGenerator = (BeanNameGenerator.class == generatorClass);
        scanner.setBeanNameGenerator(useInheritedGenerator ? this.beanNameGenerator :
                BeanUtils.instantiateClass(generatorClass));

        // 获取scopedProxy属性
        ScopedProxyMode scopedProxyMode = componentScan.getEnum("scopedProxy");
        if (scopedProxyMode != ScopedProxyMode.DEFAULT) {
            scanner.setScopedProxyMode(scopedProxyMode);
        }
        else {
            Class<? extends ScopeMetadataResolver> resolverClass = componentScan.getClass("scopeResolver");
            scanner.setScopeMetadataResolver(BeanUtils.instantiateClass(resolverClass));
        }

        // 获取resourcePattern属性
        scanner.setResourcePattern(componentScan.getString("resourcePattern"));

        // 获取includeFilters属性
        for (AnnotationAttributes filter : componentScan.getAnnotationArray("includeFilters")) {
            for (TypeFilter typeFilter : typeFiltersFor(filter)) {
                scanner.addIncludeFilter(typeFilter);
            }
        }
        // 获取excludeFilters属性
        for (AnnotationAttributes filter : componentScan.getAnnotationArray("excludeFilters")) {
            for (TypeFilter typeFilter : typeFiltersFor(filter)) {
                scanner.addExcludeFilter(typeFilter);
            }
        }

        // 获取lazyInit属性
        boolean lazyInit = componentScan.getBoolean("lazyInit");
        if (lazyInit) {
            scanner.getBeanDefinitionDefaults().setLazyInit(true);
        }

        Set<String> basePackages = new LinkedHashSet<>();
        // 获取basePackages属性
        String[] basePackagesArray = componentScan.getStringArray("basePackages");
        for (String pkg : basePackagesArray) {
            String[] tokenized = StringUtils.tokenizeToStringArray(this.environment.resolvePlaceholders(pkg),
                    ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);
            Collections.addAll(basePackages, tokenized);
        }
        // 获取basePackageClasses属性
        for (Class<?> clazz : componentScan.getClassArray("basePackageClasses")) {
            basePackages.add(ClassUtils.getPackageName(clazz));
        }
        if (basePackages.isEmpty()) {
            basePackages.add(ClassUtils.getPackageName(declaringClass));
        }

        scanner.addExcludeFilter(new AbstractTypeHierarchyTraversingFilter(false, false) {
            @Override
            protected boolean matchClassName(String className) {
                return declaringClass.equals(className);
            }
        });
        // 开始执行扫描，最终的扫描器是ClassPathBeanDefinitionScanner
        return scanner.doScan(StringUtils.toStringArray(basePackages));
    }

    protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
        Assert.notEmpty(basePackages, "At least one base package must be specified");
        Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<>();
        // 遍历basePackages
        for (String basePackage : basePackages) {
            // 扫描basePackage,将符合要求的bean定义全部找出来
            Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
            // 遍历所有候选的bean定义
            for (BeanDefinition candidate : candidates) {
                // 解析@Scope注解，包括scopeName和proxyMode
                ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
                candidate.setScope(scopeMetadata.getScopeName());
                // 使用beanName生成器来生成beanName
                String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
                if (candidate instanceof AbstractBeanDefinition) {
                    // 处理beanDefinition对象，例如，此bean是否可以自动装配到其他bean中
                    postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
                }
                if (candidate instanceof AnnotatedBeanDefinition) {
                    // 处理定义在目标类上的通用注解，包括@Lazy，@Primary，@DependsOn，@Role，@Description
                    AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
                }
                // 检查beanName是否已经注册过，如果注册过，检查是否兼容
                if (checkCandidate(beanName, candidate)) {
                    // 将当前遍历bean的bean定义和beanName封装成BeanDefinitionHolder
                    BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
                    // 根据proxyMode的值，选择是否创建作用域代理
                    definitionHolder =
                            AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
                    beanDefinitions.add(definitionHolder);
                    // 注册beanDefinition
                    registerBeanDefinition(definitionHolder, this.registry);
                }
            }
        }
        return beanDefinitions;
    }

4.**@Import注解解析
1)递归获取所有有@Import注解的类
2）检验配置类Import引入的类是否是ImportSelector子类

3. 获取导入的Class对象，通过反射来实例化ImportSelector对象，exclusionFilter来过滤掉不需要导入的
   4）获取到引用的类，然后再递归调用processImports方法来处理引用类中包含的@Import注解**

    private Set<SourceClass> getImports(SourceClass sourceClass) throws IOException {
        // 创建集合，存储包含@Import注解的类
        Set<SourceClass> imports = new LinkedHashSet<>();
        // 创建集合，为了实现递归调用
        Set<SourceClass> visited = new LinkedHashSet<>();
        // 收集@Import注解的类
        collectImports(sourceClass, imports, visited);
        return imports;
    }

    private void collectImports(SourceClass sourceClass, Set<SourceClass> imports, Set<SourceClass> visited)
            throws IOException {

        if (visited.add(sourceClass)) {
            for (SourceClass annotation : sourceClass.getAnnotations()) {
                String annName = annotation.getMetadata().getClassName();
                // 递归处理其他可能包含@Import的注解类
                if (!annName.equals(Import.class.getName())) {
                    collectImports(annotation, imports, visited);
                }
            }
            // 获取Import注解的值
            imports.addAll(sourceClass.getAnnotationAttributes(Import.class.getName(), "value"));
        }
    }

private void processImports(ConfigurationClass configClass, SourceClass currentSourceClass,
            Collection<SourceClass> importCandidates, Predicate<String> exclusionFilter,
            boolean checkForCircularImports) {

        // 如果使用@Import注解修饰的类集合为空，那么直接返回
        if (importCandidates.isEmpty()) {
            return;
        }
        // 通过一个栈结构解决循环引入
        if (checkForCircularImports && isChainedImportOnStack(configClass)) {
            this.problemReporter.error(new CircularImportProblem(configClass, this.importStack));
        }
        else {
            // 添加到栈中，用于处理循环引入的问题
            this.importStack.push(configClass);
            try {
                // 遍历每一个@Import注解的类
                for (SourceClass candidate : importCandidates) {
                    // 检验配置类Import引入的类是否是ImportSelector子类
                    if (candidate.isAssignable(ImportSelector.class)) {
                        // Candidate class is an ImportSelector -> delegate to it to determine imports
                        // 候选类是一个导入选择器->委托来确定是否进行导入
                        Class<?> candidateClass = candidate.loadClass();
                        // 通过反射生成一个ImportSelect对象
                        ImportSelector selector = ParserStrategyUtils.instantiateClass(candidateClass, ImportSelector.class,
                                this.environment, this.resourceLoader, this.registry);
                        // 获取选择器的额外过滤器
                        Predicate<String> selectorFilter = selector.getExclusionFilter();
                        if (selectorFilter != null) {
                            exclusionFilter = exclusionFilter.or(selectorFilter);
                        }
                        // 判断引用选择器是否是DeferredImportSelector接口的实例
                        // 如果是则应用选择器将会在所有的配置类都加载完毕后加载
                        if (selector instanceof DeferredImportSelector) {
                            // 将选择器添加到deferredImportSelectorHandler实例中，预留到所有的配置类加载完成后统一处理自动化配置类
                            this.deferredImportSelectorHandler.handle(configClass, (DeferredImportSelector) selector);
                        }
                        else {
                            // 获取引入的类，然后使用递归方式将这些类中同样添加了@Import注解引用的类
                            String[] importClassNames = selector.selectImports(currentSourceClass.getMetadata());
                            Collection<SourceClass> importSourceClasses = asSourceClasses(importClassNames, exclusionFilter);
                            // 递归处理，被Import进来的类也有可能@Import注解
                            processImports(configClass, currentSourceClass, importSourceClasses, exclusionFilter, false);
                        }
                    }
                    // 如果是实现了ImportBeanDefinitionRegistrar接口的bd
                    else if (candidate.isAssignable(ImportBeanDefinitionRegistrar.class)) {
                        // Candidate class is an ImportBeanDefinitionRegistrar ->
                        // delegate to it to register additional bean definitions
                        // 候选类是ImportBeanDefinitionRegistrar  -> 委托给当前注册器注册其他bean
                        Class<?> candidateClass = candidate.loadClass();
                        ImportBeanDefinitionRegistrar registrar =
                                ParserStrategyUtils.instantiateClass(candidateClass, ImportBeanDefinitionRegistrar.class,
                                        this.environment, this.resourceLoader, this.registry);
                        /**
                         * 放到当前configClass的importBeanDefinitionRegistrars中
                         * 在ConfigurationClassPostProcessor处理configClass时会随之一起处理
                         */
                        configClass.addImportBeanDefinitionRegistrar(registrar, currentSourceClass.getMetadata());
                    }
                    else {
                        // Candidate class not an ImportSelector or ImportBeanDefinitionRegistrar ->
                        // process it as an @Configuration class
                        // 候选类既不是ImportSelector也不是ImportBeanDefinitionRegistrar-->将其作为@Configuration配置类处理
                        this.importStack.registerImport(
                                currentSourceClass.getMetadata(), candidate.getMetadata().getClassName());
                        /**
                         * 如果Import的类型是普通类，则将其当作带有@Configuration的类一样处理
                         * 将candidate构造为ConfigurationClass，标注为importedBy，意味着它是通过被@Import进来的
                         * 后面处理会用到这个判断将这个普通类注册进DefaultListableBeanFactory
                         */
                        processConfigurationClass(candidate.asConfigClass(configClass), exclusionFilter);
                    }
                }
            }
            catch (BeanDefinitionStoreException ex) {
                throw ex;
            }
            catch (Throwable ex) {
                throw new BeanDefinitionStoreException(
                        "Failed to process import candidates for configuration class [" +
                        configClass.getMetadata().getClassName() + "]", ex);
            }
            finally {
                this.importStack.pop();
            }
        }
    }

5.@ImportResource注解解析
6.@Bean注解解析
1)获取有@Bean的方法，判断是否只有一个，只有一个的话直接返回，不是的话就一个一个添加到集合中

private Set<MethodMetadata> retrieveBeanMethodMetadata(SourceClass sourceClass) {
        AnnotationMetadata original = sourceClass.getMetadata();
        Set<MethodMetadata> beanMethods = original.getAnnotatedMethods(Bean.class.getName());
        if (beanMethods.size() > 1 && original instanceof StandardAnnotationMetadata) {
            // Try reading the class file via ASM for deterministic declaration order...
            // Unfortunately, the JVM's standard reflection returns methods in arbitrary
            // order, even between different runs of the same application on the same JVM.
            try {
                AnnotationMetadata asm =
                        this.metadataReaderFactory.getMetadataReader(original.getClassName()).getAnnotationMetadata();
                Set<MethodMetadata> asmMethods = asm.getAnnotatedMethods(Bean.class.getName());
                if (asmMethods.size() >= beanMethods.size()) {
                    Set<MethodMetadata> selectedMethods = new LinkedHashSet<>(asmMethods.size());
                    for (MethodMetadata asmMethod : asmMethods) {
                        for (MethodMetadata beanMethod : beanMethods) {
                            if (beanMethod.getMethodName().equals(asmMethod.getMethodName())) {
                                selectedMethods.add(beanMethod);
                                break;
                            }
                        }
                    }
                    if (selectedMethods.size() == beanMethods.size()) {
                        // All reflection-detected methods found in ASM method set -> proceed
                        beanMethods = selectedMethods;
                    }
                }
            }
            catch (IOException ex) {
                logger.debug("Failed to read class file via ASM for determining @Bean method order", ex);
                // No worries, let's continue with the reflection metadata we started with...
            }
        }
        return beanMethods;
    }

    SourceClass sourceClass = asSourceClass(configClass, filter);
        do {
            // 解析各种注解
            sourceClass = doProcessConfigurationClass(configClass, sourceClass, filter);
        }
        while (sourceClass != null);

    @Nullable
    protected final SourceClass doProcessConfigurationClass(
            ConfigurationClass configClass, SourceClass sourceClass, Predicate<String> filter)
            throws IOException {
        // @Configuration继承了@Component
        if (configClass.getMetadata().isAnnotated(Component.class.getName())) {
            // Recursively process any member (nested) classes first
            // 递归处理内部类，因为内部类也是一个配置类，配置类上有@configuration注解，该注解继承@Component，if判断为true，调用processMemberClasses方法，递归解析配置类中的内部类
            processMemberClasses(configClass, sourceClass, filter);
        }

        // Process any @PropertySource annotations
        // 如果配置类上加了@PropertySource注解，那么就解析加载properties文件，并将属性添加到spring上下文中
        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
        // 处理@ComponentScan或者@ComponentScans注解，并将扫描包下的所有bean转换成填充后的ConfigurationClass
        // 此处就是将自定义的bean加载到IOC容器，因为扫描到的类可能也添加了@ComponentScan和@ComponentScans注解，因此需要进行递归解析
        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
                // 解析@ComponentScan和@ComponentScans配置的扫描的包所包含的类
                // 比如 basePackages = com.my, 那么在这一步会扫描出这个包及子包下的class，然后将其解析成BeanDefinition
                // (BeanDefinition可以理解为等价于BeanDefinitionHolder)
                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
                // 通过上一步扫描包com.my，有可能扫描出来的bean中可能也添加了ComponentScan或者ComponentScans注解.
                //所以这里需要循环遍历一次，进行递归(parse)，继续解析，直到解析出的类上没有ComponentScan和ComponentScans
                for (BeanDefinitionHolder holder : scannedBeanDefinitions) {
                    BeanDefinition bdCand = holder.getBeanDefinition().getOriginatingBeanDefinition();
                    if (bdCand == null) {
                        bdCand = holder.getBeanDefinition();
                    }
                    // 判断是否是一个配置类，并设置full或lite属性
                    if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) {
                        // 通过递归方法进行解析
                        parse(bdCand.getBeanClassName(), holder.getBeanName());
                    }
                }
            }
        }

        // Process any @Import annotations
        // 处理@Import注解
        processImports(configClass, sourceClass, getImports(sourceClass), filter, true);

        // Process any @ImportResource annotations
        // 处理@ImportResource注解，导入spring的配置文件
        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
        // 处理加了@Bean注解的方法，将@Bean方法转化为BeanMethod对象，保存再集合中
        Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(sourceClass);
        for (MethodMetadata methodMetadata : beanMethods) {
            configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
        }

        // Process default methods on interfaces
        // 处理接口的默认方法实现，从jdk8开始，接口中的方法可以有自己的默认实现，因此如果这个接口的方法加了@Bean注解，也需要被解析
        processInterfaces(configClass, sourceClass);

        // Process superclass, if any
        // 解析父类，如果被解析的配置类继承了某个类，那么配置类的父类也会被进行解析
        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();
            }
        }

        // No superclass -> processing is complete
        return null;
    }

将所有扫描到的BeanDefinition获取出来，放入集合中 其中包含@ComponentScan扫描的和@Import导入的，然后转换为BeanDefinition注册到BeanFactory中

    // 获取所有的bean,包括扫描的bean对象，@Import导入的bean对象
            Set<ConfigurationClass> configClasses = new LinkedHashSet<>(parser.getConfigurationClasses());
        //将完全填充好的ConfigurationClass实例转化为BeanDefinition注册入IOC容器
        this.reader.loadBeanDefinitions(configClasses);

loadBeanDefinitionsForBeanMethod 方法处理有@Bean注解标注的方法的BeanDefinition，
在此处设置@Bean 实例化 工厂方法名称以及工厂名称
设置解析的工厂方法，然后设置装配模式，默认是按构造器自动装配，
获取是否有自定义的装配模式，有的话重新设置，
检测是否有@PreDestroy或者@PostConstruct注解修饰，有的话设置initMethod，
设置destroy方法，
判断需不需要代理
注册Bean

    // 设置工厂名
            beanDef.setFactoryBeanName(configClass.getBeanName());
            beanDef.setUniqueFactoryMethodName(methodName);

private void loadBeanDefinitionsForBeanMethod(BeanMethod beanMethod) {
        ConfigurationClass configClass = beanMethod.getConfigurationClass();
        // 获取方法元数据
        MethodMetadata metadata = beanMethod.getMetadata();
        // 获取方法名称
        String methodName = metadata.getMethodName();

        // Do we need to mark the bean as skipped by its condition?
        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");

        // Consider name and any aliases
        // 获取别名
        List<String> names = new ArrayList<>(Arrays.asList(bean.getStringArray("name")));
        String beanName = (!names.isEmpty() ? names.remove(0) : methodName);

        // Register aliases even when overridden
        for (String alias : names) {
            // 注册剩下的别名
            this.registry.registerAlias(beanName, alias);
        }

        // Has this effectively been overridden before (e.g. via XML)?
        // 是否存在同名bean定义
        if (isOverriddenByExistingDefinition(beanMethod, beanName)) {
            if (beanName.equals(beanMethod.getConfigurationClass().getBeanName())) {
                throw new BeanDefinitionStoreException(beanMethod.getConfigurationClass().getResource().getDescription(),
                        beanName, "Bean name derived from @Bean method '" + beanMethod.getMetadata().getMethodName() +
                        "' clashes with bean name for containing configuration class; please make those names unique!");
            }
            return;
        }

        // 封装为ConfigurationClassBeanDefinition,表示是来自配置类里的bean定义
        ConfigurationClassBeanDefinition beanDef = new ConfigurationClassBeanDefinition(configClass, metadata, beanName);
        // 设置来源的类
        beanDef.setSource(this.sourceExtractor.extractSource(metadata, configClass.getResource()));

        // 判断是否是静态的，设置BeanClass
        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);
        }
        else {
            // instance @Bean method
            // 设置工厂名
            beanDef.setFactoryBeanName(configClass.getBeanName());
            beanDef.setUniqueFactoryMethodName(methodName);
        }

        // 如果方法元数据是标准方法元数据的话，就设置解析的工厂方法
        if (metadata instanceof StandardMethodMetadata) {
            beanDef.setResolvedFactoryMethod(((StandardMethodMetadata) metadata).getIntrospectedMethod());
        }

        // 设置自定义装配模式，默认是构造器
        beanDef.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_CONSTRUCTOR);
        // 设置略过属性检查
        beanDef.setAttribute(org.springframework.beans.factory.annotation.RequiredAnnotationBeanPostProcessor.
                SKIP_REQUIRED_CHECK_ATTRIBUTE, Boolean.TRUE);

        // 处理通用注解，注解里可能还有自动装配注解
        AnnotationConfigUtils.processCommonDefinitionAnnotations(beanDef, metadata);

        // 获取自动装配枚举信息
        Autowire autowire = bean.getEnum("autowire");
        if (autowire.isAutowire()) {
            //如果是自动装配，也就是BY_NAME 或者 BY_TYPE，再设置了一次自动装配模式
            beanDef.setAutowireMode(autowire.value());
        }

        // 自动装配候选，默认是true
        boolean autowireCandidate = bean.getBoolean("autowireCandidate");
        if (!autowireCandidate) {
            beanDef.setAutowireCandidate(false);
        }

        // 初始化方法@PostConstruct和@PreDestory或者XML或者InitializingBean和DisposableBean接口
        String initMethodName = bean.getString("initMethod");
        if (StringUtils.hasText(initMethodName)) {
            beanDef.setInitMethodName(initMethodName);
        }

        // 销毁方法
        String destroyMethodName = bean.getString("destroyMethod");
        beanDef.setDestroyMethodName(destroyMethodName);

        // Consider scoping
        // 处理作用域
        ScopedProxyMode proxyMode = ScopedProxyMode.NO;
        AnnotationAttributes attributes = AnnotationConfigUtils.attributesFor(metadata, Scope.class);
        if (attributes != null) {
            beanDef.setScope(attributes.getString("value"));
            proxyMode = attributes.getEnum("proxyMode");
            if (proxyMode == ScopedProxyMode.DEFAULT) {
                proxyMode = ScopedProxyMode.NO;
            }
        }

        // Replace the original bean definition with the target one, if necessary
        BeanDefinition beanDefToRegister = beanDef;
        // 如果作用域不是no的话就要使用代理
        if (proxyMode != ScopedProxyMode.NO) {
            BeanDefinitionHolder proxyDef = ScopedProxyCreator.createScopedProxy(
                    new BeanDefinitionHolder(beanDef, beanName), this.registry,
                    proxyMode == ScopedProxyMode.TARGET_CLASS);
            beanDefToRegister = new ConfigurationClassBeanDefinition(
                    (RootBeanDefinition) proxyDef.getBeanDefinition(), configClass, metadata, beanName);
        }

        if (logger.isTraceEnabled()) {
            logger.trace(String.format("Registering bean definition for @Bean method %s.%s()",
                    configClass.getMetadata().getClassName(), beanName));
        }
        this.registry.registerBeanDefinition(beanName, beanDefToRegister);
    }

到此注解就已经解析完毕了，东西很多，还是需要自己下去DEBUG，自己看，注解解析这里，主要就是递归递归再递归，将所有内部包含的注解全部解析到