美文网首页spring
Spring原理分析-BeanFactory与Applicati

Spring原理分析-BeanFactory与Applicati

作者: 石头耳东 | 来源:发表于2022-04-11 22:12 被阅读0次

零、本文纲要

  • 一、容器接口
    1、BeanFactory与ApplicationContext
    2、BeanFactory接口
    ① DefaultListableBeanFactory类
    3、ApplicationContext接口
    ① 实现MessageSource接口
    ② 实现ResourcePatternResolver接口
    ③ 实现EnvironmentCapable接口
    ④ 实现ApplicationEventPublisher接口
  • 二、容器实现
    1、BeanFactory实现
    ① DefaultListableBeanFactory类
    ② 注册各类后置处理器
    ③ beanFactory后置处理器
    ④ bean后置处理器
    ⑤ preInstantiateSingletons初始化
    补充：AnnotationConfigUtils类
    2、ApplicationContext实现
    ① ClassPathXmlApplicationContext类
    ② FileSystemXmlApplicationContext类
    补充：XmlBeanDefinitionReader类
    ③ AnnotationConfigApplicationContext类
    补充：<context:annotation-config/>
    ④ AnnotationConfigServletWebServerApplicationContext类

一、容器接口

0、基础准备

添加最基础的Spring Boot依赖，如下：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>

1、BeanFactory与ApplicationContext

  • ① Spring Boot启动类

SpringApplication.run(A01.class, args);的返回值为ConfigurableApplicationContext对象，如下：

@SpringBootApplication
public class SpringOriginDemoApplication {

    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(SpringOriginDemoApplication.class, args);
    }

}
BeanFactory接口.png

BeanFactory是：

Ⅰ ApplicationContext 的父接口；
Ⅱ 是 Spring 的核心容器, 主要的 ApplicationContext 实现都【组合】了它的功能。

2、BeanFactory接口

BeanFactory接口，最基础的待实现方法是getBean();方法。

另外，像控制反转、基本的依赖注入、直至 Bean 的生命周期的各种功能，都是依赖于BeanFactory接口实现的。

  • ① DefaultListableBeanFactory类

是Spring项目中BeanFactory功能最完善的实现类，关系图如下：

DefaultListableBeanFactory类.png
  • ② 通过反射获取singletonObjects成员变量案例

DefaultSingletonBeanRegistry类，如下：

DefaultSingletonBeanRegistry类.png

通过反射获取beanFactory中的singletonObjects，如下：

// 通过反射获取 Field 对象singletonObjects
Field singletonObjects = DefaultSingletonBeanRegistry.class.getDeclaredField("singletonObjects");
// 暴力反射
singletonObjects.setAccessible(true);
// 获取beanFactory中的singletonObjects，并遍历
ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
Map<String, Object> map = (Map<String, Object>) singletonObjects.get(beanFactory);
map.entrySet()
        .stream().filter(e -> e.getKey().startsWith("component"))
        .forEach(e -> System.out.println(e.getKey() + " = " + e.getValue()));
反射输出结果.png

3、ApplicationContext接口

  • ① 实现MessageSource接口

Ⅰ 在/resources目录下编写配置文件

语言代码表：Language Code Table (lingoes.cn)，此处设置配置文件地区可以省略不写，一般写成zh、ja、en就可以（推荐）。

在/resources目录下编写配置文件.png 逐个配置配置文件.png

Ⅱ 编写测试代码

System.out.println(context.getMessage("hi", null, Locale.ENGLISH));
System.out.println(context.getMessage("hi", null, Locale.CHINA));
System.out.println(context.getMessage("hi", null, Locale.JAPAN));
输出.png
  • ② 实现ResourcePatternResolver接口

Ⅰ 获取类路径下指定资源classpath:

Resource[] resources = context.getResources("classpath:application.properties");
for (Resource resource : resources) {
    System.out.println(resource); // 输出 class path resource [application.properties]
}

Ⅱ 获取jar包其他资源classpath*:

Resource[] resources = context.getResources("classpath*:META-INF/spring.factories");
获取jar包其他资源.png
  • ③ 实现EnvironmentCapable接口

Ⅰ 获取变量键值

该方法可以获取配置文件（如：application.properties）内的键值，也可以拿到环境变量的键值，如下：

