SpringBoot系列—Run启动原理（十八）

作者: 海晨忆 | 来源:发表于2019-11-11 17:26 被阅读0次

SpringBoot系列—Run启动原理（十八）
SpringBoot2.2.6启动run方法之refreshCo
SpringBoot2.2.6启动run方法之prepareCo
SpringBoot启动原理
springboot启动（2） -- 启动流程
使用IDEA搭建SpringBoot多环境多配置文件
SpringBoot Jar包启动原理
SpringBoot自动装配原理分析笔记
SpringBoot源码学习系列之嵌入式Servlet容器
springboot源码之自动装备原理

个人博客：haichenyi.com。感谢关注

需要搞清楚几个重要的事件回调机制

配置在META-INF/spring.factories

ApplicationContextInitializer
SpringApplicationRunListener

只需要放在ioc容器中

ApplicationRunner
CommandLineRunner

新建一个空项目，就勾选web，找到启动类，每个方法上面写的注释，可以看一下：

@SpringBootApplication
public class SellApplication {

    public static void main(String[] args) {
        SpringApplication.run(SellApplication.class, args);
    }

}

//上面run方法点进来
public static ConfigurableApplicationContext run(Class<?> primarySource, String... args) {
        return run(new Class<?>[] { primarySource }, args);
    }

public static ConfigurableApplicationContext run(Class<?>[] primarySources, String[] args) {
        return new SpringApplication(primarySources).run(args);
    }

看到这里，就应该看到了，启动流程分为两步

创建SpringApplication对象
运行run方法

创建SpringApplication对象

//上面的构造方法点进去
//这里与1.5版本不一样的地方就是，
//2.X这里调用了重载的构造方法，而1.5这里调用的是一个initialize()方法，这个方法里面的内容，与下面两个参数的重载方法差不多
public SpringApplication(Class<?>... primarySources) {
        this(null, primarySources);
    }

//下面这个就是this调用的重载的构造方法
@SuppressWarnings({ "unchecked", "rawtypes" })
public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
        this.resourceLoader = resourceLoader;
        //保存主配置类，1.5里面这里有个非空判断，用if做的，这里换成的断言做判断
        Assert.notNull(primarySources, "PrimarySources must not be null");
        this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
        //判断当前是否一个web应用
        this.webApplicationType = WebApplicationType.deduceFromClasspath();
        //从类路径下找到META‐INF/spring.factories配置的所有ApplicationContextInitializer；然后保存起 来
        setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
        //从类路径下找到ETA‐INF/spring.factories配置的所有ApplicationListener
        setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
        //从多个配置类中找到有main方法的主配置类
        this.mainApplicationClass = deduceMainApplicationClass();
    }

setInitializers()方法

看方法名就知道，这个是初始化方法，初始化什么东西呢？再看传的参数ApplicationContextInitializer，就是一开始我们提到的类。我们看这个是怎么获取的

//第一步：
private SpringApplicationRunListeners getRunListeners(String[] args) {
        Class<?>[] types = new Class<?>[] { SpringApplication.class, String[].class };
        return new SpringApplicationRunListeners(logger,
                getSpringFactoriesInstances(SpringApplicationRunListener.class, types, this, args));
}

//第二步：
private <T> Collection<T> getSpringFactoriesInstances(Class<T> type, Class<?>[] parameterTypes, Object... args) {
        ClassLoader classLoader = getClassLoader();
        // Use names and ensure unique to protect against duplicates
        //看这里的导入方法SpringFactoriesLoader.loadFactoryNames(type, classLoader)
        Set<String> names = new LinkedHashSet<>(SpringFactoriesLoader.loadFactoryNames(type, classLoader));
        List<T> instances = createSpringFactoriesInstances(type, parameterTypes, classLoader, args, names);
        AnnotationAwareOrderComparator.sort(instances);
        return instances;
    }
    
//第三步：
public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) {
        String factoryTypeName = factoryType.getName();
        return loadSpringFactories(classLoader).getOrDefault(factoryTypeName, Collections.emptyList());
    }

