Bean的生命周期

  • Z时代
  • 2024-01-10
  • 分类：综合

编程

MainConfig.class

package com.lun.annotation.config;
import com.lun.annotation.data.Car;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Scope;
/**
 * Bean的生命周期
 * bean创建----初始化----销毁的过程
 *
 * 容器管理bean的生命周期
 * 我们可以自定义初始化方法和销毁方法，容器在bean进行到当前生命周期的时候来调用自定义的初始化和销毁方法
 *
 * 构造（对象创建）
 * 单实例：在容器启动的时候创建对象
 * 多实例：在每次获取的时候创建对象
 *
 * 初始化
 * 对象创建完成，并赋值，之后调用initMethod
 *
 * 销毁
 * 单实例：容器关闭的时候
 * 多实例：容器不会管理这个bean，容器不会调用destroyMethod
 *
 * 遍历得到容器中所有的BeanPostProcessor,逐个执行beforeInitialization
 * 一旦返回null，跳出for循环，不会执行BeanPostProcessor.postProcessBeforeInitialization
 *
 * BeanPostProcessor原理
 * populateBean(beanName,mbd,instanceWrapper),给bean属性赋值
 * initializeBean
 * {
 *     applyBeanPostProcessorBeforeInitialization(wrappedBean,beanName)
 *     invokeInitMethods(beanName,wrappedBean,mbd)执行自定义初始化方法
 *     applyBeanPostProcessorAfterInitialization(wrappedBean,beanName)
 * }
 *
 * 1) 指定初始化和销毁方法
 * 使用@Bean指定initMethod和destroyMethod
 *
 * 2) 通过让Bean实现InitializingBean(定义初始化逻辑)
 *                  DisposableBean(定义销毁逻辑)
 *
 * 3) 可以使用JSR250,
 * @PostConstruct bean创建完成属性赋值完成之后来执行初始化方法
 * @PreDestroy 在bean被移除之前调用该销毁方法
 *
 * 4) BeanPostProcessor
 *      postProcessBeforeInitialization：在初始化工作之前，即initMethod、afterProperties、PostConstruct方法执行之前
 *      postProcessAfterInitialization：在初始化工作之后，即initMethod、afterProperties、PostConstruct方法执行之后
 *
 *  Spring底层对BeanPostProcessor的使用
 *
 *  Bean赋值、注入其他组件、@Autowired、生命周期注解功能、@Async等
 *
 */
@ComponentScan("com.lun.annotation")
@Configuration
public class MainConfig {
    @Scope
    @Bean(initMethod = "init", destroyMethod = "destroy")
    public Car car() {
        return new Car();
    }
}

MyBeanPostProcessor.class

@Component
public class MyBeanPostProcessor implements BeanPostProcessor {
    /**
     * 在初始化工作之前，即initMethod、afterProperties、PostConstruct方法执行之前
     */
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("postProcessBeforeInitialization...>>>" + bean);
        return bean;
    }
    /**
     * 在初始化工作之后，即initMethod、afterProperties、PostConstruct方法执行之后
     */
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("postProcessAfterInitialization...>>>" + bean);
        return bean;
    }
}

Car.class

public class Car {
    public Car() {
        System.out.println("car...constructor...");
    }
    public void init() {
        System.out.println("car...init...");
    }
    public void destroy() {
        System.out.println("car...destroy...");
    }
}

Cat.class

@Component
public class Cat implements InitializingBean, DisposableBean {
    public Cat() {
        System.out.println("cat...constructor...");
    }
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("cat...afterPropertiesSet...");
    }
    @Override
    public void destroy() throws Exception {
        System.out.println("cat...destroy...");
    }
}

Dog.class

@Component
public class Dog {
    public Dog() {
        System.out.println("dog...construct...");
    }
    //对象创建并赋值之后
    @PostConstruct
    public void init() {
        System.out.println("dog...PostConstruct...");
    }
    //容器移除对象之前
    @PreDestroy
    public void destroy() {
        System.out.println("dog...PreDestroy...");
    }
}

以上是 Bean的生命周期 的全部内容， 来源链接： utcz.com/z/516796.html

回到顶部