首页 > > 程序设计 > Java技术 >

spring-boot-2.0.3不一样系列之源码篇 - run方法…

2018-09-29 04:03:30来源：博客园 阅读 ()

新老客户大回馈,云服务器低至5折

前言

　　此系列是针对springboot的启动，旨在于和大家一起来看看springboot启动的过程中到底做了一些什么事。如果大家对springboot的源码有所研究，可以挑些自己感兴趣或者对自己有帮助的看；但是如果大家没有研究过springboot的源码，不知道springboot在启动过程中做了些什么，那么我建议大家从头开始一篇一篇按顺序读该系列，不至于从中途插入，看的有些懵懂。当然，文中讲的不对的地方也欢迎大家指出，有待改善的地方也希望大家不吝赐教。老规矩：一周至少一更，中途会不定期的更新一些其他的博客，可能是springboot的源码，也可能是其他的源码解析，也有可能是其他的。

　　路漫漫其修远兮，吾将上下而求索！

　　github：https://github.com/youzhibing

　　码云(gitee)：https://gitee.com/youzhibing

前情回顾

　　大家还记得上篇博文讲了什么吗，或者说大家知道上篇博文讲了什么吗。这里帮大家做个简单回顾：

　　　　创建web应用上下文，对其部分属性：reader、scanner、beanFactory进行了实例化；reader中实例化了属性conditionEvaluator；scanner中添加了两个AnnotationTypeFilter：一个针对@Component，一个针对@ManagedBean；beanFactory中注册了8个注解配置处理器的Bean。应用上下文类型实际上是AnnotationConfigServletWebServerApplicationContext，beanFactory的类型是DefaultListableBeanFactory，这两个类型的类图大家重点看下，既是上篇博文的重点，也是接下来系列博客的基点。创建上下文的过程其实还创建了environment，本文中会涉及到environment，大家请留意。

　　　　通过createApplicationContext方法之后，context的包含的主要内容如下：

prepareContext

　　先欣赏下我们的战绩，看看我们对run方法完成了多少的源码解读

/**
 * Run the Spring application, creating and refreshing a new
 * {@link ApplicationContext}.
 * @param args the application arguments (usually passed from a Java main method)
 * @return a running {@link ApplicationContext}
 */
public ConfigurableApplicationContext run(String... args) {
    // 秒表，用于记录启动时间；记录每个任务的时间，最后会输出每个任务的总费时
    StopWatch stopWatch = new StopWatch();
    stopWatch.start();
    // spring应用上下文，也就是我们所说的spring根容器
    ConfigurableApplicationContext context = null;
    // 自定义SpringApplication启动错误的回调接口
    Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();
    // 设置jdk系统属性java.awt.headless，默认情况为true即开启
    configureHeadlessProperty();
    // 获取启动时监听器(EventPublishingRunListener实例)
    SpringApplicationRunListeners listeners = getRunListeners(args)
    // 触发ApplicationStartingEvent事件，启动监听器会被调用，一共5个监听器被调用，但只有两个监听器在此时做了事
    listeners.starting(); 
    try {
        // 参数封装，也就是在命令行下启动应用带的参数，如--server.port=9000
        ApplicationArguments applicationArguments = new DefaultApplicationArguments(
                args);
        // 准备环境：1、加载外部化配置的资源到environment；2、触发ApplicationEnvironmentPreparedEvent事件
        ConfigurableEnvironment environment = prepareEnvironment(listeners,
                applicationArguments);
        // 配置spring.beaninfo.ignore，并添加到名叫systemProperties的PropertySource中；默认为true即开启
        configureIgnoreBeanInfo(environment);
        // 打印banner图
        Banner printedBanner = printBanner(environment);
        // 创建应用上下文，并实例化了其三个属性：reader、scanner和beanFactory
        context = createApplicationContext();
        // 获取异常报道器，即加载spring.factories中的SpringBootExceptionReporter实现类
        exceptionReporters = getSpringFactoriesInstances(
                SpringBootExceptionReporter.class,
                new Class[] { ConfigurableApplicationContext.class }, context);
        // 准备上下文，本文重点
        prepareContext(context, environment, listeners, applicationArguments,
                printedBanner);
        refreshContext(context);
        afterRefresh(context, applicationArguments);
        stopWatch.stop();
        if (this.logStartupInfo) {
            new StartupInfoLogger(this.mainApplicationClass)
                    .logStarted(getApplicationLog(), stopWatch);
        }
        listeners.started(context);
        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;
}
View Code

　　前菜

　　　　exceptionReporters = getSpringFactoriesInstances(SpringBootExceptionReporter.class,new Class[] { ConfigurableApplicationContext.class }, context);

　　　　　　getSpringFactoriesInstances这个方法在之前已经讲过，就是加载META-INF/spring.factories中指定类型的bean集合。如下图

　　　　SpringBootExceptionReporter是一个回调接口，用于支持对SpringApplication启动错误的自定义报告。

　　　　先根据SpringBootExceptionReporter获取FailureAnalyzers的全限定类名，实例化FailureAnalyzers的时候，再次调用SpringFactoriesLoader.loadFactoryNames方法获取类型为FailureAnalyzer的名称列表，然后再根据名称列表实例化bean列表。

　　　　bean列表创建好之后，设置bean列表中满足条件的bean的beanFactory和environment，同时也将部分bean应用到context的environment和beanFactory中，代码如下

private void prepareFailureAnalyzers(List<FailureAnalyzer> analyzers,
        ConfigurableApplicationContext context) {
    for (FailureAnalyzer analyzer : analyzers) {
        prepareAnalyzer(context, analyzer);
    }
}

private void prepareAnalyzer(ConfigurableApplicationContext context,
        FailureAnalyzer analyzer) {
    if (analyzer instanceof BeanFactoryAware) {
        ((BeanFactoryAware) analyzer).setBeanFactory(context.getBeanFactory());
    }
    if (analyzer instanceof EnvironmentAware) {
        ((EnvironmentAware) analyzer).setEnvironment(context.getEnvironment());
    }
}
View Code

　　　　其中NoSuchBeanDefinitionFailureAnalyer bean的setBeanFactory方法

@Override
public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
    Assert.isInstanceOf(ConfigurableListableBeanFactory.class, beanFactory);
    this.beanFactory = (ConfigurableListableBeanFactory) beanFactory;
    this.metadataReaderFactory = new CachingMetadataReaderFactory(
            this.beanFactory.getBeanClassLoader());
    // Get early as won't be accessible once context has failed to start
    this.report = ConditionEvaluationReport.get(this.beanFactory);        // 往beanFactory中注册autoConfigurationReport
}
View Code

