SpringBoot——启动与自动配置类查找

今天学习一下SpringBoot的启动及自动配置，由于没有参与过springBoot项目开发，

所以初次学习的主要目标：将SpringBoot中的自动配置与启动与之前学习的Spring与SpringMVC实现联系起来。弄清楚SpringBoot中的：

• SpringIOC容器初始化(怎样实现自动配置的)
• SpringAOP支持
• Spring事务支持
• SpringMVC组件初始化
• Tomcat启动

 一、SpringBoot启动流程

@SpringBootApplication
public class App
{

    public static void main( String[] args )
    {
        //springboot应用启动
        SpringApplication.run(App.class,args);
    }
}

/* 
 * org.springframework.boot.SpringApplication#run()
 */
    public static ConfigurableApplicationContext run(Class<?>[] primarySources,
            String[] args) {
        return new SpringApplication(primarySources).run(args);
    }

1、SpringApplication的初始化

     初始化了6个属性：

• resourceLoader：资源加载器，初始化时一般为null
• primarySources：启动时配置文件Configuration
• webApplicationType：容器类型；
• initalizers：实例化多个与容器初始化有关的组件；
• listeners：实例化多个应用监听器；
• mainApplicationClass：main方法所在的类的Class实例。

    public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
        //null
        this.resourceLoader = resourceLoader;
        Assert.notNull(primarySources, "PrimarySources must not be null");
        //启动时配置Configuration
        this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
        //容器类型,三个枚举类型，判断顺序
        // ① 反应式web容器：WebApplicationType.REACTIVE：项目工程中包含DispatcherHandler.class，不包含DispatcherServlet.class、ServletContainer.class
        // ② 不是web应用：WebApplicationType.NONE：项目工程中不包含ConfigurableWebApplicationContext.class、Servlet.class
        // ③ 响应式web容器：WebApplicationType.SERVLET：不是上面两种情况，则响应式web容器启动
        this.webApplicationType = WebApplicationType.deduceFromClasspath();
        //实例化多个与IOC容器初始化有关的组件
        // 具体实例化所有jar包下的/META-INF/spring.factories文件中，ApplicationContextInitializer.class全限定名指定的class数组中所以Class
        setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
        //实例化多个应用监听器
        // 具体实例化所有jar包下的/META-INF/spring.factories文件中，ApplicationListener.class全限定名指定的class数组中所以Class
        setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
        //main方法所在的类的Class实例
        this.mainApplicationClass = deduceMainApplicationClass();
    }

先介绍下getSpringFactorieInstances()方法：springboot中SPI（服务发现接口）机制的实现，主要是根据/META-INF/spring.factories中寻找并创建对应的服务实例。

    private <T> Collection<T> getSpringFactoriesInstances(Class<T> type, Class<?>[] parameterTypes, Object... args) {
        //获取类加载器，(SPI打破类加载的双亲委派模型)
        ClassLoader classLoader = getClassLoader();
        // 从所用/META-INF/spring.factories中找到type对应的class集合，后面SpringFactoriesLoader是Spring-core.java中的类。
        Set<String> names = new LinkedHashSet<>(SpringFactoriesLoader.loadFactoryNames(type, classLoader));
        // 实例化class类型集合（parameterTypers：class的有参构造器中参数类型；args：构造器传参）
        List<T> instances = createSpringFactoriesInstances(type, parameterTypes, classLoader, args, names);
        //优先级排序（BeanFactoryPostProcessor时提到过的顺序：先PriorityOrdered，后Ordered,其他）
        AnnotationAwareOrderComparator.sort(instances);
        return instances;
    }

例如上面的：getSpringFactoriesInstances(ApplicationListener.class)

//spring-boot-autoconfigure.jar/META-INF/spring.factories
//Application Listeners
org.springframework.context.ApplicationListener=
org.springframework.boot.autoconfigure.BackgroundPreinitializer

