通常，应用程序开发人员不需要子类化ApplicationContext实现类。相反，可以通过插入特殊集成接口的实现来扩展Spring IoC容器。下图展示了Spring Bean的生命周期。而在这其中，与一些拓展点是非常相关的。也就是说，这些拓展点作用了Bean的生命周期中。（在看下面的拓展点的时候，可以结合这个图，观察拓展点所处于的生命周期位置）

image.png

1. FactoryBean(用于自定义实例化逻辑)

FactoryBean通常是用来创建比较复杂的bean，一般的bean 直接用xml配置即可，但如果一个bean的创建过程中涉及到很多其他的bean 和复杂的逻辑，用xml配置比较困难，这时可以考虑用FactoryBean。

• 定义需要创建的Bean

public class Tool {
    private int id;
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public Tool(int id) {
        this.id = id;
    }
}

• 实现FactoryBean

public class ToolFactory implements FactoryBean<Tool> {

    private int factoryId;
    private int toolId;
    //获取所创建的Bean
    @Override
    public Tool getObject() throws Exception {
        return new Tool(toolId);
    }
    //获取对象类型
    @Override
    public Class<?> getObjectType() {
        return Tool.class;
    }
    public int getFactoryId() {
        return factoryId;
    }
    //设置是否单例
    @Override
    public boolean isSingleton() {
        return false;
    }
    public void setFactoryId(int factoryId) {
        this.factoryId = factoryId;
    }
    public int getToolId() {
        return toolId;
    }
    public void setToolId(int toolId) {
        this.toolId = toolId;
    }
}

创建Tool这个Bean的具体过程都交给了ToolFactory来管理,也就是创建的细节都有它控制.

• 把FactoryBean创建Bean交给容器管理。

@Configuration
public class FactoryBeanAppConfig implements InitializingBean,BeanPostProcessor {
   //注入到容器里面
    @Bean(name="tool")
    public ToolFactory toolFactory() {
        ToolFactory factory = new ToolFactory();
        factory.setFactoryId(7070);
        factory.setToolId(2);
        return factory;
    }

• 通过name = "&tool"来获取到ToolFactory,因为ToolFactory本身也是Bean,由Spring容器管理.

     //注入Tool
    @Autowired
    Tool tool;
   //注入ToolFactory
    @Resource(name = "&tool")
    ToolFactory toolFactory;

2. InitializingBean和DisposableBean

IInitializingBean和DisposableBean中前者是在容器对Bean必要的属性做了初始化后，再做后续的初始化。后者是容器对Bean销毁之前做一个回调。

• InitializingBean
  InitializingBean只有一个方法,允许你在初始化之后做个回调。

void afterPropertiesSet() throws Exception;

通常来说，不推荐使用InitializingBean,因为它和Spring耦合太紧密了。推荐使用 @PostConstruct 注解 或者一个具体的 POJO 初始化方法。推荐使用的与InitializingBean效果是一样的，但是前者就没有和Spring耦合。

<bean id="exampleInitBean" class="examples.ExampleBean" init-method="init"/>

而 @PostConstruct 注解 则需要在支持Servlet2.5的容器使用。

 public class CachingMovieLister {

    @PostConstruct
    public void populateMovieCache() {
        // populates the movie cache upon initialization...
    }

    @PreDestroy
    public void clearMovieCache() {
        // clears the movie cache upon destruction...
    }
}

这三种方法的效果是一样的，但是当同时配置的时候，按照Spring Bean的生命周期，执行的顺序如下：

1. 使用@PostConstruct注解的方法。
2. InitializingBean中的afterPropertiesSet()方法。
3. 自定义的init()方法。

对应的，销毁中@PreDestroy,DisposableBean,自定义的destroy()效果一样，执行顺序与初始化的顺序对应一样。这两类在初始化之前和销毁之前的回调通常用于缓存的初始加载和缓存的清除这样的场景。

3. BeanNameAware,BeanFactoryAware,ApplicationContextAware

• BeanNameAware使得对象能够感知到bean的名称。通常用于把beanName记录在日志。
• BeanFactoryAware使得我们可以获取到BeanFactory,进而可以获取到bean，或者判断bean是否是单例。
• ApplicationContextAware使得我们获取到ApplicationContext的具体实现类这个容器。这个ApplicationContext比BeanFactory功能更强大。

使用 BeanNameAware,BeanFactoryAware,ApplicationContextAware值需要实现接口里面相应的方法即可。通常来说，定义一个类变量来分别纪录下感知的的Name,BeanFactory,ApplicationContext即可。