　　　　　　往beanFactory中注册一个名叫autoConfigurationReport的单例bean（类型是ConditionEvaluationReport），这个bean用于后面自动配置条件评估的详情报告与日志记录。

　　　　exceptionReporters 获取成功后，我们来看看beanFactory的变化

　　正餐

　　　　prepareContext内容不多，源代码如下

private void prepareContext(ConfigurableApplicationContext context,
        ConfigurableEnvironment environment, SpringApplicationRunListeners listeners,
        ApplicationArguments applicationArguments, Banner printedBanner) {
    // 设置上下文的environment
    context.setEnvironment(environment);
    // 应用上下文后处理
    postProcessApplicationContext(context);
    // 在context refresh之前，对其应用ApplicationContextInitializer
    applyInitializers(context);
    // 上下文准备（目前是空实现，可用于拓展）
    listeners.contextPrepared(context);
    // 打印启动日志和启动应用的Profile
    if (this.logStartupInfo) {
        logStartupInfo(context.getParent() == null);
        logStartupProfileInfo(context);
    }

    // Add boot specific singleton beans
    context.getBeanFactory().registerSingleton("springApplicationArguments",
            applicationArguments);                                // 向beanFactory注册单例bean：命令行参数bean
    if (printedBanner != null) {
        // 向beanFactory注册单例bean：banner bean
        context.getBeanFactory().registerSingleton("springBootBanner", printedBanner);
    }

    // Load the sources
    Set<Object> sources = getAllSources();                        // 获取全部资源，其实就一个：SpringApplication的primarySources属性
    Assert.notEmpty(sources, "Sources must not be empty");        // 断言资源是否为空
    // 将bean加载到应用上下文中
    load(context, sources.toArray(new Object[0]));
    // 向上下文中添加ApplicationListener，并广播ApplicationPreparedEvent事件
    listeners.contextLoaded(context);
}
View Code

　　　　我们逐个方法来看

　　　　context.setEnvironment(environment)

/**
 * {@inheritDoc}
 * <p>
 * Delegates given environment to underlying {@link AnnotatedBeanDefinitionReader} and
 * {@link ClassPathBeanDefinitionScanner} members.
 */
@Override
public void setEnvironment(ConfigurableEnvironment environment) {
    super.setEnvironment(environment);            // 设置context的environment
    this.reader.setEnvironment(environment);    // 实例化context的reader属性的conditionEvaluator属性
    this.scanner.setEnvironment(environment);    // 设置context的scanner属性的environment属性
}
View Code

