Spring Bean的初始化方法 和销毁方法

① bean的创建-> 初始化-> 销毁方法

由容器管理Bean的生命周期，我们可以通过自己指定bean的初始化方法和bean的销毁方法。

public class Car {

    public Car() {
        System.out.println("Car的构造方法..........");
    }


    public void init() {
        System.out.println("Car的初始化方法......init");
    }

    public void destroy() {
        System.out.println("Car的销毁方法.....destroy");
    }
}

@Configuration
public class MainConfig {
   
    //指定了bean的生命周期的初始化方法和销毁方法.

@Bean(initMethod = "init",destroyMethod = "destroy")
    public Car car() {
        return new Car();
    }
}

public class MainClass {

    public static void main(String[] args) {
        AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(MainConfig.class);
        //Car car = ctx.getBean(Car.class);

        ctx.close();
    }
}

> 执行结果

Car的构造方法..........
Car的初始化方法......init
Car的销毁方法.....destroy

• 针对单实例bean的话，容器启动的时候，bean的对象就创建了，而且容器销毁的时候，也会调用Bean的销毁方法

• 针对多实例bean的话,容器启动的时候，bean是不会被创建的而是在获取bean的时候被创建，而且bean的销毁不受IOC容器的管理.

• 实体Bean的构建

(1) 基于Class构建

<bean class="com.yj.spring.HelloSpring"></bean>

(2) 构造方法构建

<bean class="com.yj.spring.HelloSpring">
    <constructor-arg name="name" type="java.lang.String" value="luban"/>
    <constructor-arg index="1" type="java.lang.String" value="sex" />
</bean>

如果需要基于参数进行构建，就采用构造方法构建，其对应属性如下： name:构造方法参数变量名称 type:参数类型 index:参数索引，从0开始 value:参数值，spring 会自动转换成参数实际类型值 ref:引用容串的其它对象

(3) 静态工厂方法创建

<bean class="com.yj.spring.HelloSpring" factory-method="build">
    <constructor-arg name="type" type="java.lang.String" value="B"/>
</bean>

如果你正在对一个对象进行A/B测试 ，就可以采用静态工厂方法的方式创建，其于策略创建不同的对像或填充不同的属性。 该模式下必须创建一个静态工厂方法，并且方法返回该实例，spring 会调用该静态方法创建对象。

public static HelloSpring build(String type) {
    if (type.equals("A")) {
        return new HelloSpring("luban", "man");
    } else if (type.equals("B")) {
        return new HelloSpring("diaocan", "woman");
    } else {
        throw new IllegalArgumentException("type must A or B");
    }
}

(4) FactoryBean创建

<bean class="com.yj.spring.YjFactoryBean" id="helloSpring123"></bean>

指定一个Bean工厂来创建对象，对象构建初始化 完全交给该工厂来实现。配置Bean时指定该工厂类的类名。

public class YjFactoryBean implements FactoryBean {
    @Override
    public Object getObject() throws Exception {
        return new HelloSpring();
    }
    @Override
    public Class<?> getObjectType() {
        return HelloSpring.class;
    }
    @Override
    public boolean isSingleton() {
        return false;
    }
}

② 通过 InitializingBean和DisposableBean 的二个接口实现bean的初始化以及销毁方法。

@Component
public class Person implements InitializingBean,DisposableBean {
    public Person() {
        System.out.println("Person的构造方法");
    }
    @Override
    public void destroy() throws Exception {
        System.out.println("DisposableBean的destroy()方法 ");
    }
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("InitializingBean的 afterPropertiesSet方法");
    }
}

结果

Person的构造方法
InitializingBean的 afterPropertiesSet方法
DisposableBean的destroy()方法

③ 通过JSR250规范 提供的注解@PostConstruct 和@ProDestory标注的方法

@Component
public class Book {
    public Book() {
        System.out.println("book 的构造方法");
    }
    @PostConstruct
    public void init() {
        System.out.println("book 的PostConstruct标志的方法");
    }
    @PreDestroy
    public void destory() {
        System.out.println("book 的PreDestory标注的方法");
    }
}

④ 通过Spring的 BeanPostProcessor 的 bean的后置处理器会拦截所有bean创建过程

public class Car {

    public Car() {
        System.out.println("Car的构造方法..........");
    }


    public void init() {
        System.out.println("Car的初始化方法......init");
    }

    public void destroy() {
        System.out.println("Car的销毁方法.....destroy");
    }
}
// 会拦截所有的初始化的类
@Component
public class YjBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("YjBeanPostProcessor...postProcessBeforeInitialization:"+beanName);
        return bean;
    }
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("YjBeanPostProcessor...postProcessAfterInitialization:"+beanName);
        return bean;
    }
}
@Configuration
public class MainConfig {
    @Bean(initMethod = "init",destroyMethod = "destroy")
    public Car car() {
        return new Car();
    }


}

执行结果

YjBeanPostProcessor...postProcessBeforeInitialization:org.springframework.context.event.internalEventListenerProcessor
YjBeanPostProcessor...postProcessAfterInitialization:org.springframework.context.event.internalEventListenerProcessor
YjBeanPostProcessor...postProcessBeforeInitialization:org.springframework.context.event.internalEventListenerFactory
YjBeanPostProcessor...postProcessAfterInitialization:org.springframework.context.event.internalEventListenerFactory
YjBeanPostProcessor...postProcessBeforeInitialization:mainConfig
YjBeanPostProcessor...postProcessAfterInitialization:mainConfig
Car的构造方法..........
YjBeanPostProcessor...postProcessBeforeInitialization:car
Car的初始化方法......init
YjBeanPostProcessor...postProcessAfterInitialization:car
Car的销毁方法.....destroy

** 加载源码 **

BeanPostProcessor的执行时机

populateBean(beanName, mbd, instanceWrapper)
initializeBean{
    applyBeanPostProcessorsBeforeInitialization()
    invokeInitMethods{
        isInitializingBean.afterPropertiesSet
        自定义的init方法
    }
    applyBeanPostProcessorsAfterInitialization()方法
}

• postProcessBeforeInitialization 在init方法之前调用
• postProcessAfterInitialization 在init方法之后调用