Spring(三)核心容器 - ApplicationContext 上下文启动准备

目录

  • 前言
  • 正文
    • 第一步:prepareRefresh
    • 第二步:obtainFreshBeanFactory
    • 第三步:prepareBeanFactory
    • 第四步:postProcessBeanFactory
  • 总结

前言

前面介绍了 Spring 容器的概念,其核心可归纳为两个类: BeanFactory 和 ApplicationContext,ApplicationContext 继承自 BeanFactory ,其不仅包含 BeanFactory 所有功能,还扩展了容器功能。之后介绍了在 SSM 时期和 SpringBoot 时期如何启动 ApplicationContext 。在结尾处,我们指出,ApplicationContext 核心其实是 refresh 方法,容器一系列功能都在该方法中实现,如:注册 Bean、注入 Bean 等。

在 refresh 方法中,实现容器核心功能前,先进行了一系列环境准备工作,我们以 SpringBoot 为当前运行环境,深入讨论这部分内容。

注:本篇文章使用的 SpringBoot 版本为 2.0.3.RELEASE,其 Spring 版本为 5.0.7.RELEASE

正文

refresh 方法定义在 ConfigurableApplicationContext 接口中,被 AbstractApplicationContext 抽象类实现,该方法由十几个子方法组成,这些子方法各司其职,但部分子方法被 AbstractApplicationContext 的子类进行扩展,来增强功能。其中,前四个子方法主要进行上下文准备工作。

第一步:prepareRefresh

我们先从 refresh 中的 prepareRefresh 方法开始讨论:

public void refresh() throws BeansException, IllegalStateException {
    synchronized (this.startupShutdownMonitor) {
        // 初始化上下文环境,就是记录下容器的启动时间、活动状态等
        prepareRefresh();

        ...
    }
}

该方法被继承 AbstractApplicationContext 抽象类的子类进行扩展,扩展该方法的子类有:

因本次演示的环境是 SpringBoot ,前面我们讲过,SpringBoot 会根据当前 Web 应用类型创建不同的上下文对象 ,如 Servlet Web、Reactive Web 等。这里演示的是 Servlet Web 应用,所以创建的上下文对象是 AnnotationConfigServletWebServerApplicationContext 。该类的 prepareRefresh 方法会被执行:

public class AnnotationConfigServletWebServerApplicationContext
        extends ServletWebServerApplicationContext implements AnnotationConfigRegistry {

    ...

    @Override
    protected void prepareRefresh() {

        // 清除 Class 的元数据缓存。底层用 Map 保存元数据,执行 Map 的 clear 方法
        this.scanner.clearCache();

        // 调用父类,也就是 AbstractApplicationContext 的 prepareRefresh 方法
        super.prepareRefresh();
    }
    ...
}
public abstract class AbstractApplicationContext {

    ...

    private long startupDate;

    private final AtomicBoolean active = new AtomicBoolean();

    private final AtomicBoolean closed = new AtomicBoolean();

    private Set<ApplicationEvent> earlyApplicationEvents;

    ...

    protected void prepareRefresh() {

        // 记录此上下文开始时的系统时间(以毫秒为单位)
        this.startupDate = System.currentTimeMillis();

        // 记录此上下文是否已关闭,这里设置为未关闭
        this.closed.set(false);

        // 记录此上下文是否处于活动状态,这里设置为活动状态
        this.active.set(true);

        if (logger.isInfoEnabled()) {
            logger.info("Refreshing " + this);
        }

        // 这也是交由子类扩展的方法。具体子类为 GenericWebApplicationContext,主要是初始化属性源,
        // 将 ServletContext 和 ServletConfig 属性配置添加到 Environment 环境上下文中
        initPropertySources();

        // 校验 Environment 中那些必备的属性配置是否存在,不存在则抛异常。
        getEnvironment().validateRequiredProperties();

        // 创建 ApplicationEvent 事件集合
        this.earlyApplicationEvents = new LinkedHashSet<>();
    }

}