System.out.println(context.getEnvironment().getProperty("java_home")); // 输出 C:\Program Files\Java\jdk1.8.0_311
System.out.println(context.getEnvironment().getProperty("server.port")); // 输出 8080
  • ④ 实现ApplicationEventPublisher接口

Ⅰ 编写事件类（实现ApplicationEvent ）

public class UserRegisterEvent extends ApplicationEvent {
    public UserRegisterEvent(Object source) {
        super(source);
    }
}

Ⅱ 编写事件发布类

@Component
public class Component1 {
    private static final Logger log = LoggerFactory.getLogger(Component1.class);
    @Autowired
    private ApplicationEventPublisher context;
    public void register() {
        log.debug("用户注册");
        context.publishEvent(new UserRegisteredEvent(this));
    }
}

Ⅲ 编写事件监听类

@Component
public class Component2 {
    private static final Logger log = LoggerFactory.getLogger(Component2.class);
    @EventListener
    public void aaa(UserRegisteredEvent event) {
        log.debug("{}", event);
        log.debug("发送短信");
    }
}

此处我们是debug输出的，在application.properties中自定义一下日志输出：logging.level.com.stone=debug。
Ⅳ 测试

context.getBean(Component1.class).register();
实现ApplicationEventPublisher接口.png

实际使用场景中的作用：解耦合。

  • ⑤ 总结

ApplicationContext接口拓展功能：

Ⅰ 国际化支持（MessageSource）；
Ⅱ 通配符获取资源（ResourcePatternResolver）；
Ⅲ 获取环境变量（EnvironmentCapable）；
Ⅳ 发送事件（ApplicationEventPublisher）。

二、容器实现

1、BeanFactory实现

  • ① DefaultListableBeanFactory类

Ⅰ 准备测试类

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

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

    static class Bean1{
        private static final Logger log = LoggerFactory.getLogger(Bean1.class);

        public Bean1(){
            log.debug("构造 Bean1()");
        }

        @Autowired
        private Bean2 bean2;

        public Bean2 getBean2() {
            return bean2;
        }
    }

    static class Bean2{
        private static final Logger log = LoggerFactory.getLogger(Bean1.class);

        public Bean2(){
            log.debug("构造 Bean2()");
        }
    }
}

Ⅱ 编写main方法

public static void main(String[] args) {
    DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
    // Bean 的定义信息 class、scope、initMethod、destroyMethod 等
    AbstractBeanDefinition bd
            = BeanDefinitionBuilder.genericBeanDefinition(Config.class).setScope("singleton").getBeanDefinition();
    beanFactory.registerBeanDefinition("config", bd);

    for (String definitionName : beanFactory.getBeanDefinitionNames()) {
        System.out.println(definitionName);
    }
}

可以看到我们@Configuration注解的配置类并没有被扫描，所以@Bean相关的Bean没有输出，如下：

控制台输出.png

至此，我们可以看出基础的DefaultListableBeanFactory类并不直接支持此类注解扫描。

  • ② 注册各类后置处理器
// 给 beanFactory 添加常用的后置处理器
AnnotationConfigUtils.registerAnnotationConfigProcessors(beanFactory);
添加常用的后置处理器.png

可以看到，此时bean1和bean2仍然没有被扫描放入容器。以为还没有调用beanFactory的后置处理器。添加的后置处理器：
a、ConfigurationAnnotationProcessor；（BeanFactory后置处理器）
b、AutowiredAnnotationProcessor；
c、CommonAnnotationProcessor；
d、EventListenerProcessor；
e、EventListenerFactory。

  • ③ beanFactory后置处理器

获取beanFactory的后置处理器，并调用，如下：

beanFactory.getBeansOfType(BeanFactoryPostProcessor.class).values()
        .forEach(beanFactoryPostProcessor -> {
    beanFactoryPostProcessor.postProcessBeanFactory(beanFactory);
});
获取beanFactory的后置处理器.png

至此，我们知道BeanFactoryPostProcessor是对BeanDifinition的一些补充。另外，我们尝试获取一下bean1、bean2，如下：

System.out.println(beanFactory.getBean(Bean1.class).getBean2());
尝试获取bean1.png

Creating shared instance of singleton bean 'bean1'可以看到Bean对象在我们获取的时候才去创建，并且bean1对象内部并没有注入构造好的bean2。此时我们就需要用到Bean后置处理器。

  • ④ bean后置处理器