2、SpringApplication.run()运行的流程

    public ConfigurableApplicationContext run(String... args) {
        // ① 简单的秒表，记录服务启动到关闭的时间
        StopWatch stopWatch = new StopWatch();
        stopWatch.start();
        ConfigurableApplicationContext context = null;
        // ② 异常记录器  spring.factories中SpringBootExceptionReporter.class对应的类型实例
        //   org.springframework.boot.diagnostics.FailureAnalyzers的实例
        Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();
        // ③ 启动抽象窗口工具包支持：java.awt.headless = true
        //   无显示设备，鼠标，键盘时，awt+Swing可进行窗口编程（window+frame等）
        configureHeadlessProperty();
        // ③ 应用监听器  spring.factories中SpringApplicationRunListener.class对应的类型实例
        //   org.springframework.boot.context.event.EventPublishingRunListener实例
        SpringApplicationRunListeners listeners = getRunListeners(args);
        listeners.starting();
        try {
            ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
            // ④ 初始化环境变量
            //   根据上面容器类型创建对应的创建变量实例
            //   设置defaultProperties(springApplication.set)、args(命令行参数)、profiles(spring.profiles.active)属性
            //    绑定环境变量到监听器+spring.main(默认当前SpringApplication实例)
            ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments);
            // 设置spring.beaninfo.ignore（默认true）到环境变量中
            configureIgnoreBeanInfo(environment);
            // 打印/不打印环境到控制台、日志
            Banner printedBanner = printBanner(environment);
            // ⑤ 根据对应容器类型创建容器
            //   响应式web容器：AnnotationConfigServletWebServerApplicationContext
            //   ① 父类的构造方法中创建DefaultListableBeanFactory
            //   ② reader 注册注解注入的Bean后置处理器到IOC容器中AutowiredAnnotationBeanPostProcessor
            //     BeanFactory后置处理器ConfigurationClassPostProcessor,后面发现这个就是自动配置实现的类
            //   ③ scanner 设置环境变量、resourceLoader、includeFilters（Spring的@Component+JDK的@Named）
            context = createApplicationContext();
            exceptionReporters = getSpringFactoriesInstances(SpringBootExceptionReporter.class,
                    new Class[] { ConfigurableApplicationContext.class }, context);
            //⑥ 初始化容器context的一部分属性
            //  ① 环境变量覆盖
            //  ② 将容器绑定到初始化组件(initializers)、监听器(listeners)中//  ③ 注册单例 命令行参数的包装实例applicationArguments、printedBanner
            //  ④ 设置懒加载则注册懒加载BeanFactory后置处理器 LazyInitializationBeanFactoryPostProcessor
            //  ⑤ 不允许BeanDefinition覆盖
            //  ⑥ 将配置resource（包括MainClass）加载到容器中，MainClass(App.class)解析成一个AnnotatedGenericBeanDefinition
            //  ⑦ 将listeners中ApplicationContextListener类型的监听器注册到容器中
            prepareContext(context, environment, listeners, applicationArguments, printedBanner);
            //⑦ 容器初始化 主要是AnnotationConfigServletWebServerApplicationContext的父类
            //            ServletWebServerApplicationContext,这个第三节研究
            refreshContext(context);
            //⑧ 空方法
            afterRefresh(context, applicationArguments);
            stopWatch.stop();
            if (this.logStartupInfo) {
                // 打印日志
                new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), stopWatch);
            }
            //监听器启动
            listeners.started(context);
            //唤醒runners
            callRunners(context, applicationArguments);
        }
        catch (Throwable ex) {
            handleRunFailure(context, ex, exceptionReporters, listeners);
            throw new IllegalStateException(ex);
        }

        try {
            //监听器运行
            listeners.running(context);
        }
        catch (Throwable ex) {
            //监听器关闭
            handleRunFailure(context, ex, exceptionReporters, null);
            throw new IllegalStateException(ex);
        }
        return context;
    }

小结：熟悉了大致流程：发现核心的实现还是在⑦ 容器初始化中：refreshContext()。

• 容器的初始化
• tomcat的嵌入
• 两个组件initalizers、listeners的作用

3、Springboot容器初始化——refreshContext()

refreshContext() : 容器初始化+优雅停机

/* org.springframework.boot.SpringApplication#refreshContext */
    private void refreshContext(ConfigurableApplicationContext context) {
        //容器初始化
        refresh((ApplicationContext) context);
        if (this.registerShutdownHook) {
            try {
                // JDK的shutdownHook关闭钩子,
                // 作用：优雅停机。调用系统退出方法（关机注销）时，线程还在跑,但不提供服务，设定一个超时时间，到时间后停机。
                // kill pid（注意：不能kill -9 pid）
                context.registerShutdownHook();
            }
            catch (AccessControlException ex) {
                // Not allowed in some environments.
            }
        }
    }

    protected void refresh(ApplicationContext applicationContext) {
        Assert.isInstanceOf(ConfigurableApplicationContext.class, applicationContext);
        //容器初始化
        refresh((ConfigurableApplicationContext) applicationContext);
    }

    protected void refresh(ConfigurableApplicationContext applicationContext) {
        //容器初始化
        //AnnotationConfigServletWebServerApplicationContext.refresh()
        applicationContext.refresh();
    }