refresh 中的 prepareRefresh 方法执行结束,主要是记录容器的启动时间、活动状态、检查必备属性是否存在。其中,关于 Environment 环境配置,在前面 SpringBoot 系列文章中有详细讨论,感兴趣的同学可自行翻阅。

第二步:obtainFreshBeanFactory

接着进入 refresh 中的 obtainFreshBeanFactory 方法

public abstract class AbstractApplicationContext {

    ...

    public void refresh() throws BeansException, IllegalStateException {
        synchronized (this.startupShutdownMonitor) {

            ...

            ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

            ...
        }
    }
    ...

    protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
        // 该方法也是由子类扩展,其子类有 AbstractRefreshableApplicationContext 和 GenericApplicationContext,
        // 因当前是 Servlet Web 应用,所以执行的是 GenericApplicationContext 中的 refreshBeanFactory 方法。
        // 该方法主要设置 BeanFactory 的 serializationId 属性值,也就是序列化id
        refreshBeanFactory();

        // 通过 getBeanFactory 返回 BeanFactory 对象。同样也是由子类扩展,调用的是 GenericApplicationContext 类中的 getBeanFactory 方法。
        // 返回的是 DefaultListableBeanFactory 。
        ConfigurableListableBeanFactory beanFactory = getBeanFactory();
        if (logger.isDebugEnabled()) {
            logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
        }
        return beanFactory;
    }

    ...
}

obtainFreshBeanFactory 方法很简单,但如果当前是非 Servlet Web 应用,执行的就是 AbstractRefreshableApplicationContext 中的 refreshBeanFactory 方法,那可就复杂多了,这里就不展开讨论。之后,该方法还返回了 BeanFactory 对象,从这也可以看出 ApplicationContext 底层是以 BeanFactory 为基础,逐步扩展 Spring 容器功能。

第三步:prepareBeanFactory

接着进入 refresh 中的 prepareBeanFactory 方法。prepareBeanFactory 方法主要是对 BeanFactory 做一些配置,包含各种类加载器、需要忽略的依赖以及后置处理器、解析器等,

public void refresh() throws BeansException, IllegalStateException {
    synchronized (this.startupShutdownMonitor) {

        ...

        prepareBeanFactory(beanFactory);
        ...
    }
    ...
}

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
    // 设置类加载器
    beanFactory.setBeanClassLoader(getClassLoader());
    // 设置表达式解析器,主要用来解析 EL 表达式; Bean 初始化完成后填充属性时会用到
    beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
    // 设置属性注册解析器,主要用来解析 Bean 中的各种属性类型,如 String、int 等
    beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
    // 添加一个后置处理器:ApplicationContextAwareProcessor。
    // 该后置处理器用于向实现了 Aware 系列接口的 bean 设置相应属性。
    // (后置处理器和 Aware 接口也是比较核心的概念,后面会有文章详细讨论)
    beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));

    // 以下接口,在自动注入时会被忽略,其都是 Aware 系列接口
    beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
    beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
    beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
    beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
    beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
    beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);

    // 当以下特殊的 Bean 需自动注入时,指定其注入的类型 。
    // 如:注入 BeanFactory 时,注入的类型对象为 ConfigurableListableBeanFactory 。
    beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
    beanFactory.registerResolvableDependency(ResourceLoader.class, this);
    beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
    beanFactory.registerResolvableDependency(ApplicationContext.class, this);

    // 添加 ApplicationListenerDetector 后置处理器。
    // 该后置处理器用来检测那些实现了 ApplicationListener 接口的 bean,并将其添加到应用上下文的事件广播器上。
    beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

    // 判断容器中是否存在 loadTimeWeaver Bean,如果存在则上下文使用临时的 ClassLoader 进行类型匹配。
    // 集成 AspectJ 时会用到 loadTimeWeaver 对象。
    if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
        beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
        beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
    }

    // 注册和环境相关的 Bean,如 environment、systemProperties、systemEnvironment
    if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
        beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
    }
    if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
        beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
    }
    if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
        beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
    }
}