　　　　　　将context中相关的environment全部替换成SpringApplication中创建的environment。还记得这篇中的疑问吗，引申下就是：之前我们的应用中有两个environment，一个在context中，一个在SpringApplication中。经过此方法后，就只会存在SpringApplication中的environment了，而context中的原environment会被回收。

　　　　postProcessApplicationContext(context);

/**
 * Apply any relevant post processing the {@link ApplicationContext}. Subclasses can
 * apply additional processing as required.
 * @param context the application context
 */
protected void postProcessApplicationContext(ConfigurableApplicationContext context) {
    if (this.beanNameGenerator != null) {
        context.getBeanFactory().registerSingleton(
                AnnotationConfigUtils.CONFIGURATION_BEAN_NAME_GENERATOR,
                this.beanNameGenerator);
    }
    if (this.resourceLoader != null) {
        if (context instanceof GenericApplicationContext) {
            ((GenericApplicationContext) context)
                    .setResourceLoader(this.resourceLoader);
        }
        if (context instanceof DefaultResourceLoader) {
            ((DefaultResourceLoader) context)
                    .setClassLoader(this.resourceLoader.getClassLoader());
        }
    }
}
View Code

　　　　　　上下文后处理。SpringApplication子类可以根据需要应用其他处理。

　　　　　　由于当前SpringApplication实例的属性：beanNameGenerator和resourceLoader都为null，所以此方法目前相当于什么也没做。此方法可能是我们定制SpringApplication所用。

　　　　applyInitializers(context);

/**
 * Apply any {@link ApplicationContextInitializer}s to the context before it is
 * refreshed.
 * @param context the configured ApplicationContext (not refreshed yet)
 * @see ConfigurableApplicationContext#refresh()
 */
@SuppressWarnings({ "rawtypes", "unchecked" })
protected void applyInitializers(ConfigurableApplicationContext context) {
    for (ApplicationContextInitializer initializer : getInitializers()) {
        // 解析当前initializer实现的ApplicationContextInitializer的泛型参数
        Class<?> requiredType = GenericTypeResolver.resolveTypeArgument(
                initializer.getClass(), ApplicationContextInitializer.class);
        // 断言context是否是requiredType的实例
        Assert.isInstanceOf(requiredType, context, "Unable to call initializer.");
        // 向context应用初始化器
        initializer.initialize(context);
    }
}
View Code

　　　　　　在context refresh之前应用ApplicationContextInitializer到context中。还记得SpringApplication的属性initializers吗，不记得的可以点这里。

　　　　　　一共6个initializer，他们的initialize方法都被调用，源代码就不跟了，上图中已经进行了展示，我们总结下

　　　　　　DelegatingApplicationContextInitializer

　　　　　　　　environment没有context.initializer.classes配置项，所以相当于没有做任何事。

　　　　　　　　如果配置了context.initializer.classes，获取其值（逗号分隔的initializer列表字符串），转换成class列表，根据classes列表进行实例化获取initializer实例列表，再对每个initializer实例调用initialize方法。

　　　　　　　　DelegatingApplicationContextInitializer相当于context.initializer.classes的代理，最终还是会执行到被代理的initializer的initialize方法。
　　　　　　ContextIdApplicationContextInitializer

　　　　　　　　设置application id：从environment中获取spring.application.name配置项的值，并把设置成application id，若没有配置spring.application.name，则取默认值application；

　　　　　　　　将application id封装成ContextId对象，注册到beanFactory中。

　　　　　　ConfigurationWarningsApplicationContextInitializer

　　　　　　　　向上下文注册了一个BeanFactoryPostProcessor：ConfigurationWarningsPostProcessor实例；

　　　　　　　　实例化ConfigurationWarningsPostProcessor的时候，也实例化了它的属性Check[] checks，check中只有一个类型是ComponentScanPackageCheck的实例。
　　　　　　ServerPortInfoApplicationContextInitializer

　　　　　　　　向上下文注册了一个ApplicationListener：ServerPortInfoApplicationContextInitializer对象自己；

　　　　　　　　ServerPortInfoApplicationContextInitializer实现了ApplicationListener<WebServerInitializedEvent>，所以他本身就是一个ApplicationListener。
　　　　　　SharedMetadataReaderFactoryContextInitializer

　　　　　　　　向context注册了一个BeanFactoryPostProcessor：CachingMetadataReaderFactoryPostProcessor实例。
　　　　　　ConditionEvaluationReportLoggingListener

　　　　　　　　将上下文赋值给自己的属性applicationContext；

　　　　　　　　向上下文注册了一个ApplicationListener：ConditionEvaluationReportListener实例；

　　　　　　　　从beanFactory中获取名为autoConfigurationReport的bean赋值给自己的属性report。

