码农-V

Spring容器初始化源码全解析

容器概述

org.springframework.context.ApplicationContext接口代表 Spring IoC 容器，负责实例化、配置和组装 bean。容器通过读取配置元数据来获取需要被实例化、配置的对象，
配置元数据包括 XML、Java 注解或 Java BeanConfig等。本文详解容器初始过程。

使用

配置元数据

XML
先创建一个 xxx.xml 项目中常见 applicationContext.xml。然后配置bean

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="myBean" class="com.xia.xmlbean.MyBean">  
        <!-- 这里可以填充属性，注入等。 -->
    </bean>

    <bean id="xxx" class="xxxx">
       <!-- 配置你自己的类 -->
    </bean>
</beans>

关注公众号【Code视角】深入学习Spring等Java相关知识。

注解 Spring 2.5 引入了对基于注解的配置元数据的支持

package com.xia.annotation;

import org.springframework.stereotype.Component;

@Component
public class MyBean {

    public void helloWord(){
        System.out.println("helloWord");
    }
    
    public static void main(String[] args) {

        ApplicationContext context = new AnnotationConfigApplicationContext("com.xia.annotation");

        context.getBean(MyBean.class).helloWord();
    }
}

Java 从 Spring 3.0 开始，Spring JavaConfig 项目提供的许多特性成为核心 Spring Framework 的一部分

public class MyBean {
    public void helloWord(){
        System.out.println("helloWord");
    }
}


@Configuration
public class ConfigBean {

    @Bean
    public MyBean createMyBean(){
        return new MyBean();
    }

    public static void main(String[] args) {
        ApplicationContext ctx = new AnnotationConfigApplicationContext(ConfigBean.class);
        ctx.getBean(MyBean.class).helloWord();
    }
}

实例化容器

// 多种ApplicationContext实现类  
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

使用容器

// 多种ApplicationContext实现类
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

context.getBean(MyBean.class).helloWord();

// 或者这样
GenericApplicationContext context1 = new GenericApplicationContext();
new XmlBeanDefinitionReader(context1).loadBeanDefinitions("applicationContext.xml");
context1.refresh();

context1.getBean(MyBean.class).helloWord();

关注公众号【Code视角】深入学习Spring等Java相关知识。

源码详解

ApplicationContext继承

ApplicationContext继承了六个接口、每个接口都赋予了它特有的功能。

核心接口

org.springframework.beans.factory.ListableBeanFactory

ListableBeanFactory继承BeanFactory、BeanFactory定义了bean的获取、创建等。部分方法如下

    @Nullable
	Class<?> getType(String name) throws NoSuchBeanDefinitionException;
	
	boolean isSingleton(String name) throws NoSuchBeanDefinitionException;
	
	boolean containsBean(String name);
		
	<T> T getBean(Class<T> requiredType, Object... args) throws BeansException;
	
	Object getBean(String name) throws BeansException;
	
	// 这个属性很重要 在FactoryBean创建对象时，会创建两个对象、一个是FactoryBean对象本身，还有一个getBean的对象，这个时候FactoryBean对象的beanName会加上&
	String FACTORY_BEAN_PREFIX = "&";

ListableBeanFactory 是对Bean获取上进行增强，对BeanDefinition的统计等 BeanDefinition是bean定义信息。部分方法如下

    // 检查bean定义信息
    boolean containsBeanDefinition(String beanName);
    
    // 获取注册表数量
    int getBeanDefinitionCount();
    
    // 工厂中定义的所有bean的名称。
    String[] getBeanDefinitionNames();

org.springframework.beans.factory.HierarchicalBeanFactory

HierarchicalBeanFactory继承BeanFactory、主要应用于层级体系的容器类、给容器提供了父子容器实现的定义。

    
    // 回当前BeanFactory的父BeanFactory
	@Nullable
	BeanFactory getParentBeanFactory();
	
	// 检测当前BeanFactory中是否包含指定名字的Bean。不去检测其父BeanFactory中是否包含类似于Listable中的查找Bean的方法
	boolean containsLocalBean(String name);

辅助功能接口

org.springframework.core.env.EnvironmentCapable

EnvironmentCapable定义了获取Environment实例的方法，Environment是Spring容器中获取配置属性的对象，属性包括但不限于系统属性、环境变量等

    // 获取Environment实例
	Environment getEnvironment();

org.springframework.context.MessageSource

MessageSource为容器定义了支持国际化的功能，目前笔者工作中没有遇到过，故不进行编写

org.springframework.context.ApplicationEventPublisher

ApplicationEventPublisher 为容器提供事件发布功能，这里在工作中使用较多，重点，部分方法如下

    // ApplicationEventPublisher被@FunctionalInterface修饰，说明它是函数式接口

    // 通知应用所有已注册且匹配的监听器此ApplicationEvent
    default void publishEvent(ApplicationEvent event) {
		publishEvent((Object) event);
	}
	
	// 通知应用所有已注册且匹配的监听器此Event ，如果这个Event不是一个ApplicationEvent，则其被包裹于PayloadApplicationEvent
	void publishEvent(Object event);

org.springframework.core.io.support.ResourcePatternResolver

ResourcePatternResolver用于解析资源文件的策略接口，继承于ResourceLoader接口，为Spring容器提供了加载资源的能里

ResourceLoader 资源解析

	// 解析资源，返回Resource资源数据
	Resource getResource(String location);
	
	@Nullable
	ClassLoader getClassLoader();

ResourcePatternResolver

    // 对ResourceLoader进行增强，可以加载多个资源数据
	Resource[] getResources(String locationPattern) throws IOException;

这里笔者教大家一个源码小技巧，如果找不到源码接口的实现类，可以试着 Defaultxxx找它的默认实现

把如上几个接口串联起来的话，就会发现，Spring容器提供了，资源加载（元数据加载）、SpringBean获取，注册表数据获取，事件发布等。这个时候应该有个疑问： bean创建呢？

ApplicationContext部分实现

org.springframework.context.support.AbstractApplicationContext 抽象类

这个类实现了Spring容器的初始化核心方法org.springframework.context.support.AbstractApplicationContext#refresh，主要对于Bean创建、增强（AOP）、事件发布等。代码的设计模式为++模板方法++，笔者将在下文进行详细讲解。

org.springframework.context.support.ClassPathXmlApplicationContext
org.springframework.context.support.FileSystemXmlApplicationContext
org.springframework.web.context.support.AbstractRefreshableWebApplicationContext

web抽象

org.springframework.web.context.support.AnnotationConfigWebApplicationContext
org.springframework.web.context.support.XmlWebApplicationContext

通过阅读Spring源码发现，Spring在对核心功能扩展的时候都是通过继承现有的类，然后核心不变，只对外围的资源加载和输出进行改变，迎合需求。这种设计需要很高的抽象概念、良好的设计思想。

例如：

org.springframework.context.support.AbstractXmlApplicationContext

子类有：
org.springframework.context.support.ClassPathXmlApplicationContext 
org.springframework.context.support.FileSystemXmlApplicationContext

见名知意， 核心都是通过Xml文件加载数据，只是源头不同。
ClassPathXmlApplicationContext 通过类路径下的xml进行加载。
FileSystemXmlApplicationContext 可以指定绝对路径进行加载xml。

笔者以++org.springframework.context.annotation.AnnotationConfigApplicationContext++为例讲解容器的初始化过程

初始化流程图

源码解析

入口方法

public static void main(String[] args) {

    ApplicationContext context = new AnnotationConfigApplicationContext("com.xia.annotation");

    context.getBean(MyBean.class).helloWord();
}

实例化Context对象


    public AnnotationConfigApplicationContext(String... basePackages) {
    	// 调用无参构造方法 这里在创建父类的时候 为应用上下文创建一个默认的DefaultListableBeanFactory
    	this();
    	// 扫描包路径
    	scan(basePackages);
    	// 核心方法 来自于org.springframework.context.support.AbstractApplicationContext#refresh
    	refresh();
    }

org.springframework.context.annotation.AnnotationConfigApplicationContext#AnnotationConfigApplicationContext(java.lang.String…) 之this();

构造无参构造器，创建注解bean定义读取器，和注册bean元数据扫描器

    public AnnotationConfigApplicationContext() {
        // 分步记录ApplicationStartup各个阶段的时间或者指标数据
		StartupStep createAnnotatedBeanDefReader = this.getApplicationStartup().start("spring.context.annotated-bean-reader.create");
    	//  创建元数据扫描器，因为注解是后期扩展，所以最初的Spring读取器不适用，那么就需要扩展自己的bean定义读取器
		this.reader = new AnnotatedBeanDefinitionReader(this);
		// 创建解析器环境结束
		createAnnotatedBeanDefReader.end();
        // 创建BeanDefinition扫描器
		// 可以用来扫描包或者类，生成bean定义信息 
		this.scanner = new ClassPathBeanDefinitionScanner(this);
	}

new AnnotatedBeanDefinitionReader(this);

1.1 获取Environment，创建ConditionEvaluator，注册内置注解后置处理器。需要传入一个Spring容器，所以这里传入的是this。

    public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry) {
        //  getOrCreateEnvironment(registry)
        //  这个方法是为了获取Environment，存储运行时环境变量
		this(registry, getOrCreateEnvironment(registry));
    }
    
    // 然后其重载的构造方法
    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);
	}

1.2 AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);

给当前传入的BeanDefinitionRegistry注册注解处理器，简单来说就是给当前Spring容器注入内置的注解后置处理器(重要)，下面我们对源码进行解读。

    public static void registerAnnotationConfigProcessors(BeanDefinitionRegistry registry) {
		registerAnnotationConfigProcessors(registry, null);
	}

	public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
			BeanDefinitionRegistry registry, @Nullable Object source) {
        
        // 得到DefaultListableBeanFactory工厂
		DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
		if (beanFactory != null) {
		    // 判断有没有处理注解的排序器，就是判断容器Comparator