带你搞懂 SpringBoot 自动装配原理

public static void register(BeanDefinitionRegistry registry, String... packageNames) {

        // 如果已经存在该 BEAN ，则修改其包（package）属性

        // BEAN 就是 AutoConfigurationPackages，用于存储自动配置包以供稍后引用

        if (registry.containsBeanDefinition(BEAN)) {

            BeanDefinition beanDefinition = registry.getBeanDefinition(BEAN);

            ConstructorArgumentValues constructorArguments = beanDefinition.getConstructorArgumentValues();

            // 将构造函数的第一个参数设置为包名列表

            constructorArguments.addIndexedArgumentValue(0, addBasePackages(constructorArguments, packageNames));

        // 如果不存在该 BEAN ，则创建一个 Bean ，并进行注册

        } else { GenericBeanDefinition beanDefinition = new GenericBeanDefinition();

            beanDefinition.setBeanClass(BasePackages.class);

            // 将beanClass设置为BasePackages

            beanDefinition.getConstructorArgumentValues().addIndexedArgumentValue(0, packageNames);

            // 将构造函数的第一个参数设置为包名列表，也就是BasePackages的构造函数

            beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);

            // 注册beanDefinition

            registry.registerBeanDefinition(BEAN, beanDefinition);

        }

    }

AutoConfigurationImportSelector.AutoConfigurationGroup.class

public void process(AnnotationMetadata annotationMetadata, DeferredImportSelector deferredImportSelector) {

            // 断言

            Assert.state(

                    deferredImportSelector instanceof AutoConfigurationImportSelector,

                    () -> String.format("Only %s implementations are supported, got %s",

                            AutoConfigurationImportSelector.class.getSimpleName(),

                            deferredImportSelector.getClass().getName()));

            // 获得 AutoConfigurationEntry 对象

            // 核心方法：获取并过滤全部自动装配的类

            AutoConfigurationEntry autoConfigurationEntry = ((AutoConfigurationImportSelector) deferredImportSelector)

                    .getAutoConfigurationEntry(getAutoConfigurationMetadata(), annotationMetadata);

            // 添加到 autoConfigurationEntries 中

            this.autoConfigurationEntries.add(autoConfigurationEntry);

            // 添加到 entries 中

            for (String importClassName : autoConfigurationEntry.getConfigurations()) {

                this.entries.putIfAbsent(importClassName, annotationMetadata);

            }

        }

AutoConfigurationImportSelector.AutoConfigurationGroup.class

public Iterable<Entry> selectImports() {

            // 如果为空，则返回空数组

            if (this.autoConfigurationEntries.isEmpty()) {

                return Collections.emptyList();

            }

            // 获得 allExclusions

            Set<String> allExclusions = this.autoConfigurationEntries.stream()

                    .map(AutoConfigurationEntry::getExclusions)

                    .flatMap(Collection::stream).collect(Collectors.toSet());

            // 获得 processedConfigurations

            Set<String> processedConfigurations = this.autoConfigurationEntries.stream()

                    .map(AutoConfigurationEntry::getConfigurations)

                    .flatMap(Collection::stream)

                    .collect(Collectors.toCollection(LinkedHashSet::new));

            // 从 processedConfigurations 中，移除排除的

            processedConfigurations.removeAll(allExclusions);

            // 处理，返回结果

            return sortAutoConfigurations(processedConfigurations, getAutoConfigurationMetadata()) // 排序

                        .stream()

                        .map((importClassName) -> new Entry(this.entries.get(importClassName), importClassName)) // 创建 Entry 对象

                        .collect(Collectors.toList()); // 转换成 List

        }

AutoConfigurationImportSelector.class

