跳至主要內容

11、Bean 的生命周期

安图新大约 8 分钟

11、Bean 的生命周期

一、简介

首先,为什么要学习 Spring 中 Bean 的生命周期呢?

虽然不了解 Bean 的生命周期,并不影响日常工作中的开发。但是如果我们了解了 Bean 的生命周期,可以帮助我们更好地掌握 Spring 框架,并且能够让我们更好地去理解 Spring 容器是如何管理和创建 Bean 示例的。如果以后遇到 Bean 的相关问题(比如 Spring 的循环依赖问题),就可以方便我们去调试和解决这些问题。同时也让我们可以编写出更健壮、灵活、易维护的应用程序。所以说,理解 Bean 的生命周期对掌握 Spring 框架来说是至关重要的。

这里我们主要分两部分去说明:

1、 先从整体上去介绍 Bean 创建的整个流程->Bean 的流程;
2、 然后再用代码的方式去验证流程->代码验证;

二、Bean 的流程

1.BeanDefinition

BeanDefinition:Bean 的定义信息。Spring 容器在进行实例化时,会将 xml 配置中 <bean> 的信息(注解也是如此)封装成一个 BeanDefinition 对象,Spring 根据 BeanDefinition 来创建 Bean 对象,里面有很多用来描述 Bean 的属性。

有了 BeanDefinition 之后,再去创建 Bean 对象的时候,就可以通过反射去创建。

<bean id="userDao" class="com.demo.dao.impl.UserDaoImpl" lazy-init="true"/>
<bean id="userService" class="com.demo.service.UserServiceImpl" scope="singleton">
	<property name="userDao" ref="userDao"></property>
</bean>

 
 
  • beanClassName:bean 的类名。
  • initMethodName:初始化方法名称。
  • propertyValues:bean 的属性值。
  • scope:作用域。
  • lazyInit:延迟初始化。

以上这些属性都被封装到 BeanDefinition 中备用。那具体什么时候用呢?这就是下面要说的 Bean 的生命周期。

2.Bean 的生命周期

目前我们已经有了 BeanDefinition 这个对象了,那第一步就是要去创建对象。

 
 
  • 第 1 步,调用 Bean 的构造函数。 来去实例化当前 Bean 的对象。
  • 第 2 步,依赖注入。 像是一些 @Autowired 或者 @Value 标明的属性,这些都是在依赖注入中完成。
  • 第 3 步,Aware 接口。 比较常见的有三个,它们都是以 Aware 结尾的接口,如果 Bean 实现了这些接口,就要重写里面的方法:

BeanNameAware:在初始化过程中可以获取到 Bean 的名称。

BeanFactoryAware:在初始化过程中可以获取到 Bean 工厂。

ApplicationContextAware:在初始化过程中可以获取到应用上下文。

以上这些内容都是为了方便对 Bean 进行扩展。

  • 第 4 步,BeanPostProcessor#before。 BeanPostProcessor 是 Bean 的后置处理器,用来增强 Bean 的功能的,在初始化方法调用之前(before)进行回调。这个 BeanPostProcessor 后置处理器在 Bean 的生命中其中占有非常重要的作用,需要重点记忆。
  • 第 5 步,调用初始化方法。 里面有两部分:

InitializingBean:这是一个接口类,如果当前 Bean 实现了这个接口的话,就要重写里面的方法,这一步就是来执行重写之后的方法。

自定义init方法:比如在 Bean 中的某一个方法使用了注解 @PostConstruct,这里就会去执行标明了注解的方法。其实自定义 init 方法也是从 BeanDefinition 中读取到的信息。

  • 第 6 步,BeanPostProcessor#after。 还是在 Bean 的后置处理器中执行,但是是在初始化方法之后(after)执行。在 Spring 中对 Bean 进行增强的话,都是用到这个初始化方法之后执行的后置处理器。其实在 Spring 内部就使用到了很多的后置处理器,比较典型的就是:当一个类被曾倩了,使用到了 AOP,那这个类通常都是使用后置处理器(BeanPostProcessor#after)来增强的。我们知道 AOP 的底层使用的是动态代理,有两种:JDK 动态代理、CGLIB 动态代理。