AnnotationConfigServletWebServerApplicationContext.refresh()，

 查看AnnotationConfigServletWebServerApplicationContext的类图，发现springboot相比于spring实现了一个ServletWebServerApplicationContext

如果观看AnnotationConfigservletWebServerApplicationContext源码，发现具体逻辑实现都在ServletWebServerApplicationContext中，所以主要学习ServletWebServerApplicationContext的源码:ServletWebServerApplicationContext.refresh();

/* org.springframework.boot.web.servlet.context.ServletWebServerApplicationContext#refresh  */
    public final void refresh() throws BeansException, IllegalStateException {
        try {
            //AbstractApplicationContext.refresh()
            super.refresh();
        }
        catch (RuntimeException ex) {
            //关闭释放web服务（tomcat、jetty等）
            stopAndReleaseWebServer();
            throw ex;
        }
    }

结合之前的SpringIOC——refresh()分析，装饰者模式(继承实现)有对哪些模块有增强。先给出AbstractApplicationContext.refresh()。仅说明增强功能。

    public void refresh() throws BeansException, IllegalStateException {
        synchronized (this.startupShutdownMonitor) {
            // ② IOC初始化前的装备(配置环境参数、创建监听器、事件容器)
            // 增强：scanner缓存清理
            prepareRefresh();
            ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
            prepareBeanFactory(beanFactory);

            try {
                // 彻底重写
                postProcessBeanFactory(beanFactory);
                invokeBeanFactoryPostProcessors(beanFactory);
                registerBeanPostProcessors(beanFactory);
                initMessageSource();
                initApplicationEventMulticaster();

                //增强：初始化了一个web服务:createWebServer（tomcat、jetty等），并启动
                onRefresh();
                registerListeners();
                finishBeanFactoryInitialization(beanFactory);

               //增强：webServer未启动时，重新启动
                finishRefresh();
            }

            catch (BeansException ex) {
                if (logger.isWarnEnabled()) {
                    logger.warn("Exception encountered during context initialization - " +
                            "cancelling refresh attempt: " + ex);
                }

                destroyBeans();
                cancelRefresh(ex);
                throw ex;
            }

            finally {
                resetCommonCaches();
            }
        }
    }    

综上：找到了tomcat启动的位置，但是没有找到自动配置的位置，可能是postProcessBeanFactory(beanFactory)

/* org/springframework/boot/web/servlet/context/ServletWebServerApplicationContext */
    protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
        //注册了一个Bean后置处理器WebApplicationContextServletContextAwareProcessor
        //这个Bean后置处理器逻辑很简单：仅有一个前置方法
        // servletContextAware类型的bean，bean.set(servletContext)
        // servletConfigAware类型的bean,bean.set(servletConfig)
        beanFactory.addBeanPostProcessor(new WebApplicationContextServletContextAwareProcessor(this));
        //忽略实现接口ServletContextAware的Bean
        //跟上面的Bean后置处理器冲突，应该是版本升级加的吧
        beanFactory.ignoreDependencyInterface(ServletContextAware.class);
        registerWebApplicationScopes();
    }

    private void registerWebApplicationScopes() {
        // 允许用户自定义scope（不能与自带的singleton，prototype冲突）
        // 注册web的作用域scope（session、request）
        // 将scope注册进IOC容器中
        ExistingWebApplicationScopes existingScopes = new ExistingWebApplicationScopes(getBeanFactory());
        WebApplicationContextUtils.registerWebApplicationScopes(getBeanFactory());
        existingScopes.restore();
    }

综上：还是没有找到自动配置实现的地方，只能IDEA debug一行一行的找了，最终发现

invokeBeanFactoryPostProcessors(beanFactory)：这一行执行完，容器中多了100多个BeanDefinition，也就是说是BeanFactory的后置处理器实现自动配置的。

最终找到了ConfigurationClassPostProcessor，这个BeanFactoryPostProcessor是在AnnotationConfigservletWebServerApplicationContext初始化时注册入到容器中的