protected AutoConfigurationEntry getAutoConfigurationEntry(AutoConfigurationMetadata autoConfigurationMetadata, AnnotationMetadata annotationMetadata) {

        // 1\. 判断是否开启注解。如未开启，返回空串

        if (!isEnabled(annotationMetadata)) {

            return EMPTY_ENTRY;

        }

        // 2\. 获得注解的属性

        AnnotationAttributes attributes = getAttributes(annotationMetadata);

        // 3\. getCandidateConfigurations()用来获取默认支持的自动配置类名列表

        // spring Boot在启动的时候，使用内部工具类SpringFactoriesLoader，查找classpath上所有jar包中的META-INF/spring.factories，

        // 找出其中key为org.springframework.boot.autoconfigure.EnableAutoConfiguration的属性定义的工厂类名称，

        // 将这些值作为自动配置类导入到容器中，自动配置类就生效了

        List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes);

        // 3.1 //去除重复的配置类，若我们自己写的starter 可能存在重复的

        configurations = removeDuplicates(configurations);

        // 4\. 如果项目中某些自动配置类，我们不希望其自动配置，我们可以通过EnableAutoConfiguration的exclude或excludeName属性进行配置，

        // 或者也可以在配置文件里通过配置项“spring.autoconfigure.exclude”进行配置。

        //找到不希望自动配置的配置类（根据EnableAutoConfiguration注解的一个exclusions属性）

        Set<String> exclusions = getExclusions(annotationMetadata, attributes);

        // 4.1 校验排除类（exclusions指定的类必须是自动配置类，否则抛出异常）

        checkExcludedClasses(configurations, exclusions);

        // 4.2 从 configurations 中，移除所有不希望自动配置的配置类

        configurations.removeAll(exclusions);

        // 5\. 对所有候选的自动配置类进行筛选，根据项目pom.xml文件中加入的依赖文件筛选出最终符合当前项目运行环境对应的自动配置类

        //@ConditionalOnClass ： 某个class位于类路径上，才会实例化这个Bean。

        //@ConditionalOnMissingClass ： classpath中不存在该类时起效

        //@ConditionalOnBean ： DI容器中存在该类型Bean时起效

        //@ConditionalOnMissingBean ： DI容器中不存在该类型Bean时起效

        //@ConditionalOnSingleCandidate ： DI容器中该类型Bean只有一个或@Primary的只有一个时起效

        //@ConditionalOnExpression ： SpEL表达式结果为true时

        //@ConditionalOnProperty ： 参数设置或者值一致时起效

        //@ConditionalOnResource ： 指定的文件存在时起效

        //@ConditionalOnJndi ： 指定的JNDI存在时起效

        //@ConditionalOnJava ： 指定的Java版本存在时起效

        //@ConditionalOnWebApplication ： Web应用环境下起效

        //@ConditionalOnNotWebApplication ： 非Web应用环境下起效

        //要判断@Conditional是否满足

        // 如@ConditionalOnClass({ SqlSessionFactory.class, SqlSessionFactoryBean.class })表示需要在类路径中存在SqlSessionFactory.class、SqlSessionFactoryBean.class这两个类才能完成自动注册。

        configurations = filter(configurations, autoConfigurationMetadata);

        // 6\. 将自动配置导入事件通知监听器

        //当AutoConfigurationImportSelector过滤完成后会自动加载类路径下Jar包中META-INF/spring.factories文件中 AutoConfigurationImportListener的实现类，

        // 并触发fireAutoConfigurationImportEvents事件。

        fireAutoConfigurationImportEvents(configurations, exclusions);

        // 7\. 创建 AutoConfigurationEntry 对象

        return new AutoConfigurationEntry(configurations, exclusions);

    }

public static ConfigurableApplicationContext run(Class<?>[] primarySources, String[] args) {

       //SpringApplication的启动由两部分组成：

        //1\. 实例化SpringApplication对象

        //2\. run(args)：调用run方法

        return new SpringApplication(primarySources).run(args);

    }

public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {

        this.sources = new LinkedHashSet();

        this.bannerMode = Mode.CONSOLE;

        this.logStartupInfo = true;

        this.addCommandLineProperties = true;

        this.addConversionService = true;

        this.headless = true;

        this.registerShutdownHook = true;

        this.additionalProfiles = new HashSet();

        this.isCustomEnvironment = false;

        this.resourceLoader = resourceLoader;

        Assert.notNull(primarySources, "PrimarySources must not be null");

        //项目启动类 SpringbootDemoApplication.class设置为属性存储起来

        this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));

        //设置应用类型是SERVLET应用（Spring 5之前的传统MVC应用）还是REACTIVE应用（Spring 5开始出现的WebFlux交互式应用）

        this.webApplicationType = WebApplicationType.deduceFromClasspath();

        // 设置初始化器(Initializer),最后会调用这些初始化器

        //所谓的初始化器就是org.springframework.context.ApplicationContextInitializer的实现类,在Spring上下文被刷新之前进行初始化的操作

        setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));

        // 设置监听器(Listener)

        setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));

        // 初始化 mainApplicationClass 属性:用于推断并设置项目main()方法启动的主程序启动类

        this.mainApplicationClass = deduceMainApplicationClass();

    }