　　　　listeners.contextPrepared(context);

　　　　　　还记得SpringApplicationRunListeners中listeners属性吗，没错，里面就一个EventPublishingRunListener对象。

　　　　　　调用EventPublishingRunListener的contextPrepared，发现其是空实现。

　　　　　　也就是相当于啥事也没做。

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

　　　　　　创建了一个BeanDefinitionLoader对象；BeanDefinitionLoader作为AnnotatedBeanDefinitionReader，XmlBeanDefinitionReader和ClassPathBeanDefinitionScanner的门面，从底层源加载bean定义，包括XML和JavaConfig；

　　　　　　能被加载的source类型包括：Class、Resource、Package和CharSequence四种，每种类型的加载方式也不一样，Class用AnnotatedBeanDefinitionReader处理、Resource用XmlBeanDefinitionReader处理、Package用ClassPathBeanDefinitionScanner，而CharSequence则比较特殊了，它按Class、Resource、Package的顺序处理，哪种处理成功就按哪种处理（CharSequence方式貌似很少用，反正我还没用过）；

　　　　　　而目前我们的source只有一个：class com.lee.shiro.ShiroApplication，是class类型；先判断ShiroApplication是否有被component注解修饰，很显然是（SpringBootApplication注解中包含component注解），那么AnnotatedBeanDefinitionReader来处理：将com.lee.shiro.ShiroApplication封装成一个名叫ShiroApplication的BeanDefinition对象，并将其注册到了beanFactory的BeanDefinitionMap中。

　　　　listeners.contextLoaded(context);

　　　　　　还记得SpringApplication的属性listeners吗，不记得的可以点这里。将这些ApplicationListener注册到了上下文中，具体包括ConfigFileApplicationListener,AnsiOutputApplicationListener,LoggingApplicationListener,ClasspathLoggingApplicationListener,BackgroundPreinitializer,DelegatingApplicationListener,ParentContextCloserApplicationListener(实现了ApplicationContextAware接口；将上下文赋值给了属性context，相当于有了上下文的引用),ClearCachesApplicationListener,FileEncodingApplicationListener,LiquibaseServiceLocatorApplicationListener,EnableEncryptablePropertiesBeanFactoryPostProcessor。

　　　　　　广播ApplicationPreparedEvent事件，并触发对应的事件。过滤出匹配事件的监听器可以查看这里，一共过滤出5个监听器，他们的onApplicationEvent方法会被调用，具体做了如下事情：

　　　　　　　　ConfigFileApplicationListener

　　　　　　　　　　向context注册了一个BeanFactoryPostProcessor：PropertySourceOrderingPostProcessor实例；该实例后面会对我们的property sources进行重排序，另外该实例拥有上下文的引用。

　　　　　　　　LoggingApplicationListener

　　　　　　　　　　向beanFactory中注册了一个名叫springBootLoggingSystem的单例bean，也就是我们的日志系统bean。

　　　　　　　　BackgroundPreinitializer

　　　　　　　　　　目前什么也没做

　　　　　　　　DelegatingApplicationListener

　　　　　　　　　　目前什么也没做

　　　　　　　　EnableEncryptablePropertiesBeanFactoryPostProcessor

　　　　　　　　　　仅仅打印了一句debug日志，相当于什么也没做

　　甜点

　　　　一开始还以为本文内容不会多，但分析分析着，发现内容不少。不管我们是吃撑了还是没吃饱，都来点甜点收尾。

　　　　一般一个单例对象注册到beanFactory中，beanFactory会有2个属性都添加此单例对象信息：singletonObjects、registeredSingletons

　　　　　　Map<String, Object> singletonObjects = new ConcurrentHashMap<>()，key是bean name，value是单例对象

　　　　　　Set<String> registeredSingletons = new LinkedHashSet<>()，存放的是bean name

　　　　一般一个bean定义注册到beanFactory中是，beanFactory也会有2个属相会添加此bean定义信息：beanDefinitionMap、beanDefinitionNames　

　　　　　　List<String> beanDefinitionNames = new ArrayList<>()，beanDefinition的名称列表
　　　　　　Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>()，key是beanDefinition的名称，value是beanDefinition对象

　　　　另外beanFactory中Set<String> manualSingletonNames = new LinkedHashSet<>，按注册顺序存放手动注册的单例的名称。

　　　　load方法，我会放到另一篇博文中重点分析；load负责加载bean定义资源，应该是挺重要的，而本文却讲的比较粗糙，我们一起期待吧。

 

　　　　有时候，不是对手有多强大，只是我们不敢去尝试；勇敢踏出第一步，你会发现自己比想象中更优秀！诚如海因斯第一次跑进人类10s大关时所说：上帝啊，原来那扇门是虚掩着的！