到这一步之后,基本上这个对象就创建完成了,现在就可以从 Spring 容器中去获取和使用这个 Bean 对象了。

注意: 从 依赖注入 开始到 BeanPostProcessor#after 完成之后,都是针对当前的 Bean 进行初始化赋值,当然也做了一些增强。这里需要注意,Spring 中 Bean 的创建是一步一步完成的,也就是说 **Bean 的创建和初始化赋值是分开的**。调用构造函数就是创建 Bean 对象,但是这里创建好后是一个空对象,里面没有值,下面就是初始化赋值的过程。
  • 第 6 步,销毁 Bean。 当 Spring 容器关闭之后,这个 Bean 对象就要执行销毁的操作了。比较典型的是,如果在某个方法上使用了 @PreDestroy 这个注解,那这个方法就是一个销毁的方法,Spring 容器关闭的时候就会执行这个销毁的方法。

以上就是 Bean 的生命周期,里面的步骤还是挺多的。为了方便加深印象,我们可以用代码的方式去验证一下。

三、代码验证

1.User 实体类

User.java

继承了BeanNameAwareBeanFactoryAwareApplicationContextAwareInitializingBean 接口。

package com.demo.lifecycle;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.BeanFactoryAware;
import org.springframework.beans.factory.BeanNameAware;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;

import javax.annotation.PreDestroy;

@Component
public class User implements BeanNameAware, BeanFactoryAware, ApplicationContextAware, InitializingBean {



    public User() {


        System.out.println("User类的构造方法被调用了...");
    }

    /**
     * 姓名
     */
    private String name;

    @Value("张三")
    public void setName(String name) {


        System.out.println("setName方法被调用了...");
        this.name = name;
    }

    @Override
    public void setBeanName(String name) {


        System.out.println("BeanNameAware接口的setBeanName方法被调用了,bean的名字是:" + name);
    }

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {


        System.out.println("BeanFactoryAware接口的setBeanFactory方法被调用了...");
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {


        System.out.println("ApplicationContextAware接口的setApplicationContext方法被调用了...");
    }

    @Override
    public void afterPropertiesSet() {


        System.out.println("InitializingBean接口的afterPropertiesSet方法被调用了...");
    }

    @PreDestroy
    public void destroy() {


        System.out.println("PreDestroy注解的destroy方法被调用了...");
    }
}

2.MyBeanPostProcessor 后置处理器

MyBeanPostProcessor.java

定义了 #before 和 #after 方法的增强实现。

package com.demo.lifecycle;

import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.InvocationHandler;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;
import java.util.Objects;

@Component
public class MyBeanPostProcessor implements BeanPostProcessor {



    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) {


        System.out.println("BeanPostProcessor接口的postProcessBeforeInitialization方法被调用了 -> user对象初始化方法前开始增强....");
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) {


        if (Objects.equals(beanName, "user")) {


            System.out.println("BeanPostProcessor接口的postProcessAfterInitialization方法被调用了 -> user对象初始化方法后开始增强....");
            // cglib代理对象
            /*Enhancer enhancer = new Enhancer();
            // 设置需要增强的类
            enhancer.setSuperclass(bean.getClass());
            // 执行回调方法,增强方法
            enhancer.setCallback(new InvocationHandler() {
                @Override
                public Object invoke(Object o, Method method, Object[] objects) throws Throwable {
                    // 执行目标方法
                    return method.invoke(bean, objects);
                }
            });
            // 创建代理对象
            return enhancer.create();*/
        }
        return bean;
    }
}

3.SpringConfig 扫描包配置

SpringConfig.java

配置了扫描包位置,只扫描 User 实体类和 MyBeanPostProcessor 后置处理器。

package com.demo.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@ComponentScan("com.demo.lifecycle")
public class SpringConfig {


}

4.UserTest 测试类

UserTest.java

main 方法执行,使用 SpringConfig 配置创建上下文,并从容器中获取 user 的 Bean 对象。

package com.demo.test;