其作用是对bean生命周期的各个阶段提供拓展，例如：@Autowired...

beanFactory.getBeansOfType(BeanPostProcessor.class).values()
        .forEach(beanFactory::addBeanPostProcessor);
bean后置处理器.png

此时可以看到，装配bean1时需要bean2，容器就去沟通bean2完成注入。但是，实际使用Spring的时候，其实bean都是在我们使用前已经创建好的，我们还需处理。

  • ⑤ preInstantiateSingletons初始化
beanFactory.preInstantiateSingletons();
System.out.println("==== before we get these beans ====");
System.out.println(beanFactory.getBean(Bean1.class).getBean2());
preInstantiateSingletons初始化.png
  • ⑥ 总结

Ⅰ 不会主动调用 BeanFactory 后处理器；
Ⅱ 不会主动添加 Bean 后处理器；
Ⅲ 不会主动初始化单例；
Ⅳ 不会解析beanFactory 还不会解析 ${ } 与 #{ }（如：@Value注解内使用）。

补充：AnnotationConfigUtils类

  • ① 基础准备

Ⅰ Config类添加：

@Bean
public Bean3 bean3(){
    return new Bean3();
}
@Bean
public Bean4 bean4(){
    return new Bean4();
}

Ⅱ 编写接口&内部类：

interface Inter{}
static class Bean3 implements Inter{}
static class Bean4 implements Inter{}

Ⅲ Bean1内注入：

a、同一接口不同实现，@Autowired按照字段名注入，如下：

@Autowired
private Inter bean3;
@Autowired按照字段名注入.png

b、同一接口不同实现，@Resource(name = "bean4")指定注入，如下：

@Resource(name = "bean4")指定注入.png

c、同时开启，按照@Autowired注入，如下：

同时开启按照@Autowired注入.png

d、通过比较器修改注入，如下：

Ⅰ 修改前

beanFactory.getBeansOfType(BeanPostProcessor.class).values()
        .forEach(beanPostProcessor -> {
            System.out.println("[!!!LOOK HERE!!!] Added BeanPostProcessor is ---> " + beanPostProcessor);
            beanFactory.addBeanPostProcessor(beanPostProcessor);
        });
修改前.png

Ⅱ 修改后

添加了.stream().sorted(beanFactory.getDependencyComparator())；

beanFactory.getBeansOfType(BeanPostProcessor.class).values()
        .stream().sorted(beanFactory.getDependencyComparator())
        .forEach(beanPostProcessor -> {
            System.out.println("[!!!LOOK HERE!!!] Added BeanPostProcessor is ---> " + beanPostProcessor);
            beanFactory.addBeanPostProcessor(beanPostProcessor);
        });
修改后.png

2、ApplicationContext实现

  • ① ClassPathXmlApplicationContext类

Ⅰ 编写内部类

public class Demo02 {
    static class Bean1{}

    static class Bean2{
        private Bean1 bean1;

        public void setBean1(Bean1 bean1) {
            this.bean1 = bean1;
        }

        public Bean1 getBean1() {
            return bean1;
        }
    }
}

Ⅱ 编写b01.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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans 
       http://www.springframework.org/schema/beans/spring-beans.xsd">
        <!--配置bean-->
        <bean name="bean1" class="com.stone.demo02.Demo02.Bean1"/>
        <bean name="bean2" class="com.stone.demo02.Demo02.Bean2">
            <property name="bean1" ref="bean1"/>
        </bean>
</beans>

Ⅲ 编写测试方法

public static void testClassPathXmlApplicationContext(){
    ClassPathXmlApplicationContext context = 
            new ClassPathXmlApplicationContext("b01.xml");
    for (String definitionName : context.getBeanDefinitionNames()) {
        System.out.println(definitionName);
    }
    System.out.println(context.getBean(Bean2.class).getBean1());
}
ClassPathXmlApplicationContext类.png
  • ② FileSystemXmlApplicationContext类
public static void testFileSystemXmlApplicationContext(){
    FileSystemXmlApplicationContext context
            // 绝对路径 D:\JavaStudy\Level1\spring_origin_demo\src\main\resources\b01.xml
            // 相对路径 src/main/resources/b01.xml
            = new FileSystemXmlApplicationContext("src/main/resources/b01.xml");
    for (String definitionName : context.getBeanDefinitionNames()) {
        System.out.println(definitionName);
    }
    System.out.println(context.getBean(Bean2.class).getBean1());
}
FileSystemXmlApplicationContext类.png

