Spring中Bean的生命周期

1 指定初始化和销毁方法

• 创建Car类

public class Car {

    public Car() {
        System.out.println("car constructor......");
    }

    public void init(){
        System.out.println("car ...init...");
    }

    public void destory(){
        System.out.println("car ...destory...");
    }
}

• 写配置类

@Configuration
public class MainConfigOfLifeCycle {

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

• 测试

@Test
    public void test01(){
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MainConfigOfLifeCycle.class);
        System.out.println("容器创建完成");
        context.close();
    }

2 使用接口InitializingBean和DisposableBean实现初始化和销毁

• 新建Cat类实现接口InitializingBean和DisposableBean

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

@Component
public class Cat implements InitializingBean, DisposableBean {

    public Cat() {
        System.out.println("cat constructor....");
    }

    //容器关闭时调用
    @Override
    public void destroy() throws Exception {
        System.out.println("cat ... destroy ....");
    }

    //Bean创建完成，并且属性都复制后执行
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("cat ... afterPropertiesSet ...");
    }
}

• 注入IOC容器

@Configuration
@ComponentScan("com.yunfeng.spring2.entity")
public class MainConfigOfLifeCycle {}

• 测试

@Test
    public void test01(){
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MainConfigOfLifeCycle.class);
        System.out.println("容器创建完成");
        context.close();
    }

3 使用JSR250中的@PreDestroy 和@PostConstruct

import org.springframework.stereotype.Component;

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

@Component
public class Dog {

    public Dog() {
        System.out.println("Dog constructor....");
    }

    //容器关闭时调用
    @PreDestroy
    public void destroy() throws Exception {
        System.out.println("Dog ... destroy ....");
    }

    //Bean创建完成，并且属性都复制后执行
    @PostConstruct
    public void afterPropertiesSet() throws Exception {
        System.out.println("Dog ... PostConstruct ...");
    }
}

4 BeanPostProcessor后置处理器

• 在bean初始化前后进行一些处理工作

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

/**
 * 后置处理器：初始化前后进行处理工作
 */
@Component
public class MyBeanPostProcessor implements BeanPostProcessor {
    //初始化前执行
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("postProcessBeforeInitialization..." + beanName + bean);
        return bean;
    }

    //初始化后执行
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("postProcessAfterInitialization..." + beanName + bean);
        return bean;
    }
}

5 总结

在Spring框架中，bean的生命周期中的初始化和实例化的执行顺序是固定的。以下是执行顺序的概述：

• 实例化（Instantiation）：
  首先，Spring容器通过调用bean的构造方法来创建bean的实例。这是bean生命周期的第一步，此时bean对象被创建，但还没有进行任何初始化。
• 依赖注入（Dependency Injection）：
  在实例化之后，Spring容器会进行依赖注入。这意味着，如果bean有依赖的其他bean，Spring会负责将这些依赖注入到刚创建的bean实例中。
• 自定义的BeanPostProcessor（Before Initialization）：
  在bean的依赖注入完成后，Spring容器会调用BeanPostProcessor的postProcessBeforeInitialization方法。这允许开发者在bean的初始化方法执行之前对bean进行自定义的处理。
• 初始化（Initialization）：
  接着，Spring容器会执行bean的初始化方法。这通常包括实现InitializingBean接口的afterPropertiesSet方法，或者在配置文件中使用init-method指定的方法，或者使用JSR250中的@PostConstruct。在这个阶段，bean可以进行一些必要的设置或启动逻辑。
• 自定义的BeanPostProcessor（After Initialization）：
  在bean的初始化方法执行完成后，Spring容器会调用BeanPostProcessor的postProcessAfterInitialization方法。这允许开发者在bean的初始化方法执行之后对bean进行自定义的处理。
• 使用（Bean Usage）：
  在bean完全初始化之后，它就可以被应用程序使用了。这意味着bean的方法可以被调用，bean的功能可以被使用。
• 销毁（Destruction）：
  当Spring容器关闭或bean不再需要时，bean会经历销毁阶段。如果bean实现了DisposableBean接口或配置了destroy-method或者加了@PreDestroy注解，则这些销毁回调方法会被调用。
  总结来说，执行顺序是：

实例化（通过构造方法创建对象）
依赖注入（注入依赖的bean）
自定义的BeanPostProcessor（Before Initialization）
初始化（执行初始化方法）
自定义的BeanPostProcessor（After Initialization）
使用（bean被应用程序使用）
销毁（当容器关闭或bean不再需要时）
在整个过程中，BeanPostProcessor为开发者提供了一个在bean的生命周期中的特定点插入自定义逻辑的机会。

6 AOP代理对象实在那个过程创建的

在Spring的生命周期中，AOP代理对象的创建通常发生在postProcessAfterInitialization阶段，而不是postProcessBeforeInitialization阶段。

这是因为在postProcessBeforeInitialization阶段，Bean的实例化、依赖注入已经完成，但还没有进行自定义的初始化方法（如果有的话）。在这个阶段，Bean还没有完全准备好，因此在这个阶段创建代理对象可能不是最佳时机。

相反，在postProcessAfterInitialization阶段，Bean的实例化、依赖注入和初始化方法（如果有的话）都已经完成。这意味着Bean已经完全准备好并可以使用了。因此，在这个阶段创建AOP代理对象可以确保代理对象包含了Bean的所有必要状态和行为。

Spring容器在初始化Bean之后，会检查是否需要为这个Bean创建AOP代理。如果需要，就会在这个阶段创建代理对象，并替换原始的Bean实例。这样，当应用程序从Spring容器中获取这个Bean时，实际上获取到的是代理对象，而不是原始的Bean实例。

因此，可以得出结论：在Spring的AOP代理对象创建过程中，通常是在postProcessAfterInitialization阶段进行创建的。