import com.demo.config.SpringConfig;
import com.demo.lifecycle.User;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class UserTest {



    public static void main(String[] args) {


        ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
        User user = ctx.getBean(User.class);
        System.out.println(user);
    }
}

5.测试结果

由于我使用的是 SpringBoot 项目进行的测试,会多打印一些日志,其中不带时间前缀的是我们手动 println 的日志。

Connected to the target VM, address: '127.0.0.1:61642', transport: 'socket'
20:03:56.949 [main] DEBUG org.springframework.context.annotation.AnnotationConfigApplicationContext - Refreshing org.springframework.context.annotation.AnnotationConfigApplicationContext@9660f4e
20:03:56.985 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'org.springframework.context.annotation.internalConfigurationAnnotationProcessor'
20:03:57.100 [main] DEBUG org.springframework.context.annotation.ClassPathBeanDefinitionScanner - Identified candidate component class: file [D:\IdeaProjects\SpringBootExamples\springboot-demo\target\classes\com\demo\lifecycle\MyBeanPostProcessor.class]
20:03:57.105 [main] DEBUG org.springframework.context.annotation.ClassPathBeanDefinitionScanner - Identified candidate component class: file [D:\IdeaProjects\SpringBootExamples\springboot-demo\target\classes\com\demo\lifecycle\User.class]
20:03:57.266 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'org.springframework.context.event.internalEventListenerProcessor'
20:03:57.270 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'org.springframework.context.event.internalEventListenerFactory'
20:03:57.272 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'org.springframework.context.annotation.internalAutowiredAnnotationProcessor'
20:03:57.275 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'org.springframework.context.annotation.internalCommonAnnotationProcessor'
20:03:57.281 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'myBeanPostProcessor'
20:03:57.304 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'springConfig'
BeanPostProcessor接口的postProcessBeforeInitialization方法被调用了 -> user对象初始化方法前开始增强....
20:03:57.305 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'user'
User类的构造方法被调用了...
setName方法被调用了...
BeanNameAware接口的setBeanName方法被调用了,bean的名字是:user
BeanFactoryAware接口的setBeanFactory方法被调用了...
ApplicationContextAware接口的setApplicationContext方法被调用了...
BeanPostProcessor接口的postProcessBeforeInitialization方法被调用了 -> user对象初始化方法前开始增强....
InitializingBean接口的afterPropertiesSet方法被调用了...
BeanPostProcessor接口的postProcessAfterInitialization方法被调用了 -> user对象初始化方法后开始增强....
User类的构造方法被调用了...
com.demo.lifecycle.User@2235eaab
Disconnected from the target VM, address: '127.0.0.1:61642', transport: 'socket'

Process finished with exit code 0

可以看到日志是按照我们梳理的 Bean 的生命周期顺序打印的,验证完毕。

6.模拟 AOP 增强

MyBeanPostProcessor.javapostProcessAfterInitialization() 方法中注释了 AOP 底层 CGLIB 动态代理的演示代码的,可以在 UserTestmain 方法中获取到 user 的 Bean 对象后,将鼠标放到 user 上看下,打开和关闭 CGLIB 代理的注释生成的 user Bean 会不同:

关闭 CGLIB 代理:

 
 

打开 CGLIB 代理:

 
 

三、总结

问: Spring 中 Bean 的生命周期是什么样的?

答:

① 通过 BeanDefinition 获取 Bean 的定义信息;
② 调用构造函数实例化 Bean;
③Bean 的依赖注入;
④ 处理 Aware 接口(BeanNameAware、BeanFactoryAware、ApplicationContextAware);
⑤Bean 的后置处理器 BeanPostProcessor-前置;
⑥ 初始化方法(InitializingBean、init-method);
⑦Bean 的后置处理器 BeanPostProcessor-后置;
⑧ 销毁 Bean。

整理完毕,完结撒花~ 🌻

参考地址:

1、 框架篇-05-Spring-bean 的生命周期,https://www.bilibili.com/video/BV1yT411H7YK/?p=39&spm_id_from=333.1007.top_right_bar_window_history.content.click&vd_source=cf16f2e5f7c4612add10f9f9268a2c8a;

上次编辑于:
贡献者: Andy