//第四步，就是这里了。看这里面的实现
private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {
        MultiValueMap<String, String> result = cache.get(classLoader);
        if (result != null) {
            return result;
        }

        try {
        //一眼看过去。很明显，这里就是classLoader.getResources()，导入的本地的资源。看这个传的参数,我放到这个方法下面去了
            Enumeration<URL> urls = (classLoader != null ?
                    classLoader.getResources(FACTORIES_RESOURCE_LOCATION) :
                    ClassLoader.getSystemResources(FACTORIES_RESOURCE_LOCATION));
            result = new LinkedMultiValueMap<>();
            //这里通过一个while循环，加载本地配置的ApplicationContextInitializer
            while (urls.hasMoreElements()) {
                URL url = urls.nextElement();
                UrlResource resource = new UrlResource(url);
                Properties properties = PropertiesLoaderUtils.loadProperties(resource);
                for (Map.Entry<?, ?> entry : properties.entrySet()) {
                    String factoryTypeName = ((String) entry.getKey()).trim();
                    for (String factoryImplementationName : StringUtils.commaDelimitedListToStringArray((String) entry.getValue())) {
                        result.add(factoryTypeName, factoryImplementationName.trim());
                    }
                }
            }
            cache.put(classLoader, result);
            return result;
        }
        catch (IOException ex) {
            throw new IllegalArgumentException("Unable to load factories from location [" +
                    FACTORIES_RESOURCE_LOCATION + "]", ex);
        }
    }
    
/**
 * The location to look for factories.
 * <p>Can be present in multiple JAR files.
 */
public static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories";

所以，从上面的源码，我们一步一步点击进去看，我们就能发现，他最终都是加载到 META-INF/spring.factories 目录下的 ApplicationContextInitializer 当然，到目前为止这里只是初始化

setListeners()方法

一眼就能看出来，这里是设置监听方法

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

一眼看过去，这个setListener方法传的参数熟不熟悉？就是我们上面初始化的时候传的参数是同一个方法。所以，这里设置监听设置哪些监听方法也是META-INF/spring.factories 目录下的listener方法，我们看一下这个文件内容：

spring_factories.png

这些都是是自动配置类的内容

运行Run方法

public ConfigurableApplicationContext run(String... args) {
        StopWatch stopWatch = new StopWatch();
        stopWatch.start();
        ConfigurableApplicationContext context = null;
        Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();
        configureHeadlessProperty();
        //获取SpringApplicationRunListeners；从类路径下META‐INF/spring.factories
        SpringApplicationRunListeners listeners = getRunListeners(args);
        //回调所有的获取SpringApplicationRunListener.starting()方法
        listeners.starting();
        try {
            //封装命令行参数
            ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
            //准备环境，创建环境完成后回调SpringApplicationRunListener.environmentPrepared()；表示环境准 备完成
            ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments);
            //这里是新增的，点击去看，就是再properties文件中配置你需要忽略的bean
            configureIgnoreBeanInfo(environment);
            //这个是打印spring的logo banner图
            Banner printedBanner = printBanner(environment);
            /创建ApplicationContext；这个下面有下介绍
            context = createApplicationContext();
            //看一下参数，这个就是做异常报告处理的
            exceptionReporters = getSpringFactoriesInstances(SpringBootExceptionReporter.class,
                    new Class[] { ConfigurableApplicationContext.class }, context);
                    
            //准备上下文环境;将environment保存到ioc中；而且applyInitializers()；
            //applyInitializers()：回调之前保存的所有的ApplicationContextInitializer的initialize方法
            //回调所有的SpringApplicationRunListener的contextPrepared()；  
            //prepareContext运行完成以后回调所有的SpringApplicationRunListener的contextLoaded()；
            prepareContext(context, environment, listeners, applicationArguments, printedBanner);
            //s刷新容器；ioc容器初始化（如果是web应用还会创建嵌入式的Tomcat）；Spring注解版
            //扫描，创建，加载所有组件的地方；（配置类，组件，自动配置）
            refreshContext(context);
            //2.x里面是空方法
            afterRefresh(context, applicationArguments);
            stopWatch.stop();
            if (this.logStartupInfo) {
                new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), stopWatch);
            }
            listeners.started(context);
            
            //从ioc容器中获取所有的ApplicationRunner和CommandLineRunner进行回调 //ApplicationRunner先回调，CommandLineRunner再回调
            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);
        }
        //返回这个IOC容器
        return context;
    }

getRunListeners()方法

我们看到上面第一个有注释的位置：getRunListeners方法

private SpringApplicationRunListeners getRunListeners(String[] args) {
        Class<?>[] types = new Class<?>[] { SpringApplication.class, String[].class };
        return new SpringApplicationRunListeners(logger,
                getSpringFactoriesInstances(SpringApplicationRunListener.class, types, this, args));
}

方法熟悉吗？就是我们上面初始化的时候调用的那个方法，只是这里的参数传的是：SpringApplicationRunListener,我们看最开始说的，这就是我们要了解的第二个内容，回调都是怎么调用的