/* org.springframework.boot.web.servlet.context.AnnotationConfigServletWebServerApplicationContext#AnnotationConfigServletWebServerApplicationContext() */
    public AnnotationConfigServletWebServerApplicationContext() {
        this.reader = new AnnotatedBeanDefinitionReader(this);
        this.scanner = new ClassPathBeanDefinitionScanner(this);
    }

/*
 * 下面是spring-context.jar中的源码，也就是自动加载还是依托于spring源码实现的
 */

/* org.springframework.context.annotation.AnnotatedBeanDefinitionReader#AnnotatedBeanDefinitionReader(org.springframework.beans.factory.support.BeanDefinitionRegistry, org.springframework.core.env.Environment) */
    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);
    }

/*org.springframework.context.annotation.AnnotationConfigUtils#registerAnnotationConfigProcessors(org.springframework.beans.factory.support.BeanDefinitionRegistry, java.lang.Object) */
    public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
            BeanDefinitionRegistry registry, @Nullable Object source) {

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

        Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>(8);

        if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {
            //BeanFactory后置处理器：会对class上的@Configuration、@ComponentScan、@Component、@Import、@ImportResource注解解析
            RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
            def.setSource(source);
            beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
        }

        if (!registry.containsBeanDefinition(AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
            //Bean后置处理器：在bean实例化后实现依赖注入的（@Autowired注解）
            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.
        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.
        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));
        }

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

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

ConfigurationClassPostProcessor.processConfigBeanDefinitions():解析@Configuration注解类中的@Bean到容器BeanDefinition容器中（属于Spring的源码）

二、自动配置

 自动配置配置代码有点复杂，主要看看@SpringBootApplication的实现

1、@SpringBootApplication注解

@SpringBootApplication是一个组合注解，主要是@SpringBootConfiguration+@EnableAutoConfiguration+@ComponentScan

 

 @SpringBootConfiguration == @Configuration

 @EnableAutoConfiguration = @AutoConfigurationPackage +@Import(AutoConfigurationImportSelector.class)

 @AutoConfigurationPackage = @Import(AutoConfigurationPackages.Registrar.class)

 综上：@SpringBootApplication =  @Configuration + @Import(AutoConfigurationPackages.Registrar.class)+@Import(AutoConfigurationImportSelector.class)+@ComponentScan

顺序ConfigurationClassPostProcessor找到@ComponentScan、@Import的解析

ConfigurationClassPostProcessor.processConfigBeanDefinitions()-->parser.parse(candidates)

ConfigurationClassParser.parse-->ConfigurationClassParser.processConfigurationClass->ConfigurationClassParser.doProcessConfigurationClass()

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

        if (configClass.getMetadata().isAnnotated(Component.class.getName())) {
            // Recursively process any member (nested) classes first
            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");
            }
        }

        // 处理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
                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)) {
                        //如果bdCand也被@Configuration注解，解析
                        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);
            }
        }

        // 处理@Configuration中的@Bean注解
        Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(sourceClass);
        for (MethodMetadata methodMetadata : beanMethods) {
            configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
        }

        // 处理接口默认的方法  @Import(AutoConfigurationPackages.Registrar.class)
        // AutoConfigurationPackages.Registrar 的接口有默认方法,
        // 将MainClass的basePackage封装成一个BeanDefinition放入到IOC容器中，并不是扫描basePackage，仅仅是一个记录的作用
        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();
            }
        }

        return null;
    }    

@ComponentScan注解解析：

basePackage/basePackageClasses未设置时，扫描@ComponentScan所注解的类所在的包下的所有class文件，

@Component注解的class文件，生成BeanDefinition放入IOC容器中