在 prepareBeanFactory 方法中,主要对 BeanFactory 添加了一系列属性项,如添加忽略自动注入的接口、添加 BeanPostProcessor 后置处理器、手动注册部分特殊的 Bean及环境相关的 Bean 。

第四步:postProcessBeanFactory

postProcessBeanFactory 方法是上下文准备的最后一步,主要用来注册 Web 请求相关的处理器、Bean及配置。

public void refresh() throws BeansException, IllegalStateException {
    synchronized (this.startupShutdownMonitor) {

        ...

        postProcessBeanFactory(beanFactory);
        ...
    }
}

该方法也是由子类进行扩展,实现该方法的子类有:


前面也说过,当前是 Servlet Web 应用,所以创建的 ApplicationContext 上下文是 AnnotationConfigServletWebServerApplicationContext,执行该类的 postProcessBeanFactory 方法。

public class AnnotationConfigServletWebServerApplicationContext
        extends ServletWebServerApplicationContext implements AnnotationConfigRegistry {

    private final AnnotatedBeanDefinitionReader reader;

    private final ClassPathBeanDefinitionScanner scanner;

    private final Set<Class<?>> annotatedClasses = new LinkedHashSet<>();

    private String[] basePackages;

    ...

    @Override
    protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
        // 先执行父类 ServletWebServerApplicationContext 的 postProcessBeanFactory 方法。
        // 跳转到 1 查看父类实现
        super.postProcessBeanFactory(beanFactory);

        // basePackages 存储的是类路径。先判断是否为 null,不为 null 则通过 ClassPathBeanDefinitionScanner 的 scan 方法
        // 扫描该路径下符合条件的 Class,并将 Class 信息包装成 BeanDefinition 注册到容器中,
        // 当然,这里没有指定扫描路径,所以不会进入这个 if。
        // (BeanDefinition 概念会在后面章节详细讨论)
        if (this.basePackages != null && this.basePackages.length > 0) {
            this.scanner.scan(this.basePackages);
        }

        // annotatedClasses 存储的 Class 集合。先判断该集合是否为空,不为空则通过
        // AnnotatedBeanDefinitionReader 的 register 方法将 Class 信息包装成 BeanDefinition 注册到容器中,
        // 这里同样没有设置 Class 集合内容,所以不会进入这个 if。
        if (!this.annotatedClasses.isEmpty()) {
            this.reader.register(ClassUtils.toClassArray(this.annotatedClasses));
        }
    }
}

1、
public class ServletWebServerApplicationContext extends GenericWebApplicationContext
        implements ConfigurableWebServerApplicationContext {
    ...

    @Override
    protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
        // 添加 BeanPostProcessor 后置处理器:WebApplicationContextServletContextAwareProcessor,
        // 该后置处理器主要是从 ConfigurableWebApplicationContext 上下文中获取 ServletContext 和 ServletConfig 对象
        beanFactory.addBeanPostProcessor(new WebApplicationContextServletContextAwareProcessor(this));

        // 添加一个 忽略自动注入的接口
        beanFactory.ignoreDependencyInterface(ServletContextAware.class);
    }
    ...
}

postProcessBeanFactory 方法执行的操作和前面类似,也是添加了后置处理器和忽略自动注入的接口。

总结

ApplicationContext 上下文准备工作基本结束,主要还是在 BeanFactory 中添加一系列后置处理器、注册特殊的 Bean 及设置忽略自动注入的接口。其中还提到了 Spring 容器的三个核心部分:Aware 系列接口、BeanPostProcessor 后置处理器、BeanDefinition ,这部分在后面的文章会逐步讨论。接下来将对 Spring 容器的核心功能展开讨论。

以上就是本章内容,如果文章中有错误或者需要补充的请及时提出,本人感激不尽。

原文地址:https://www.cnblogs.com/loongk/p/12233417.html

时间: 2024-10-09 14:53:03

Spring(三)核心容器 - ApplicationContext 上下文启动准备的相关文章

【Spring】Spring之核心容器bean