    @Override
    public void setBeanName(String s) {
        System.out.println(s);
        System.out.println("setBeanName方法被调用");
    }

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        System.out.println(beanFactory.containsBean("person"));
        System.out.println(beanFactory.isSingleton("person"));
        System.out.println("setBeanFactory被调用,beanFactory");
    }
   //功能比beanFactory功能更强大些
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        System.out.println(applicationContext.getId());
        System.out.println(applicationContext.containsBean("person"));
        System.out.println("setApplicationContext被调用");
    }

在大多数情况下，我们应该避免使用这些Aware接口，因为它和Spring耦合太多。

4. BeanPostProcessor，BeanFactoryPostProcessor

• BeanPostProcessor是在整个bean已经创建，并且设置好类成员属性之后，即spring容器已经实例化一个bean后。通过回调方法去实现自定义的实例逻辑.通常用于检查bean属性的有效性，每个bean在初始化（init-method,InitializingBean等初始化方法）前后，都会回调BeanPostProcessor中的方法。
• BeanFactoryPostProcessor 主要用于改变bean的Metadata。Spring容器允许BeanFactoryPostProcessor去读取配置元属性，并改变它。它在BeanPostProcessor之前执行。

  public class MyBeanPostProcessor implements BeanPostProcessor,BeanFactoryPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        // TODO Auto-generated method stub
        if(bean instanceof Person) {
            ((Person) bean).setName("sb");
        }
        System.out.println("postProcessBeforeInitialization被调用");
        return bean;
    }
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        // TODO Auto-generated method stub
        System.out.println("postProcessAfterInitialization被调用");
        return bean;
    }

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
        System.out.println("BeanFactoryPostProcessor被调用");
    }
}

这样，SpringBean的生命周期就被串联起来了。如下

• 首先容器启动后，会对scope为singleton且非懒加载的bean进行实例化，

• 按照Bean定义信息配置信息，注入所有的属性，

• 如果Bean实现了BeanNameAware接口，会回调该接口的setBeanName()方法，传入该Bean的id，此时该Bean就获得了自己在配置文件中的id，

• 如果Bean实现了BeanFactoryAware接口,会回调该接口的setBeanFactory()方法，传入该Bean的BeanFactory，这样该Bean就获得了自己所在的BeanFactory，

• 如果Bean实现了ApplicationContextAware接口,会回调该接口的setApplicationContext()方法，传入该Bean的ApplicationContext，这样该Bean就获得了自己所在的ApplicationContext，

• 如果有Bean实现了BeanPostProcessor接口，则会回调该接口的postProcessBeforeInitialzation()方法，

• 如果Bean实现了InitializingBean接口，则会回调该接口的afterPropertiesSet()方法，(初始化之一）

• 如果Bean配置了init-method方法，则会执行init-method配置的方法，（初始化之一）

• 如果有Bean实现了BeanPostProcessor接口，则会回调该接口的postProcessAfterInitialization()方法，

• 经过流程9之后，就可以正式使用该Bean了,对于scope为singleton的Bean,Spring的ioc容器中会缓存一份该bean的实例，而对于scope为prototype的Bean,每次被调用都会new一个新的对象，期生命周期就交给调用方管理了，不再是Spring容器进行管理了

• 容器关闭后，如果Bean实现了DisposableBean接口，则会回调该接口的destroy()方法，

• 如果Bean配置了destroy-method方法，则会执行destroy-method配置的方法，至此，整个Bean的生命周期结束。

参考文章：
spring官方文档
Spring Bean生命周期