方法里面的注释也写了，先获取监听事件，然后回调starting方法，我们看一下这个接口有那些回调方法：

public interface SpringApplicationRunListener {

    default void starting() {
    }
    
    default void environmentPrepared(ConfigurableEnvironment environment) {
    }
    
    default void contextPrepared(ConfigurableApplicationContext context) {
    }

    default void contextLoaded(ConfigurableApplicationContext context) {
    }

    default void started(ConfigurableApplicationContext context) {
    }

    default void running(ConfigurableApplicationContext context) {
    }

    default void failed(ConfigurableApplicationContext context, Throwable exception) {
    }

}

就这些回调，这里还用了1.8的新特性，default关键字，接口里面的方法可以有方法体

prepareEnvironment()

看到第二个写注释的位置，眼熟吗？可不就是跟上面回调方法名字相同么？我们点进去看一下

private ConfigurableEnvironment prepareEnvironment(SpringApplicationRunListeners listeners,
            ApplicationArguments applicationArguments) {
        // Create and configure the environment
        ConfigurableEnvironment environment = getOrCreateEnvironment();
        configureEnvironment(environment, applicationArguments.getSourceArgs());
        ConfigurationPropertySources.attach(environment);
        
        //这里划重点，这里就调用的environmentPrepared的回调方法
        listeners.environmentPrepared(environment);
        bindToSpringApplication(environment);
        if (!this.isCustomEnvironment) {
            environment = new EnvironmentConverter(getClassLoader()).convertEnvironmentIfNecessary(environment,
                    deduceEnvironmentClass());
        }
        ConfigurationPropertySources.attach(environment);
        return environment;
    }

准备完环境之后，调用environmentPrepared的回调

createApplicationContext()

protected ConfigurableApplicationContext createApplicationContext() {
        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);
            }
        }
        return (ConfigurableApplicationContext) BeanUtils.instantiateClass(contextClass);
    }

创建applicationContext，这里跟1.5不一样，1.5就只有两种：一种是web的ioc容器，一种是默认的ioc容器。2.X这里有三种：DEFAULT_CONTEXT_CLASS，DEFAULT_SERVLET_WEB_CONTEXT_CLASS，DEFAULT_REACTIVE_WEB_CONTEXT_CLASS，实际字符串比较长，可以去看一下源码。然后用BeanUtils通过反射创建。

prepareContext()方法

private void prepareContext(ConfigurableApplicationContext context, ConfigurableEnvironment environment,
            SpringApplicationRunListeners listeners, ApplicationArguments applicationArguments, Banner printedBanner) {
        //将environment放到context中
        context.setEnvironment(environment);
        postProcessApplicationContext(context);
        //初始化
        applyInitializers(context);
        //这里回调contextPrepared方法
        listeners.contextPrepared(context);
        if (this.logStartupInfo) {
            logStartupInfo(context.getParent() == null);
            logStartupProfileInfo(context);
        }
        // Add boot specific singleton beans
        ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
        beanFactory.registerSingleton("springApplicationArguments", applicationArguments);
        if (printedBanner != null) {
            beanFactory.registerSingleton("springBootBanner", printedBanner);
        }
        if (beanFactory instanceof DefaultListableBeanFactory) {
            ((DefaultListableBeanFactory) beanFactory)
                    .setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
        }
        if (this.lazyInitialization) {
            context.addBeanFactoryPostProcessor(new LazyInitializationBeanFactoryPostProcessor());
        }
        // Load the sources
        Set<Object> sources = getAllSources();
        Assert.notEmpty(sources, "Sources must not be empty");
        load(context, sources.toArray(new Object[0]));
        //这里回调contextLoaded()方法
        listeners.contextLoaded(context);
    }

准备上下文环境;将environment保存到ioc中；而且applyInitializers()

protected void applyInitializers(ConfigurableApplicationContext context) {
        for (ApplicationContextInitializer initializer : getInitializers()) {
            Class<?> requiredType = GenericTypeResolver.resolveTypeArgument(initializer.getClass(),
                    ApplicationContextInitializer.class);
            Assert.isInstanceOf(requiredType, context, "Unable to call initializer.");
            initializer.initialize(context);
        }
    }

这里就将我们一开始从配置文件里面读取，然后创建ApplicationContextInitializer初始化。

当环境准备好之后，就回调了SpringApplicationRunListener的contextPrepared()；

当所有的都准备好了之后，回调SpringApplicationRunListener的contextLoaded()；

到这里，所有的环境都准备好了，需要打印的logo也加进去了。

refreshContext()

刷新容器这个方法，我们可以点到具体的功能实现里面，可以看到，这里就是扫描，创建，加载所有的组件，配置类，组件，自动配置等。

到这里，这个方法创建完之后，所有的控制器就创建完了，所有的组件，bean等，都在控制台打印出来了。如果是web应用，还会创建嵌入式的tomcat。我们spring boot项目内嵌tomcat，就是在这里创建的。

afterRefresh()

1.5版本这个方法里面回调的是callRunners方法，而2.X版本，现在这是个空方法里面并没有实现。callRunners被提出来了，放到了最后面。

started(),running()

在1.5版本这里，也就是afterRefresh()之后，应该是调用的SpringApplicationRunListeners的finished()方法。

在2.X版本之后，去掉了finished方法，改成了调用started方法，然后调用running方法。我们上面有一个starting方法，从这里名字就可以看出来，相当于，首先是正在启动当中，然后就是启动完成了，正在运行了。

callRunners()

private void callRunners(ApplicationContext context, ApplicationArguments args) {
        List<Object> runners = new ArrayList<>();
        runners.addAll(context.getBeansOfType(ApplicationRunner.class).values());
        runners.addAll(context.getBeansOfType(CommandLineRunner.class).values());
        AnnotationAwareOrderComparator.sort(runners);
        for (Object runner : new LinkedHashSet<>(runners)) {
            if (runner instanceof ApplicationRunner) {
                callRunner((ApplicationRunner) runner, args);
            }
            if (runner instanceof CommandLineRunner) {
                callRunner((CommandLineRunner) runner, args);
            }
        }
    }

从IOC容器中(不是配置文件)获取所有的的ApplicationRunner和CommandLineRunner进行回调。这也是最开始说的两个注意的地方

并且，这里有个先后顺序，先回调的ApplicationRunner，后回调的CommandLineRunner

这里也是run方法，最后执行的地方。从这里就是真正的开启了run。

最后一步，返回那个context就是返回IOC容器对象。到这里，我们的spring boot就启动完成了。

这就是我们的spring boot的启动原理。初始化，listener的回调，Runner的回调都说的很清楚。

SpringBoot系列—Run启动原理（十八）
个人博客：haichenyi.com。感谢关注需要搞清楚几个重要的事件回调机制配置在META-INF/sp...
SpringBoot2.2.6启动run方法之refreshCo
SpringBoot2.2.6启动run方法之refreshContext 前言此系列是针对springboot...
SpringBoot2.2.6启动run方法之prepareCo
SpringBoot2.2.6启动run方法之prepareContext 前言此系列是针对springboot...
SpringBoot启动原理
SpringBoot启动流程详细分析 1. SpringBoot原理 SpringBoot run 会创建一个io...
springboot启动（2） -- 启动流程
根据springboot启动（1）的分析，springboot真正启动从应用主类main方法开始，其run方法中由...
使用IDEA搭建SpringBoot多环境多配置文件
启动SpringBoot 打开SpringBootApplication启动类，鼠标右键RUN项，或者Ctrl+S...
SpringBoot Jar包启动原理
SpringBoot Jar包启动原理
SpringBoot自动装配原理分析笔记
首先，springboot项目是根据springbootApplication.run方法启动的，启动的时候，它会...
SpringBoot源码学习系列之嵌入式Servlet容器
SpringBoot源码学习系列之嵌入式Servlet容器启动原理 @[toc] 1、博客前言简单介绍 Sprin...
springboot源码之自动装备原理
上节我们了解了springboot的应用的启动原理,其所有的核心都在run方法里,来看一段简单的代码: 还是原来的...

SpringBoot系列—Run启动原理（十八）

创建SpringApplication对象

setInitializers()方法

setListeners()方法

运行Run方法

getRunListeners()方法

prepareEnvironment()

createApplicationContext()

prepareContext()方法

refreshContext()

afterRefresh()

started(),running()

callRunners()

相关文章

SpringBoot系列—Run启动原理（十八）

SpringBoot2.2.6启动run方法之refreshCo

SpringBoot2.2.6启动run方法之prepareCo

SpringBoot启动原理

springboot启动（2） -- 启动流程

使用IDEA搭建SpringBoot多环境多配置文件

SpringBoot Jar包启动原理

SpringBoot自动装配原理分析笔记

SpringBoot源码学习系列之嵌入式Servlet容器

springboot源码之自动装备原理

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

java后台