SpringBoot未配置basePackage、basePackageClasses，所以会扫描MainClass所在包下的所有class文件。

    public Set<BeanDefinitionHolder> parse(AnnotationAttributes componentScan, final String declaringClass) {
        //@ComponentScan注解对应一个ClassPathBeanDefinitionScanner实例
        //setUserDefaultFilters：是否使用默认过滤器Filters，默认使用
        ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(this.registry,
                componentScan.getBoolean("useDefaultFilters"), this.environment, this.resourceLoader);

        //setBeanNameGenerator：设置默认的beanName生成器，默认使用BeanNameGenerator.class
        Class<? extends BeanNameGenerator> generatorClass = componentScan.getClass("nameGenerator");
        boolean useInheritedGenerator = (BeanNameGenerator.class == generatorClass);
        scanner.setBeanNameGenerator(useInheritedGenerator ? this.beanNameGenerator :
                BeanUtils.instantiateClass(generatorClass));

        //setScopedProxyMode：设置是否为检测组件生成代理
        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));
        }

        //setResourcePattern：扫描包下源文件格式 默认"**/*.class"
        scanner.setResourcePattern(componentScan.getString("resourcePattern"));

        //includeFilter：扫描组件过滤器，符合includeFilter条件的类，生成BeanDefinition
        for (AnnotationAttributes filter : componentScan.getAnnotationArray("includeFilters")) {
            for (TypeFilter typeFilter : typeFiltersFor(filter)) {
                scanner.addIncludeFilter(typeFilter);
            }
        }
        //excludeFilter：扫描组件反向过滤器，符合excludeFilter条件的类，不生成BeanDefinition
        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);
        }

        //扫描的包basePackages下class文件
        Set<String> basePackages = new LinkedHashSet<>();
        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所在包下class文件
        for (Class<?> clazz : componentScan.getClassArray("basePackageClasses")) {
            basePackages.add(ClassUtils.getPackageName(clazz));
        }
        //如果basePackages，basePackageClasses未设置，
        // 扫描@ComponentScan所注解的类所在包下的class文件：
        // 这里就是Springboot扫描MainClass同包下的Bean的原因
        if (basePackages.isEmpty()) {
            basePackages.add(ClassUtils.getPackageName(declaringClass));
        }

        scanner.addExcludeFilter(new AbstractTypeHierarchyTraversingFilter(false, false) {
            @Override
            protected boolean matchClassName(String className) {
                return declaringClass.equals(className);
            }
        });
        //scanner.do(basePackages):熟悉的spring源码，扫描basePackages下的class文件(includeFilters = @Component)生成组件
        return scanner.doScan(StringUtils.toStringArray(basePackages));
    }

@Import解析：

• DeferredImportSelector放入容器ConfigurationClassParser中的deferredImportSelectors中
  
• ImportBeanDefinitionRegistrar放入ConfigurationClass的importBeanDefinitionRegistrars容器中
  
• 其他类型@Import==@Configuration处理

/* org.springframework.context.annotation.ConfigurationClassParser#processImports */
    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 {
                for (SourceClass candidate : importCandidates) {
                    if (candidate.isAssignable(ImportSelector.class)) {
                        //@Import()指定类型是ImportSelector类型
                        Class<?> candidateClass = candidate.loadClass();
                        //初始化ImportSelector实例
                        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);
                        }
                        if (selector instanceof DeferredImportSelector) {
                            // 指定类型再细分为DeferredImportSelector类型
                            // springboot的注解@Import(AutoConfigurationImportSelector.class)
                            // 将AutoConfigurationImportSelector实例放入到
                            // ConfigurationClassParser中的deferredImportSelectors容器中
                            this.deferredImportSelectorHandler.handle(configClass, (DeferredImportSelector) selector);
                        }
                        else {
                            String[] importClassNames = selector.selectImports(currentSourceClass.getMetadata());
                            Collection<SourceClass> importSourceClasses = asSourceClasses(importClassNames, exclusionFilter);
                            processImports(configClass, currentSourceClass, importSourceClasses, exclusionFilter, false);
                        }
                    }
                    else if (candidate.isAssignable(ImportBeanDefinitionRegistrar.class)) {
                        //@Import()指定类型是ImportBeanDefinitionRegistrar类型时
                        //springboot的注解@Import(AutoConfigurationPackages.Registrar.class)
                        Class<?> candidateClass = candidate.loadClass();
                        //创建一个ImportBeanDefinitionRegistrar实例，
                        // 放入到ConfigurationClass的importBeanDefinitionRegistrars容器中
                        // ConfigurationClass是@Configuration注解的类的元数据+beanName的封装类型
                        ImportBeanDefinitionRegistrar registrar =
                                ParserStrategyUtils.instantiateClass(candidateClass, ImportBeanDefinitionRegistrar.class,
                                        this.environment, this.resourceLoader, this.registry);
                        configClass.addImportBeanDefinitionRegistrar(registrar, currentSourceClass.getMetadata());
                    }
                    else {
                        // 指定类不是上两种类型，将@Import视为@Configuration处理
                        this.importStack.registerImport(
                                currentSourceClass.getMetadata(), candidate.getMetadata().getClassName());
                        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();
            }
        }
    }

@Import+@ComponentScan解析完，后退到ConfigurationClassParser.parse方法

    public void parse(Set<BeanDefinitionHolder> configCandidates) {
        for (BeanDefinitionHolder holder : configCandidates) {
            BeanDefinition bd = holder.getBeanDefinition();
            try {
                if (bd instanceof AnnotatedBeanDefinition) {
                    //@注解解析（@PropertySource、@ComponentScan、@Import、@ImportResource）
                    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);
            }
        }
        //springboot自动配置
        this.deferredImportSelectorHandler.process();
    }

this.deferredImportSelectorHandler.process();

 调用AutoConfigurationImportSelector.selectImports()方法返回/META-INF/spring.factories中EnableAutoConfiguration对应的class数组

将每个文件视作为一个@Configuration注解的class文件进行解析，解析生成BeanDefinition

/* org.springframework.context.annotation.ConfigurationClassParser.DeferredImportSelectorHandler#process */
public void process() {
            List<DeferredImportSelectorHolder> deferredImports = this.deferredImportSelectors;
            this.deferredImportSelectors = null;
            try {
                if (deferredImports != null) {
                    DeferredImportSelectorGroupingHandler handler = new DeferredImportSelectorGroupingHandler();
                    deferredImports.sort(DEFERRED_IMPORT_COMPARATOR);
                    deferredImports.forEach(handler::register);
                    handler.processGroupImports();
                }
            }
            finally {
                this.deferredImportSelectors = new ArrayList<>();
            }
        }

/* org.springframework.context.annotation.ConfigurationClassParser.DeferredImportSelectorGroupingHandler#register*/
        public void register(DeferredImportSelectorHolder deferredImport) {
            //调用ImportSelector.getImportGroup返回group类型
            //springboot: AutoConfigurationImportSelector.getImportGroup==AutoConfigurationGroup.class
            Class<? extends Group> group = deferredImport.getImportSelector().getImportGroup();
            //将group转换成一个DeferredImportSelectorGrouping类型grouping
            DeferredImportSelectorGrouping grouping = this.groupings.computeIfAbsent(
                    (group != null ? group : deferredImport),
                    key -> new DeferredImportSelectorGrouping(createGroup(group)));
            //将deferredImport放入到grouping.deferredImports容器中
            //这里还是回忆一下springboot的deferredImport是AutoConfigurationImportSelector、ConfigurationClass的封装器
            grouping.add(deferredImport);
            //将ConfigurationClass放入到ConfigurationClasses容器中，
            //springboot：MainClass放入到ConfigurationClasses容器中
            this.configurationClasses.put(deferredImport.getConfigurationClass().getMetadata(),
                    deferredImport.getConfigurationClass());
        }

/* org.springframework.context.annotation.ConfigurationClassParser.DeferredImportSelectorGroupingHandler#processGroupImports */
        public void processGroupImports() {
            for (DeferredImportSelectorGrouping grouping : this.groupings.values()) {
                Predicate<String> exclusionFilter = grouping.getCandidateFilter();
                //grouping.getImports() == <configurationClass,importSelect.selectImports(configurationClass)>
                //selectImports(configurationClass) ==SpringFactoriesLoader.loadFactoryNames(EnableAutoConfiguration.class, getBeanClassLoader())
                //即这里遍历的是/MATE-INF/spring.factories中EnableAutoConfiguration对应的class数组
                //将每个class视作为一个@Import注解解析
                // ①  class是ImportSelector类型，加入到ConfigurationClassParser中的deferredImportSelectors容器中
                // ②  ImportBeanDefinitionRegistrar，放入到ConfigurationClass的importBeanDefinitionRegistrars容器中
                // ③  不是上面两种类型，就视为一个@Configuration注解的配置文件类解析
                grouping.getImports().forEach(entry -> {
                    ConfigurationClass configurationClass = this.configurationClasses.get(entry.getMetadata());
                    try {
                        processImports(configurationClass, asSourceClass(configurationClass, exclusionFilter),
                                Collections.singleton(asSourceClass(entry.getImportClassName(), exclusionFilter)),
                                exclusionFilter, false);
                    }
                    catch (BeanDefinitionStoreException ex) {
                        throw ex;
                    }
                    catch (Throwable ex) {
                        throw new BeanDefinitionStoreException(
                                "Failed to process import candidates for configuration class [" +
                                        configurationClass.getMetadata().getClassName() + "]", ex);
                    }
                });
            }
        }

最后看下AutoConfigurationImportSelector.selectImports()实现