林炳文Evankaka原创作品.转载请注明出处http://blog.csdn.net/evankaka 摘要:Spring的核心容器实现了Ioc,其目 的是提供一种无侵入式的框架.在本文中,首先讲解了Spring的基础bean的相关知识,然后介绍了Spring是如何对bean进行管理的. 在Spring中,有2个最基本最重要的包,即org.springframework.beans 和org.springframework.context.在这两个包中实现了无侵入式的框架,代码中大量引用了ja

Spring之核心容器bean

摘要:Spring的核心容器实现了Ioc,其目 的是提供一种无侵入式的框架.在本文中,首先讲解了Spring的基础bean的相关知识,然后介绍了Spring是如何对bean进行管理的. 在Spring中,有2个最基本最重要的包,即org.springframework.beans 和org.springframework.context.在这两个包中实现了无侵入式的框架,代码中大量引用了java的反射机制,通过动态调用的方式避免了硬编码,为spring的反向控制特性提供了基础.在这2个包中,最重

Spring容器-ApplicationContext的启动过程

转载自: http://blog.163.com/[email protected]/blog/static/118777042009410248557/ 这片博客信息量很大,言简意赅.简明扼要地说清楚了Spring容器的启动过程,前面红色的“打比方”可以忽略... Spring容器像一台构造精妙的机器,我们通过配置文件向机器传达控制信息,机器就能够按照设定的模式进行工作.如果我们将Spring容器比喻为一辆汽车,可以将BeanFactory看成汽车的发动机,而ApplicationContex

Spring的核心容器

Spring框架的主要功能是通过其核心容器来实现的.Spring提供了2种核心容器:BeanFactory.ApplicationContext. BeanFactory BeanFactory是一个管理Bean的工厂,主要负责初始化各种Bean,并调用它们的声明周期方法. BeanFactory由BeanFactory接口定义.BeanFactory接口的常用实现类:XmlBeanFactory类. 创建一个BeanFactory的实例: 1 Resource resource=new Fil

Spring 在web 容器中的启动过程

1.对于一个web 应用,其部署在web 容器中,web 容器提供其一个全局的上下文环境,这个上下文就是 ServletContext ,其后面的spring IoC 容器提供宿主环境 2.在web.xml 中会提供有 contextLoaderListener.在web 容器启动时,会触发容器初始化事件,此时 contextLoaderListener 会监听到这个事件,其 contextInitialized 方法会被调用,在这个方法中,spring 会初始化一个启动上下文,这个上下文就被称

正则表达添加170号段Spring之核心容器

Some ladies <a title="who" style='font: 14px/24px "Helvetica Neue", Helvetica, Arial, sans-serif; margin: 0px; padding: 0px; text-align: left; color: rgb(51, 51, 51); text-transform: none; text-indent: 28px; letter-spacing: normal;

spring技术核心概念纪要

一.背景 springframework 从最初的2.5版本发展至今,期间已经发生了非常多的修正及优化.许多新特性及模块的出现,使得整个框架体系显得越趋庞大,同时也带来了学习及理解上的困难. 本文阐述了一些要点,并配合一些代码样例,这有助于快速理解 spring 框架. 二.spring架构 核心容器层 Core 模块 提供了框架的基本组成部分,包括 IoC 及依赖注入功能. Bean 模块 实现 Bean 管理,包括自动装配机制等功能: 其中BeanFactory是一个工厂模式的实现. Con

Spring(二)核心容器 - 简介 、BeanFactory、ApplicationContext

目录 前言 1.容器简介 2.容器的结构 2.1 BeanFactory 2.2 ApplicationContext 2.2.1 ConfigurableApplicationContext 2.2.2 WebApplicationContext 2.3 差异对比 3.ApplicationContext 准备启动 4.总结 前言 在上篇文章中,和大家一起讨论了 Spring 的整体架构,其大致分为五个模块:核心容器.AOP.Web.Data 数据访问.Test模块.其中核心容器是 Sprin

spring核心容器两个接口ApplicationContext和BeanFactory

import dao.LoginDao; import org.springframework.beans.factory.BeanFactory; import org.springframework.beans.factory.xml.XmlBeanFactory; import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlAppl