Spring原理（1）——容器

Spring,容器,原理 · 浏览次数 : 100

小编点评

文章内容主要介绍以下几个主题： 1. Spring容器的配置 2. Bean的定义 3. Annotations的使用 4. Spring容器的加载 5. 注解的处理文章内容使用简单的排版和注释，能够帮助读者理解Spring容器的配置和使用。文章内容主要通过以下几个方面进行介绍： 1. Spring容器的配置 a. 使用DefaultListableBeanFactory创建容器 b. 使用XmlBeanDefinitionReader加载xml配置 2. Bean的定义 a. 使用@Configuration注解定义Bean b. 使用@Autowired注解进行注入 3. Annotations的使用 a. 使用@ContextAnnotationConfig注解配置 b. 使用@Configuration注解定义事件监听器 4. Spring容器的加载 a. 使用FileSystemXmlApplicationContext加载配置文件 b. 使用AnnotationConfigApplicationContext加载配置 5. 注解的处理 a. 使用@Autowired注解进行注入 b. 使用@Configuration注解定义事件监听器文章内容通过简单的说明能够帮助读者理解Spring容器的配置和使用。

正文

容器接口

BeanFactory

是ApplicationContext的父接口，所有ApplicationContext的实现都组合了BeanFactory。
BeanFactory才是Spring的核心容器。

从BeanFactory提供的方法来看，主要是从容器中获取Bean。实际上控制反转，依赖注入以及Bean的生命周期管理，都由它的实现类提供。如下展示了BeanFactory其中一个实现类DefaultListableBeanFactory的继承关系。

可以看到，它的继承路线上有一个DefaultSingletonBeanRegistry类，这个类我们打开可以看到如下代码段，其中singletonObjects对象正是容器中所有单例对象被保存的地方。

public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {
	/** Cache of singleton objects: bean name to bean instance. */
	private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);  // 保存了所有的单例对象

	/** Cache of singleton factories: bean name to ObjectFactory. */
	private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
	
	...
}

ApplicationContext

ApplicationContext继承自多个接口，因此提供了多种能力，具体提供的能力如下代码所示。

@SpringBootApplication
public class SsmpApplication {

    public static void main(String[] args) throws IOException {
        final ConfigurableApplicationContext context = SpringApplication.run(SsmpApplication.class, args);

        // MessageSource接口提供的功能，实现国际化能力
        context.getMessage("hi", null, Locale.CHINA);
        context.getMessage("hi", null, Locale.US);

        // ResourcePatternResolver接口提供的能力，实现读取资源文件的能力
        final Resource[] resources = context.getResources("classpath*:spring.factories");

        // EnvironmentCapable接口提供的能力，实现获取环境参数的能力，可以获取环境变量、配置等
        final String java_home = context.getEnvironment().getProperty("java_home");
        final String port = context.getEnvironment().getProperty("server.port");

        // ApplicationEventPublisher提供的能力，可以发送事件，实现解耦
        context.publishEvent(new MyEvent(context));
    }

    public static class MyEvent extends ApplicationEvent {

        public MyEvent(Object source) {
            super(source);
        }
    }
}

容器实现

BeanFactory实现

以下代码的注释中展示了BeanFactory是如何注册Bean的，以及注册后如何进行后处理的。

点击查看代码

package com.leo.ssmp;

import lombok.extern.slf4j.Slf4j;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.support.DefaultListableBeanFactory;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.AnnotationConfigUtils;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.Collection;

@SpringBootApplication
@Slf4j
public class SsmpApplication {

    public static void main(String[] args) {
        // 将MyConfig类注册到BeanFactory中，由BeanFactory管理Bean的生成，销毁
        DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
        final BeanDefinition configDefinition = BeanDefinitionBuilder.genericBeanDefinition(MyConfig.class)
            .setScope("singleton")
            .getBeanDefinition();
        beanFactory.registerBeanDefinition("config", configDefinition);

        // 向BeanFactory上注册一些后处理器，这些后处理器可以解析@Configuration和@Bean这些注解
        AnnotationConfigUtils.registerAnnotationConfigProcessors(beanFactory);

        // BeanFactory后处理器，执行后处理操作，处理@Configuration注解，将bean1和bean2生成出来
        final Collection<BeanFactoryPostProcessor> beanFactoryPostProcessors = beanFactory.getBeansOfType(
            BeanFactoryPostProcessor.class).values();
        log.info("---------------BeanFactory后处理器------------------");
        beanFactoryPostProcessors.forEach(beanFactoryPostProcessor -> log.info(beanFactoryPostProcessor.toString()));
        beanFactoryPostProcessors.forEach(beanFactoryPostProcessor -> {
            beanFactoryPostProcessor.postProcessBeanFactory(beanFactory);
        });
        log.info("---------------BeanFactory后处理器------------------");

        // Bean后处理器，针对Bean的生命周期的各个阶段做扩展，例如@Autowired @Resource，
        // 这样才能在生成bean1后，向bean1中注入bean2
        final Collection<BeanPostProcessor> beanPostProcessors = beanFactory.getBeansOfType(BeanPostProcessor.class)
            .values();
        log.info("----------------Bean后处理器-----------------");
        beanPostProcessors.forEach(beanPostProcessor -> log.info(beanPostProcessor.toString()));
        beanPostProcessors.forEach(beanFactory::addBeanPostProcessor);
        log.info("----------------Bean后处理器-----------------");

        log.info("------------------注册的所有Bean定义信息------------------");
        final String[] beanDefinitionNames = beanFactory.getBeanDefinitionNames();
        for (String beanDefinitionName : beanDefinitionNames) {
            log.info(beanDefinitionName);
        }
        log.info("------------------注册的所有Bean定义信息------------------");

        final Bean1 bean1 = beanFactory.getBean(Bean1.class);
        log.info(bean1.getBean2().toString());
    }

    @Configuration
    static class MyConfig {
        @Bean
        public Bean1 bean1() {
            return new Bean1();
        }

        @Bean
        public Bean2 bean2() {
            return new Bean2();
        }
    }

    static class Bean1 {

        @Autowired
        private Bean2 bean2;

        public Bean1() {
            log.info("Bean1 construct...");
        }

        public Bean2 getBean2() {
            return bean2;
        }
    }

    static class Bean2 {
        public Bean2() {
            log.info("Bean2 construct");
        }
    }
}

以上代码的运行结果如下：

点击查看代码

10:56:43.379 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'org.springframework.context.annotation.internalConfigurationAnnotationProcessor'
10:56:43.395 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'org.springframework.context.event.internalEventListenerProcessor'
10:56:43.398 [main] INFO com.leo.ssmp.SsmpApplication - ---------------BeanFactory后处理器------------------
10:56:43.398 [main] INFO com.leo.ssmp.SsmpApplication - org.springframework.context.annotation.ConfigurationClassPostProcessor@724af044
10:56:43.398 [main] INFO com.leo.ssmp.SsmpApplication - org.springframework.context.event.EventListenerMethodProcessor@4678c730
10:56:43.512 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'org.springframework.context.event.internalEventListenerFactory'
10:56:43.513 [main] INFO com.leo.ssmp.SsmpApplication - ---------------BeanFactory后处理器------------------
10:56:43.513 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'org.springframework.context.annotation.internalAutowiredAnnotationProcessor'
10:56:43.513 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'org.springframework.context.annotation.internalCommonAnnotationProcessor'
10:56:43.516 [main] INFO com.leo.ssmp.SsmpApplication - ----------------Bean后处理器-----------------
10:56:43.516 [main] INFO com.leo.ssmp.SsmpApplication - org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor@6385cb26
10:56:43.516 [main] INFO com.leo.ssmp.SsmpApplication - org.springframework.context.annotation.CommonAnnotationBeanPostProcessor@38364841
10:56:43.517 [main] INFO com.leo.ssmp.SsmpApplication - ----------------Bean后处理器-----------------
10:56:43.517 [main] INFO com.leo.ssmp.SsmpApplication - ------------------注册的所有Bean定义信息------------------
10:56:43.517 [main] INFO com.leo.ssmp.SsmpApplication - config
10:56:43.517 [main] INFO com.leo.ssmp.SsmpApplication - org.springframework.context.annotation.internalConfigurationAnnotationProcessor
10:56:43.517 [main] INFO com.leo.ssmp.SsmpApplication - org.springframework.context.annotation.internalAutowiredAnnotationProcessor
10:56:43.517 [main] INFO com.leo.ssmp.SsmpApplication - org.springframework.context.annotation.internalCommonAnnotationProcessor
10:56:43.517 [main] INFO com.leo.ssmp.SsmpApplication - org.springframework.context.event.internalEventListenerProcessor
10:56:43.517 [main] INFO com.leo.ssmp.SsmpApplication - org.springframework.context.event.internalEventListenerFactory
10:56:43.517 [main] INFO com.leo.ssmp.SsmpApplication - bean1
10:56:43.517 [main] INFO com.leo.ssmp.SsmpApplication - bean2
10:56:43.517 [main] INFO com.leo.ssmp.SsmpApplication - ------------------注册的所有Bean定义信息------------------
10:56:43.517 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'bean1'
10:56:43.518 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'config'
10:56:43.529 [main] INFO com.leo.ssmp.SsmpApplication - Bean1 construct...
10:56:43.535 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'bean2'
10:56:43.536 [main] INFO com.leo.ssmp.SsmpApplication - Bean2 construct
10:56:43.537 [main] INFO com.leo.ssmp.SsmpApplication - com.leo.ssmp.SsmpApplication$Bean2@55040f2f

Process finished with exit code 0

后处理器的执行顺序跟它们之间的排序策略有关，先执行的后处理器会生效。

ApplicationContext实现

ClassPathXmlApplicationContext

首先我们定义一个实体类

package com.leo.domain;

import lombok.Data;

@Data
public class Book {
    private Integer id;

    private String type;

    private String name;

    private String description;
}

在resources目录下创建b01.xml文件作为Spring的配置文件

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">

    <bean id="bean1" class="com.leo.domain.Book"/>
</beans>

通常我们会使用如下方式来启动和加载Spring容器

package com.leo;

import org.springframework.beans.factory.support.DefaultListableBeanFactory;
import org.springframework.beans.factory.xml.XmlBeanDefinitionReader;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.core.io.ClassPathResource;

@SpringBootApplication
public class SpringApplication {
    public static void main(String[] args) {
        final ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(
            "b01.xml");
    }
}

其内部实现如果简单的拆开来，可以用如下步骤表示，BeanFactory是真正的容器，我们使用XmlBeanDefinitionReader将xml中定义的bean转化成BeanDefinition并注册到BeanFactory中。

package com.leo;

import org.springframework.beans.factory.support.DefaultListableBeanFactory;
import org.springframework.beans.factory.xml.XmlBeanDefinitionReader;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.core.io.ClassPathResource;

@SpringBootApplication
public class SpringApplication {
    public static void main(String[] args) {
        testClasspathXmlApplicationContext();
    }

    private static void testClasspathXmlApplicationContext() {
        DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
        System.out.println("=======================>before");
        for (String beanDefinitionName : beanFactory.getBeanDefinitionNames()) {
            System.out.println(beanDefinitionName);
        }
        XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(beanFactory);
        reader.loadBeanDefinitions(new ClassPathResource("b01.xml"));
        System.out.println("=======================>after");
        for (String beanDefinitionName : beanFactory.getBeanDefinitionNames()) {
            System.out.println(beanDefinitionName);
        }
    }
}

以上代码的运行结果如下：

=======================>before
14:14:13.483 [main] DEBUG org.springframework.beans.factory.xml.XmlBeanDefinitionReader - Loaded 6 bean definitions from class path resource [b01.xml]
=======================>after
bean1

我们会发现这是容器里只有一个Bean，但是当我们用springboot自动配置来启动容器时，会发现即使我们不定义Bean，默认也会加载一些内置的bean。那么Spring是如何加载这些内置的Bean的呢。我们可以在xml文件中加入如下配置：

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">

    <bean id="bean1" class="com.leo.ssmp.domain.Book"/>

    <!--这里开启了各种注解，例如Autowired-->
    <context:annotation-config/>
</beans>

这样我们运行上面的代码时打印出来的结果如下：

=======================>before
14:14:13.483 [main] DEBUG org.springframework.beans.factory.xml.XmlBeanDefinitionReader - Loaded 6 bean definitions from class path resource [b01.xml]
=======================>after
bean1
org.springframework.context.annotation.internalConfigurationAnnotationProcessor
org.springframework.context.annotation.internalAutowiredAnnotationProcessor
org.springframework.context.annotation.internalCommonAnnotationProcessor
org.springframework.context.event.internalEventListenerProcessor
org.springframework.context.event.internalEventListenerFactory

可以看到这时已经加载了很多处理注解和事件监听的Bean。

FileSystemXmlApplicationContext

基本原理与ClassPathXmlApplicationContext相似，只不过这里改为从文件系统直接读取xml配置。

AnnotationConfigApplicationContext

直接通过@Configuration注解的类来加载Bean，这种方法加载Bean时，会默认加载注解处理器这些内置的Bean。同时还会将config类也加载为Bean。