public ConfigurableApplicationContext run(String... args) {

        // 创建 StopWatch 对象，并启动。StopWatch 主要用于简单统计 run 启动过程的时长。

        StopWatch stopWatch = new StopWatch();

        stopWatch.start();

        // 初始化应用上下文和异常报告集合

        ConfigurableApplicationContext context = null;

        Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();

        // 配置 headless 属性

        configureHeadlessProperty();

        //   （1）获取并启动监听器

        SpringApplicationRunListeners listeners = getRunListeners(args);

        listeners.starting();

        try {

            // 创建  ApplicationArguments 对象 初始化默认应用参数类

            // args是启动Spring应用的命令行参数，该参数可以在Spring应用中被访问。如：--server.port=9000

            ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);

            //（2）项目运行环境Environment的预配置

            // 创建并配置当前SpringBoot应用将要使用的Environment

            // 并遍历调用所有的SpringApplicationRunListener的environmentPrepared()方法

            ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments);

            configureIgnoreBeanInfo(environment);

            // 准备Banner打印器 - 就是启动Spring Boot的时候打印在console上的ASCII艺术字体

            Banner printedBanner = printBanner(environment);

            // （3）创建Spring容器

            context = createApplicationContext();

            // 获得异常报告器 SpringBootExceptionReporter 数组

            //这一步的逻辑和实例化初始化器和监听器的一样，

            // 都是通过调用 getSpringFactoriesInstances 方法来获取配置的异常类名称并实例化所有的异常处理类。

            exceptionReporters = getSpringFactoriesInstances(

                    SpringBootExceptionReporter.class,

                    new Class[] { ConfigurableApplicationContext.class }, context);

            // （4）Spring容器前置处理

            //这一步主要是在容器刷新之前的准备动作。包含一个非常关键的操作：将启动类注入容器，为后续开启自动化配置奠定基础。

            prepareContext(context, environment, listeners, applicationArguments,

                    printedBanner);

            // （5）：刷新容器

            refreshContext(context);

            // （6）：Spring容器后置处理

            //扩展接口，设计模式中的模板方法，默认为空实现。

            // 如果有自定义需求，可以重写该方法。比如打印一些启动结束log，或者一些其它后置处理

            afterRefresh(context, applicationArguments);

            // 停止 StopWatch 统计时长

            stopWatch.stop();

            // 打印 Spring Boot 启动的时长日志。

            if (this.logStartupInfo) {

                new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), stopWatch);

            }

            // （7）发出结束执行的事件通知

            listeners.started(context);

            // （8）：执行Runners

            //用于调用项目中自定义的执行器XxxRunner类，使得在项目启动完成后立即执行一些特定程序

            //Runner 运行器用于在服务启动时进行一些业务初始化操作，这些操作只在服务启动后执行一次。

            //Spring Boot提供了ApplicationRunner和CommandLineRunner两种服务接口

            callRunners(context, applicationArguments);

        } catch (Throwable ex) {

            // 如果发生异常，则进行处理，并抛出 IllegalStateException 异常

            handleRunFailure(context, ex, exceptionReporters, listeners);

            throw new IllegalStateException(ex);

        }

        //   (9)发布应用上下文就绪事件

        //表示在前面一切初始化启动都没有问题的情况下，使用运行监听器SpringApplicationRunListener持续运行配置好的应用上下文ApplicationContext，

        // 这样整个Spring Boot项目就正式启动完成了。

        try {

            listeners.running(context);

        } catch (Throwable ex) {

            // 如果发生异常，则进行处理，并抛出 IllegalStateException 异常

            handleRunFailure(context, ex, exceptionReporters, null);

            throw new IllegalStateException(ex);

        }

         //返回容器

        return context;

    }