补充：XmlBeanDefinitionReader类

DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
System.out.println("[!!!LOOK HERE!!!] Before reader works :");
for (String definitionName : beanFactory.getBeanDefinitionNames()) {
    System.out.println(definitionName);
}
XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(beanFactory);
//        reader.loadBeanDefinitions(new ClassPathResource("b01.xml"));
reader.loadBeanDefinitions(new FileSystemResource("src/main/resources/b01.xml"));
System.out.println("[!!!LOOK HERE!!!] After reader worked :");
for (String definitionName : beanFactory.getBeanDefinitionNames()) {
    System.out.println(definitionName);
}
XmlBeanDefinitionReader类.png
  • ③ AnnotationConfigApplicationContext类

Ⅰ 编写Config类

@Configuration
static class Config{
    @Bean
    public Bean1 bean1(){
        return new Bean1();
    }
    @Bean
    public Bean2 bean2(Bean1 bean1){
        Bean2 bean2 = new Bean2();
        bean2.setBean1(bean1);
        return bean2;
    }
}

Ⅱ 编写测试方法

public static void testAnnotationConfigApplicationContext(){
    AnnotationConfigApplicationContext context
            = new AnnotationConfigApplicationContext(Config.class);
    for (String definitionName : context.getBeanDefinitionNames()) {
        System.out.println(definitionName);
    }
    System.out.println(context.getBean(Bean2.class).getBean1());
}
AnnotationConfigApplicationContext类.png

补充：<context:annotation-config/>

可以看到AnnotationConfigApplicationContext类自动添加了后置处理器，其作用类似于配置<context:annotation-config/>。

<!--添加注解驱动-->
<context:annotation-config/>
注解驱动在上.png 注解驱动在下.png
  • ④ AnnotationConfigServletWebServerApplicationContext类

Ⅰ 编写WebConfig类

@Configuration
static class WebConfig{
    @Bean // 必须有
    public ServletWebServerFactory servletWebServerFactory(){
        return new TomcatServletWebServerFactory();
    }
    @Bean // 必须有
    public DispatcherServlet dispatcherServlet(){
        return new DispatcherServlet();
    }
    @Bean // 必须有
    public DispatcherServletRegistrationBean registrationBean(
            DispatcherServlet dispatcherServlet){
        return new DispatcherServletRegistrationBean(dispatcherServlet, "/");
    }
    @Bean("/hello")
    public Controller controller(){
        // org.springframework.web.servlet.mvc.Controller
        return (request, response) -> {
            response.getWriter().println("Hello, context!");
            return null;
        };
    }
}

Ⅱ 编写测试方法

public static void testAnnotationConfigServletWebServerApplicationContext(){
    AnnotationConfigServletWebServerApplicationContext context
            = new AnnotationConfigServletWebServerApplicationContext(WebConfig.class);
    for (String definitionName : context.getBeanDefinitionNames()) {
        System.out.println(definitionName);
    }
}
AnnotationConfigServletWebServerApplicationContext类.png

三、结尾

以上即为Spring原理分析-容器&Bean（一）的全部内容，感谢阅读。

相关文章

网友评论

    本文标题：Spring原理分析-BeanFactory与Applicati

    本文链接：https://www.haomeiwen.com/subject/ufaisrtx.html

    延伸阅读

    深度阅读

    • 您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！

    栏目导航

    热点阅读

    spring

    关于我们|服务条款|联系我们|Spring原理分析-BeanFactory与Applicati|投稿指南|网站地图|RSS订阅|排版工具|手机版

    提供经典美文摘抄,优美散文欣赏,现代诗歌精选,短篇小说,心情随笔,表白情书范文,故事会在线阅读欣赏

    Copyright © 2014-2023 Haomeiwen.com All Rights Reserved. 好美文阅读网 版权所有

    备案信息：桂公网安备 45052102000051号 · 桂ICP备13007215号-3

    本站所收录作品、热点评论等信息部分来源互联网，目的只是为了系统归纳学习和传递资讯

    所有作品版权归原创作者所有，与本站立场无关，如不慎侵犯了你的权益，请联系我们告知，我们将做删除处理！