Bean的生命周期

描述

Bean 的生命周期，就是一个 Bean 从创建到销毁，所经历的各种方法调用。 简单的来说，一个Bean的生命周期分为四个阶段： 实例化(Instantiation)、 属性设置(populate)、初始化(Initialization)、销毁(Destruction)

注意 单例bean 和容器同生共死，多例bean才会被jvm 垃圾回收

实例化

程序启动后，Spring把注解或者配置文件定义好的Bean对象转换成一个BeanDefination对象，然后完成整个BeanDefination的解析和加载的过程。Spring获取到这些完整的对象之后，会对整个BeanDefination进行实例化操作，实例化是通过反射的方式创建对象。

属性设置

实例化后的对象被封装在BeanWrapper对象中，并且此时对象仍然是一个原生的状态，并没有进行依赖注入。Spring根据BeanDefinition中的信息进行依赖注入, populateBean方法来完成属性的注入。

初始化

• 调用Aware接口相关的方法：invokeAwareMethod(完成beanName, beanClassLoader, beanFactory对象的属性设置)
• 调用beanPostProcessor中的前置处理方法（applyBeanPostProcessorsBeforeInitialization）
• 调用InitMethod方法：invokeInitMethod(),判断是否实现了initializingBean接口，如果有，调用afterPropertiesSet方法，没有就不调用
• 调用BeanPostProcessor后置处理方法（applyBeanPostProcessorsAfterInitialization），Spring 的Aop就是在此处实现的

销毁

判断是否实现了DisposableBean接口，调用destoryMethod方法

代码验证

• bean的配置类

package com.tk.bean.config;
	
import com.tk.bean.entity.Book;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @author taoke
 * @desc 实体类配置
 * @date 2022/3/23
 */
@Configuration
public class BookConfig {

    @Bean(initMethod = "myPostConstruct", destroyMethod = "myPreDestroy")
    public Book getBook() {
        Book book = new Book();
        book.setBookName("水浒传");
        return book;
    }
}

• 实体类Book

package com.tk.bean.entity;
	
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.*;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

/**
 * @author taoke
 * @desc 书
 * @date 2022/3/21
 */
public class Book implements BeanNameAware, BeanFactoryAware, ApplicationContextAware, InitializingBean, DisposableBean {

    private String bookName;

    public String getBookName() {
        return bookName;
    }

    public Book() {
        System.out.println("构造方法执行了。。。。 ");
    }

    public void setBookName(String bookName) {
        this.bookName = bookName;
        System.out.println("设置属性执行了，书名是： " + getBookName());
    }

    @Override
    public void setBeanName(String name) {
        System.out.println("setBeanName 方法执行了。。。");
    }

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        System.out.println("setBeanFactory 方法执行了。。。");
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        System.out.println("setApplicationContext 方法执行了。。。");
    }

    //MyBeanPostProcessor.postProcessBeforeInitialization

    @PostConstruct
    public void springPostConstruct() {
        System.out.println("@PostConstruct 执行了。。。");
    }

    @Override
    public void afterPropertiesSet() {
        System.out.println("afterPropertiesSet 执行了。。。");
    }

    public void myPostConstruct() {
        System.out.println("自定义方法 myPostConstruct 执行了。。。");
    }

    //MyBeanPostProcessor.postProcessAfterInitialization
    //Book name = thing king in java

    @PreDestroy
    public void springPreDestroy() {
        System.out.println("@PreDestroy 方法执行了。。。");
    }

    @Override
    public void destroy() {
        System.out.println("destroy 方法执行了。。。");
    }

    public void myPreDestroy() {
        System.out.println("自定义方法 myPreDestroy 执行了。。。 ");
    }

}

BeanPostProcessor

package com.tk.bean.processor;
	
import com.tk.bean.entity.Book;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.stereotype.Component;

/**
 * @author taoke
 * @desc 增强处理
 * @date 2022/3/21
 */
@Component
public class MyBeanPostProcessor implements BeanPostProcessor {

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        if (bean instanceof Book) {
            System.out.println("MyBeanPostProcessor 前置方法 postProcessBeforeInitialization 执行了。。。");
        }
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if (bean instanceof Book) {
            System.out.println("MyBeanPostProcessor 后置方法 postProcessAfterInitialization 执行了。。。");
        }
        return bean;
    }
}

• 启动类

package com.tk.bean;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 * @author taoke
 * @desc 启动类
 * @date 2022/3/21
 */
@SpringBootApplication
public class BeanTestApplication {

    public static void main(String[] args) {
        SpringApplication.run(BeanTestApplication.class);
    }
}

• 运行结果

小结

main方法启动后，Spring读@Bean注解，将注解修饰的对象加载到IOC容器，IOC容器将其转化为BeanDefination对象，并进行实例化，实例化后封装为BeanWrapper对象。然后Spring调用populateBean方法对BeanDefination对象进行属性填充，再调用initializeBean方法完成一些Aware操作，然后调用beanPostProcessor中的前置处理方法，如果实现了initializingBean，则调用afterPropertiesSet方法，然后调用BeanPostProcessor后置处理方法，Aop就是在此处实现的。处理完成后，bean就处于一个就绪状态，等待被调用。销毁时判断是否实现了DisposableBean接口，调用destoryMethod方法。

未经允许不得转载：木盒主机 » Bean的生命周期