/* org.springframework.boot.autoconfigure.AutoConfigurationImportSelector#selectImports */
    public String[] selectImports(AnnotationMetadata annotationMetadata) {
        if (!isEnabled(annotationMetadata)) {
            return NO_IMPORTS;
        }
        AutoConfigurationMetadata autoConfigurationMetadata = AutoConfigurationMetadataLoader.loadMetadata(this.beanClassLoader);
        AutoConfigurationEntry autoConfigurationEntry = getAutoConfigurationEntry(autoConfigurationMetadata, annotationMetadata);
        return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
    }

    protected AutoConfigurationEntry getAutoConfigurationEntry( AutoConfigurationMetadata autoConfigurationMetadata, AnnotationMetadata annotationMetadata) {
        if (!isEnabled(annotationMetadata)) {
            return EMPTY_ENTRY;
        }
        AnnotationAttributes attributes = getAttributes(annotationMetadata);
        List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes);
        configurations = removeDuplicates(configurations);
        Set<String> exclusions = getExclusions(annotationMetadata, attributes);
        checkExcludedClasses(configurations, exclusions);
        configurations.removeAll(exclusions);
        //@Condition注解筛选
        configurations = filter(configurations, autoConfigurationMetadata);
        fireAutoConfigurationImportEvents(configurations, exclusions);
        return new AutoConfigurationEntry(configurations, exclusions);
    }


    protected List<String> getCandidateConfigurations(AnnotationMetadata metadata,
            AnnotationAttributes attributes) {
        List<String> configurations = SpringFactoriesLoader.loadFactoryNames(
                getSpringFactoriesLoaderFactoryClass(), getBeanClassLoader());
        Assert.notEmpty(configurations,
                "No auto configuration classes found in META-INF/spring.factories. If you "
                        + "are using a custom packaging, make sure that file is correct.");
        return configurations;
    }

    protected Class<?> getSpringFactoriesLoaderFactoryClass() {
        return EnableAutoConfiguration.class;
    }

spring-boot-autoconfigure-2.1.3.RELEASE.jar!/META-INF/spring.factories中自动配置class数组

总共有118个class,列举spring相关的自动配置

org.springframework.boot.autoconfigure.EnableAutoConfiguration=
org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration,
org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,
org.springframework.boot.autoconfigure.context.ConfigurationPropertiesAutoConfiguration,
org.springframework.boot.autoconfigure.context.MessageSourceAutoConfiguration,
org.springframework.boot.autoconfigure.context.PropertyPlaceholderAutoConfiguration,
org.springframework.boot.autoconfigure.data.jdbc.JdbcRepositoriesAutoConfiguration,
org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration,
org.springframework.boot.autoconfigure.jdbc.JdbcTemplateAutoConfiguration,
org.springframework.boot.autoconfigure.jdbc.JndiDataSourceAutoConfiguration,
org.springframework.boot.autoconfigure.jdbc.XADataSourceAutoConfiguration,
org.springframework.boot.autoconfigure.jdbc.DataSourceTransactionManagerAutoConfiguration,
org.springframework.boot.autoconfigure.web.servlet.DispatcherServletAutoConfiguration,
org.springframework.boot.autoconfigure.web.servlet.ServletWebServerFactoryAutoConfiguration,
org.springframework.boot.autoconfigure.web.servlet.error.ErrorMvcAutoConfiguration,
org.springframework.boot.autoconfigure.web.servlet.HttpEncodingAutoConfiguration,
org.springframework.boot.autoconfigure.web.servlet.MultipartAutoConfiguration,
org.springframework.boot.autoconfigure.web.servlet.WebMvcAutoConfiguration,

 118个class并不是都有效，还需要经过@Condition中条件筛选