总结

　　1、上文中的load

　　　　就是加载bean定义资源，支持4种方式：Class、Resource、Package和CharSequence。

　　　　Class：注解形式的Bean定义；AnnotatedBeanDefinitionReader负责处理。

　　　　Resource：一般而言指的是xml bean配置文件，也就是我们在spring中常用的xml配置。xml的加载大家可以去阅读《Spring源码深度解析》。说的简单点就是：将xml的bean定义封装成BeanDefinition并注册到beanFactory的BeanDefinitionMap中；XmlBeanDefinitionReader负责处理。

　　　　Package：以扫包的方式扫描bean定义； ClassPathBeanDefinitionScanner负责处理。

　　　　CharSequence：以先后顺序进行匹配Class、Resource或Package进行加载，谁匹配上了就用谁的处理方式处理。

　　　　当然还支持Groovy形式的Bean定义，有兴趣的朋友可以自行去跟下源代码。

　　　　springboot鼓励用java类实现java bean定义，所以springboot应用中，我们一般只需要关注Class方式、Package方式即可。

　　2、prepareContext到底做了什么　　　　

　　　　1、将context中的environment替换成SpringApplication中创建的environment
　　　　2、将SpringApplication中的initializers应用到context中
　　　　　　设置application id，并将application id封装成ContextId对象，注册到beanFactory中
　　　　　　向context的beanFactoryPostProcessors中注册了一个ConfigurationWarningsPostProcessor实例
　　　　　　向context的applicationListeners中注册了一个ServerPortInfoApplicationContextInitializer实例
　　　　　　向context的beanFactoryPostProcessors中注册了一个CachingMetadataReaderFactoryPostProcessor实例
　　　　　　向context的applicationListeners中注册了一个ConditionEvaluationReportListener实例

　　　　3、加载两个单例bean到beanFactory中

　　　　　　向beanFactory中注册了一个名叫springApplicationArguments的单例bean，该bean封装了我们的命令行参数；
　　　　　　向beanFactory中注册了一个名叫springBootBanner的单例bean。

　　　　4、加载bean定义资源
　　　　　　资源文件只有SpringApplication的primarySources集合，里面就一个资源类：com.lee.shiro.ShiroApplication；
　　　　　　将该资源封装成了名叫ShiroApplication的BeanDefinition对象，并将其注册到了beanFactory的BeanDefinitionMap中。
　　　　5、将SpringApplication中的listeners注册到context中，并广播ApplicationPreparedEvent事件
　　　　　　总共11个ApplicationListener注册到了context的applicationListeners中；
　　　　　　ApplicationPreparedEvent事件的监听器一共做了两件事
　　　　　　　　向context的beanFactoryPostProcessors中注册了一个PropertySourceOrderingPostProcessor实例
　　　　　　　　向beanFactory中注册了一个名叫springBootLoggingSystem的单例bean，也就是我们的日志系统bean

　　　　context中主要是三个属性增加了内容：beanFactory、beanFactoryPostProcessors和applicationListeners，到目前为止，context的内容如下

参考

　　《Spring源码深度解析》

　　Spring Boot Reference Guide　　

　　Spring boot 源码

标签：

版权申明：本站文章部分自网络，如有侵权，请联系：west999com@outlook.com
特别注意：本站所有转载文章言论不代表本站观点，本站所提供的摄影照片，插画，设计作品，如需使用，请与原作者联系，版权归原作者所有

上一篇：Hibernate学习笔记三

下一篇：简单说说SpringMVC

相关文章

IDC资讯： 主机资讯 注册资讯 托管资讯 vps资讯 网站建设

网站运营： 建站经验 策划盈利 搜索优化 网站推广 免费资源

网站联盟： 联盟新闻 联盟介绍 联盟点评 网赚技巧

行业资讯： 搜索引擎 网络游戏 电子商务 广告传媒

网络编程： Asp.Net编程 Asp编程 Php编程 Xml编程 Access Mssql Mysql 其它

服务器技术： Web服务器 Ftp服务器 Mail服务器 Dns服务器 安全防护

软件技巧： 其它软件 Word Excel Powerpoint Ghost Vista QQ空间 QQ FlashGet 迅雷

网页制作： FrontPages Dreamweaver Javascript css photoshop fireworks Flash

程序设计： Java技术 C/C++ VB delphi

网络知识： 网络协议 网络安全 网络管理 组网方案 Cisco技术

操作系统： Win2000 WinXP Win2003 Mac OS Linux FreeBSD

热门词条
最新资讯
热门关注
热门标签