SpringApplication.class

protected ConfigurableApplicationContext createApplicationContext() {

        // 根据 webApplicationType 类型，获得 ApplicationContext 类型

        // 这里创建容器的类型 还是根据webApplicationType进行判断的，

        // 该类型为SERVLET类型，所以会通过反射装载对应的字节码，

        // 也就是AnnotationConfigServletWebServerApplicationContext

        // 先判断有没有指定的实现类

        Class<?> contextClass = this.applicationContextClass;

        if (contextClass == null) {

            try {

                switch (this.webApplicationType) {

                case SERVLET:

                    contextClass = Class.forName(DEFAULT_SERVLET_WEB_CONTEXT_CLASS);

                    break;

                case REACTIVE:

                    contextClass = Class.forName(DEFAULT_REACTIVE_WEB_CONTEXT_CLASS);

                    break;

                default:

                    contextClass = Class.forName(DEFAULT_CONTEXT_CLASS);

                }

            } catch (ClassNotFoundException ex) {

                throw new IllegalStateException("Unable create a default ApplicationContext, " + "please specify an ApplicationContextClass", ex);

            }

        }

        // 创建 ApplicationContext 对象

        return (ConfigurableApplicationContext) BeanUtils.instantiateClass(contextClass);

    }

SpringApplication.class

private void prepareContext(ConfigurableApplicationContext context,

            ConfigurableEnvironment environment, SpringApplicationRunListeners listeners,

            ApplicationArguments applicationArguments, Banner printedBanner) {

        //设置容器环境，包括各种变量

        context.setEnvironment(environment);

        //设置上下文的 bean 生成器和资源加载器

        postProcessApplicationContext(context);

        //执行容器中的ApplicationContextInitializer（包括 spring.factories和自定义的实例）

        applyInitializers(context);

        //触发所有 SpringApplicationRunListener 监听器的 contextPrepared 事件方法

        listeners.contextPrepared(context);

        //记录启动日志

        if (this.logStartupInfo) {

            logStartupInfo(context.getParent() == null);

            logStartupProfileInfo(context);

        }

        // Add boot specific singleton beans

        //注册启动参数bean，这里将容器指定的参数封装成bean，注入容器

        ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();

        beanFactory.registerSingleton("springApplicationArguments", applicationArguments);

        if (printedBanner != null) {

            beanFactory.registerSingleton("springBootBanner", printedBanner);

        }

        if (beanFactory instanceof DefaultListableBeanFactory) {

            ((DefaultListableBeanFactory) beanFactory).setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);

        }

        // Load the sources

        // 加载所有资源

        Set<Object> sources = getAllSources();

        Assert.notEmpty(sources, "Sources must not be empty");

        //加载我们的启动类，将启动类注入容器,为后续开启自动化配置奠定基础

        load(context, sources.toArray(new Object[0]));

        //触发所有 SpringApplicationRunListener 监听器的 contextLoaded 事件方法

        listeners.contextLoaded(context);

    }

BeanDefinitionLoader.class

private int load(Object source) {

        Assert.notNull(source, "Source must not be null");

        // 如果是 Class 类型，则使用 AnnotatedBeanDefinitionReader 执行加载

        if (source instanceof Class<?>) {

            return load((Class<?>) source);

        }

        // 如果是 Resource 类型，则使用 XmlBeanDefinitionReader 执行加载

        if (source instanceof Resource) {

            return load((Resource) source);

        }

        // 如果是 Package 类型，则使用 ClassPathBeanDefinitionScanner 执行加载

        if (source instanceof Package) {

            return load((Package) source);

        }

        // 如果是 CharSequence 类型，则各种尝试去加载

        if (source instanceof CharSequence) {

            return load((CharSequence) source);

        }

        // 无法处理的类型，抛出 IllegalArgumentException 异常

        throw new IllegalArgumentException("Invalid source type " + source.getClass());

    }