/* org.springframework.boot.autoconfigure.AutoConfigurationImportSelector#filter */
    private List<String> filter(List<String> configurations,
            AutoConfigurationMetadata autoConfigurationMetadata) {
        long startTime = System.nanoTime();
        String[] candidates = StringUtils.toStringArray(configurations);
        boolean[] skip = new boolean[candidates.length];
        boolean skipped = false;
        //注意filters也是在spring.factories中指定的
        //默认三个OnBeanCondition，OnClassCondition，OnWebApplicationCondition即只有三个注解有效@ConditionOnBean @ConditionOnClass @ConditionOnWebApplication
        for (AutoConfigurationImportFilter filter : getAutoConfigurationImportFilters()) {
            invokeAwareMethods(filter);
            //Condition条件判断
            boolean[] match = filter.match(candidates, autoConfigurationMetadata);
            for (int i = 0; i < match.length; i++) {
                if (!match[i]) {
                    skip[i] = true;//没通过的打标true
                    candidates[i] = null;
                    skipped = true;
                }
            }
        }
        if (!skipped) {
            //所有class都满足各自的Condition
            return configurations;
        }
        List<String> result = new ArrayList<>(candidates.length);
        for (int i = 0; i < candidates.length; i++) {
            if (!skip[i]) {
                //满足条件的Bean才会被视为配置文件（@Configuration）解析
                result.add(candidates[i]);
            }
        }
        if (logger.isTraceEnabled()) {
            int numberFiltered = configurations.size() - result.size();
            logger.trace("Filtered " + numberFiltered + " auto configuration class in "
                    + TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - startTime)
                    + " ms");
        }
        return new ArrayList<>(result);
    }

条件过滤是有顺序：（追究这个好像没什么意义，最终Condition都生效了......）

1、先select过滤：在调用AutoConfigurationImportSelector.filters时仅仅只检测@ConditionOnClass @ConditionOnBean @ConditionOnWebApplication三个条件

2、后class上的@Condition过滤：这个时候类上的@ConditionalOnProperty才会生效

以AopAutoConfiguration为例

@Configuration
@ConditionalOnClass({ EnableAspectJAutoProxy.class, Aspect.class, Advice.class,AnnotatedElement.class })
@ConditionalOnProperty(prefix = "spring.aop", name = "auto", havingValue = "true", matchIfMissing = true)
public class AopAutoConfiguration {
...
}

将spring.aop.auto = false，依然扫描进了configurations中，后续类加载时，@ConditionOnProperty才生效

 三、总结

1、springboot主动注解配置，是依赖spring源码中BeanFactory的后置处理器ConfigurationClassPostProcessor实现的，这个后置处理器是在ApplicationContext的构造方法中注入到IOC容器中的，ConfigurationClassPostProcessor会处理解析5个注解@Configuration、@Import、@ImportResource、@Component、@ComponentScan。

2、@SpringBootApplication = @Configuration+@ComponentScan+@Import（AutoConfigurationImportSelector.class） +@Import（AutoConfigurationPackages.Registrar.class）

• @Configuration：主要是一个属性proxyBeanMethods：默认开启（true），允许其他类调用@Bean注解的方法，为false的话，不允许则想要一个@Bean注解的类型只能自己初始化一个。
• @ComponentScan：springboot扫描MainClass所在包下的class文件。这个标签basePackages、basePackageClasses未指定时，扫描注解类（MainClass）所在package下的所有class文件到IOC容器中。
• @Import（AutoConfigurationImportSelector.class）：自动配置的核心。会调用selector.selectImports(medata)方法，获取/META-INF/spring.factories文件中的EnableAutoConfiguration映射的class数组，class数组就是配置类的集合。（可视为每个类被@Configuration注解）。
• @Import（AutoConfigurationPackages.Registrar.class）：注册basePackage为一个BeanDefinition到容器中。注意仅仅是记录basePackage，不会进行包扫描，包扫描由上面的@ComponentScan实现

3、springboot的SPI机制：对应文件/META-INF/spring.factories，所有的自动发现并加载的类都配置在这里面。这也是springboot热拔插的原因，直接依赖jar包，就可以使用redis，kafka等中间件，通过spring.factories+@ConditionOnClass(判断Class是否存在 == 是否引入jar包)来发现中间件的Bean，例如RedisTemplate等

4、spring的启动顺序：

① initalizers+listeners+webType

② 异常记录器exceptionReporters +headless模式

③ 初始化环境变量environment（命令行参数+spring.profiles.active+系统环境变量path）

④ printbanner日志横幅

⑤ 根据webType创建对应的容器ApplicationContext，

⑥ initalizers+listeners+environment与容器ApplicationContext的互相绑定

⑦ 容器启动（允许自定义scope，重写AbstarctApplicationContext的onRefresh，开启tomcat服务）

四、遗留问题

1、知道了怎么找到配置类，但是属性自动注入还没有弄清楚

2、知道tomcat启动的地方，但嵌入细节不知道，开启一个后台线程吗？

五、补充

1、SpringBoot自定义的注解@ConditionOnClass等