Spring注解驱动-生命周期（二）

bean的生命周期是指：创建->初始化->销毁。bean的生命周期是由Spring容器帮我们管理的，我们可以自定义bean生命周期的初始化和销毁方法，当容器进行到当前生命周期的时候，就会调用我们自定义的方法。

1.@Bean指定初始化和销毁方法

在使用xml的时候，可以在bean标签上指定init-method属性和destroy-method属性。

创建一个新的配置类MainConfigOfLifeCycle.java和一个Car.java类，在Car类里加入构造方法，自定义的初始化方法和自定义的销毁方法，将Car类注入Spring容器，在@Bean上添加initMethod属性和destroyMethod属性即可指定初始化和销毁方法。

package com.atguigu.config;

import com.atguigu.bean.Car;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class MainConfigOfLifeCycle {
    @Bean(initMethod = "init", destroyMethod = "destroy")
    // @Scope("prototype")
    public Car car() {
        return new Car();
    }
}

package com.atguigu.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");
    }
}

编写测试方法进行测试。

@Test
public void testInitAndDestroy() {
    // 创建容器
    AnnotationConfigApplicationContext annotationConfigApplicationContext = new AnnotationConfigApplicationContext(MainConfigOfLifeCycle.class);
    System.out.println("容器创建完成");
    // 获取bean
    Object car = annotationConfigApplicationContext.getBean("car");
    // 关闭容器
    annotationConfigApplicationContext.close();
}

对于单实例的bean，在容器初始化的时候，会调用init方法，在容器销毁的时候，会调用destroy方法。

对于多实例的bean，在容器初始化的时候，不调用init方法，在获取的时候进行创建，此时调用init方法，在容器销毁的时候，不会执行destroy方法。

2.InitializingBean和DisposableBean

Spring还提供了另外的方式实现bean的自定义初始化和销毁逻辑。让Bean实现InitializingBean接口的afterPropertiesSet()方法，实现DisposableBean接口的destroy()方法，分别完成初始化逻辑和销毁逻辑。

创建Dog.java实现InitializingBean和DisposableBean接口的方法，在配置类中注入Dog类。

package com.atguigu.bean;

import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;

public class Dog implements InitializingBean, DisposableBean {
    public Dog() {
        System.out.println("Dog构造器方法");
    }

    public void destroy() throws Exception {
        System.out.println("Dog.destroy");
    }

    public void afterPropertiesSet() throws Exception {
        System.out.println("Dog.afterPropertiesSet");
    }
}

3.@PostConstruct&@PreDestroy

可以使用JSR250中的@PostConstruct和@PreDestroy注解也可以用来执行初始化和销毁方法。@PostConstruct在bean创建完成并且属性赋值完成，执行初始化方法，@PreDestroy在容器销毁bean之前进行清理工作。

创建Cat.java类，编写init方法和destroy方法，分别用@PostConstruct和@PreDestroy进行标注。将Cat加入到容器中。

package com.atguigu.bean;

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

public class Cat {
    public Cat() {
        System.out.println("Cat构造器");
    }

    // 对象创建完成并且赋值完成之后调用
    @PostConstruct
    public void init() {
        System.out.println("Cat.init");
    }

    // 容器移除对象之前执行
    @PreDestroy
    public void destroy() {
        System.out.println("Cat.destroy");
    }
}

4.BeanPostProcessor-后置处理器

BeanPostProcessor是一个接口，作为bean的后置处理器，在bean初始化前后进行一些处理工作。接口中有两个方法：postProcessBeforeInitialization()和postProcessAfterInitialization()，分别代表初始化之前和初始化之后进行的一些操作。

package com.atguigu.bean;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;

public class MyBeanPostProcessor implements BeanPostProcessor {
    public Object postProcessBeforeInitialization(Object o, String s) throws BeansException {
        System.out.println(s + "->MyBeanPostProcessor.postProcessBeforeInitialization");
        return o;
    }

    public Object postProcessAfterInitialization(Object o, String s) throws BeansException {
        System.out.println(s + "->MyBeanPostProcessor.postProcessAfterInitialization");
        return o;
    }
}

将后置处理器添加到容器中，运行测试方法查看效果。

5.BeanPostProcessor原理

查看AbstractAutowireCapableBeanFactory类的initializeBean()方法。

protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {
    if (System.getSecurityManager() != null) {
        AccessController.doPrivileged(new PrivilegedAction<Object>() {
            public Object run() {
                AbstractAutowireCapableBeanFactory.this.invokeAwareMethods(beanName, bean);
                return null;
            }
        }, this.getAccessControlContext());
    } else {
        this.invokeAwareMethods(beanName, bean);
    }
    Object wrappedBean = bean;
    if (mbd == null || !mbd.isSynthetic()) {
        wrappedBean = this.applyBeanPostProcessorsBeforeInitialization(bean, beanName);// 执行postProcessBeforeInitialization()方法
    }
    try {
        this.invokeInitMethods(beanName, wrappedBean, mbd);// 执行初始化方法
    } catch (Throwable var6) {
        throw new BeanCreationException(mbd != null ? mbd.getResourceDescription() : null, beanName, "Invocation of init method failed", var6);
    }
    if (mbd == null || !mbd.isSynthetic()) {
        wrappedBean = this.applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);// 执行postProcessAfterInitialization()方法
    }
    return wrappedBean;
}

再看applyBeanPostProcessorsBeforeInitialization()方法和applyBeanPostProcessorsAfterInitialization()方法，它们非常相似。都是取出所有的postProcessor，然后挨个执行，如果执行到某一个返回null，退出循环。

public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName) throws BeansException {
    Object result = existingBean;
    Iterator var4 = this.getBeanPostProcessors().iterator();
    do {
        if (!var4.hasNext()) {
            return result;
        }
        BeanPostProcessor beanProcessor = (BeanPostProcessor)var4.next();
        result = beanProcessor.postProcessBeforeInitialization(result, beanName);
    } while(result != null);
    return result;
}

public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName) throws BeansException {
    Object result = existingBean;
    Iterator var4 = this.getBeanPostProcessors().iterator();
    do {
        if (!var4.hasNext()) {
            return result;
        }
        BeanPostProcessor beanProcessor = (BeanPostProcessor)var4.next();
        result = beanProcessor.postProcessAfterInitialization(result, beanName);
    } while(result != null);
    return result;
}

在initializeBean()方法之前，会执行一个populateBean()方法给bean的属性赋值。

6.BeanPostProcessor在Spring底层的使用

在MyBeanPostProcessor类的两个方法里打断点，debug模式运行，看一下整个流程。

通过调用栈信息，先将光标定位在测试类里面，也就是new AnnotationConfigApplicationContext(MainConfigOfLifeCycle.class)上。点进去AnnotationConfigApplicationContext()的构造方法，继续查看refresh()方法，finishBeanFactoryInitialization()方法，preInstantiatSingletons()方法。在preInstantiatSingletons()方法里，循环所有的bean进行实例化。继续看getBean()方法，doGetBean()方法。在doGetBean()方法里，会判断当前实例是singleton的还是prototype的。这里是单例，所以会调用getSingleton()方法，通过单例工厂创建出单例对象。继续看getObject()方法，createBean()方法，doCreateBean()方法，在doCreateBean()方法里，会调用initializeBean()方法，在initializeBean()方法里，就可以看到applyBeanPostProcessorsBeforeInitialization()方法和applyBeanPostProcessorsAfterInitialization()方法了，在它们中间有一个invokeInitMethods()方法。

在invokeInitMethods()方法中，我们看到afterPropertiesSet()方法在前，getInitMethodName()方法在后，在这里被调用。