public void refresh() throws BeansException, IllegalStateException {

        synchronized (this.startupShutdownMonitor) {

            // Prepare this context for refreshing.

            // 第一步 刷新前的预处理

            prepareRefresh();

            // Tell the subclass to refresh the internal bean factory.

            // 第二步 1.创建BeanFactory实例，默认实现是DefaultListableBeanFactory

            //       2.解析XML中的<bean>为BeanDefition 并注册到 BeanDefitionRegistry

            ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

            // Prepare the bean factory for use in this context.

            // 第三步 BeanFactory的预准备⼯作（BeanFactory进⾏⼀些设置，⽐如context的类加载器等）

            prepareBeanFactory(beanFactory);

            try {

                // Allows post-processing of the bean factory in context subclasses.

                // 第四步 BeanFactory准备工作完成后的后置处理工作,钩子方法，等子类重写

                postProcessBeanFactory(beanFactory);

                // Invoke factory processors registered as beans in the context.

                // 第五步 实例化并调⽤实现了BeanFactoryPostProcessor接⼝的Bean

                // 提前初始化工厂后置处理器bean，并调用postProcessBeanFactory方法

                //其中BeanFactoryPostProcessor比较重要的一个ConfigurationClassPostProcessor在这里调用，

                //用来遍历BeanDefinitionRegistry中现有的BeanDefinition解析@Import、@Configuration

                // 、@ComponentScan等注解将注解覆盖到的类也注册到BeanDefinitionRegistry中

                invokeBeanFactoryPostProcessors(beanFactory);

                // Register bean processors that intercept bean creation.

                // 第六步 注册BeanPostProcessor（Bean的后置处理器），在创建bean的前后等执

                registerBeanPostProcessors(beanFactory);

                // Initialize message source for this context.

                // 第七步 初始化MessageSource组件（做国际化功能；消息绑定，消息解析）；

                initMessageSource();

                // Initialize event multicaster for this context.

                // 第八步 初始化事件派发器

                initApplicationEventMulticaster();

                // Initialize other special beans in specific context subclasses.

                // 第九步 ⼦类重写这个⽅法，在容器刷新的时候可以⾃定义逻辑，钩子方法

                onRefresh();

                // Check for listener beans and register them.

                // 第十步 注册应⽤的监听器。就是注册实现了ApplicationListener接⼝的监听器bean

                registerListeners();

                // Instantiate all remaining (non-lazy-init) singletons.

                // 第十一步 初始化所有剩下的⾮懒加载的单例bean

                //1）.初始化创建⾮懒加载⽅式的单例Bean实例（未设置属性）

                //2）.填充属性

                //3) .如果bean实现了Aware相关接口,则调用Aware接口的实现方法

                //4) .调用BeanPostProcessor处理器的前置方法

                //5）.初始化⽅法调⽤（⽐如调⽤afterPropertiesSet⽅法、init-method⽅法）

                //6）.调⽤BeanPostProcessor（后置处理器）对实例bean进⾏后置处

                finishBeanFactoryInitialization(beanFactory);

                // Last step: publish corresponding event.

                // 第十二步 完成context的刷新。主要是调⽤LifecycleProcessor的onRefresh()⽅法，并且发布事件 （ContextRefreshedEvent）

                finishRefresh();

            }

            catch (BeansException ex) {

                if (logger.isWarnEnabled()) {

                    logger.warn("Exception encountered during context initialization - " +

                            "cancelling refresh attempt: " + ex);

                }

                // Destroy already created singletons to avoid dangling resources.

                destroyBeans();

                // Reset 'active' flag.

                cancelRefresh(ex);

                // Propagate exception to caller.

                throw ex;

            }

            finally {

                // Reset common introspection caches in Spring's core, since we

                // might not ever need metadata for singleton beans anymore...

                resetCommonCaches();

            }

        }

    }

ConfigurationClassPostProcessor.class

public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {

        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);

        }

        this.registriesPostProcessed.add(registryId);

        // 核心方法

        processConfigBeanDefinitions(registry);

    }

public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {

        List<BeanDefinitionHolder> 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直接return

        // Return immediately if no @Configuration classes were found

        if (configCandidates.isEmpty()) {

            return;

        }

        // Sort by previously determined @Order value, if applicable

        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 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();

        }

        // Parse each @Configuration class

        ConfigurationClassParser parser = new ConfigurationClassParser(

                this.metadataReaderFactory, this.problemReporter, this.environment,

                this.resourceLoader, this.componentScanBeanNameGenerator, registry);

        Set<BeanDefinitionHolder> candidates = new LinkedHashSet<>(configCandidates);

        Set<ConfigurationClass> alreadyParsed = new HashSet<>(configCandidates.size());

        do {

            // 核心解析方法

            parser.parse(candidates);

            parser.validate();

            Set<ConfigurationClass> configClasses = new LinkedHashSet<>(parser.getConfigurationClasses());

            configClasses.removeAll(alreadyParsed);

            // Read the model and create bean definitions based on its content

            if (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<String> oldCandidateNames = new HashSet<>(Arrays.asList(candidateNames));

                Set<String> 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());

        // 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();

        }

    }

public void parse(Set<BeanDefinitionHolder> configCandidates) {

        for (BeanDefinitionHolder holder : configCandidates) {

            BeanDefinition bd = holder.getBeanDefinition();

            try {

                if (bd instanceof AnnotatedBeanDefinition) {

                    // 注解解析BeanDefinition核心方法

                    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 void processConfigurationClass(ConfigurationClass configClass) throws IOException {

        if (this.conditionEvaluator.shouldSkip(configClass.getMetadata(), ConfigurationPhase.PARSE_CONFIGURATION)) {

            return;

        }

        ConfigurationClass existingClass = this.configurationClasses.get(configClass);

        if (existingClass != null) {

            if (configClass.isImported()) {

                if (existingClass.isImported()) {

                    existingClass.mergeImportedBy(configClass);

                }

                // Otherwise ignore new imported config class; existing non-imported class overrides it.

                return;

            }

            else {

                // Explicit bean definition found, probably replacing an import.

                // Let's remove the old one and go with the new one.

                this.configurationClasses.remove(configClass);

                this.knownSuperclasses.values().removeIf(configClass::equals);

            }

        }

        // Recursively process the configuration class and its superclass hierarchy.

        SourceClass sourceClass = asSourceClass(configClass);

        do {

            // 解析核心方法

            sourceClass = doProcessConfigurationClass(configClass, sourceClass);

        }

        while (sourceClass != null);

        this.configurationClasses.put(configClass, configClass);

    }

ConfigurationClassParser.class

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);

        }

        //解析@PropertySource注解

        // 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");

            }

        }

        // 解析@ComponentScan注解

        // Process any @ComponentScan annotations

        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注解

        // Process any @Import annotations

        processImports(configClass, sourceClass, getImports(sourceClass), true);

        // 解析@ImportResource注解

        // 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);

            }

        }

        // 解析@Bean注解

        // Process individual @Bean methods

        Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(sourceClass);

        for (MethodMetadata methodMetadata : beanMethods) {

            configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));

        }

        // Process default methods on interfaces

        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;

    }

public void handle(ConfigurationClass configClass, DeferredImportSelector importSelector) {

            DeferredImportSelectorHolder holder = new DeferredImportSelectorHolder(

                    configClass, importSelector);

            if (this.deferredImportSelectors == null) {

                DeferredImportSelectorGroupingHandler handler = new DeferredImportSelectorGroupingHandler();

                handler.register(holder);

                // 核心方法

                handler.processGroupImports();

            }

            else {

                this.deferredImportSelectors.add(holder);

            }

        }

public void processGroupImports() {

            for (DeferredImportSelectorGrouping grouping : this.groupings.values()) {

                //getImports()中调用了AutoConfigurationImportSelector.AutoConfigurationGroup.class中的process和selectImports

                grouping.getImports().forEach(entry -> {

                    ConfigurationClass configurationClass = this.configurationClasses.get(

                            entry.getMetadata());

                    try {

                        processImports(configurationClass, asSourceClass(configurationClass),

                                asSourceClasses(entry.getImportClassName()), false);

                    }

                    catch (BeanDefinitionStoreException ex) {

                        throw ex;

                    }

                    catch (Throwable ex) {

                        throw new BeanDefinitionStoreException(

                                "Failed to process import candidates for configuration class [" +

                                        configurationClass.getMetadata().getClassName() + "]", ex);

                    }

                });

            }

        }