Spring 创建bean的整个生命周期分析-源码级别

首先我们需要准备好前置准备：

这个是创建的bean对象

import org.springframework.stereotype.Component;

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

@Component
public class Dog {
    public Dog() {
        System.out.println("dog constructor");
    }

    @PostConstruct
    public void init() {
        System.out.println("dog...@PostConstruct");
    }

    @PreDestroy
    public void destory() {
        System.out.println("dog..PreDestroy");
    }
}

然后写一个后置处理器

@Component
public class MyBeanPostProcessor implements BeanPostProcessor, Ordered {
    @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;
    }

    @Override
    public int getOrder() {
        return 3;
    }
}

这个时候我们去创建一个扫描的bean

import com.mohan.bean.Dog;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@ComponentScan("com.mohan.bean")
public class MainConfigOfLifecle {

    @Bean(initMethod = "init",destroyMethod = "destory")
    public Dog dog() {
        return new Dog();
    }
}

这个时候我们去创建一个测试类

@Test
    public void test11() {
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfigOfLifecle.class);
        System.out.println("容器创建完成");
        for (String name : applicationContext.getBeanDefinitionNames()) {
            System.out.println("name = " + name);
        }
        applicationContext.close();
    }

准备工作完成，下面我们来Debug，这里打一个断点

看到下面要这些堆栈信息

点击这里，从这个地方开始追源码

从这里我们可以看到他新建了一个AnnotationConfigApplicationContext对象，然后去进入了AnnotationConfigApplicationContext对象，执行了refresh()方法

public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
        this();
        this.register(componentClasses);
        this.refresh();
    }

我们继续追，点击debug上面的refresh()方法，可以看到，这个时候，他完成了bean工厂的创建，在这个地方：

this.finishBeanFactoryInitialization(beanFactory);

工厂创建完成之后，这个时候他去获取了一次bean

然后这个时候，他会看你创建的bean的模式了，有三种情况，一种是单例模式，一种是原型模式，一种是你自己定义的方式，（去继承Scpoe接口）
他获取到你的bean是没有的，所以他这个时候就开始去创建bean

这个时候，他会调用你的那个类的构造方法

创建完成了bean之后到了我们最重要的一个地方！！初始化这个bean

可以看到这里有三个地方：第一个地方是

wrappedBean = this.applyBeanPostProcessorsBeforeInitialization(bean, beanName);
这个就是你的初始化的前置处理器了，这个时候就会调用咱们最开始的那个方法：

this.invokeInitMethods(beanName, wrappedBean, mbd);这个地方执行就是真正初始化你的bean的地方了
这个时候会执行咱们的init()方法

最后会调用wrappedBean = this.applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);，这个时候会执行咱们的后置处理器的方法

这个时候，也算真正完成了一个bean的创建
最后咱们的销毁的方法会在容器销毁的时候执行，applicationContext.close();这个时候，前提必须你的bean是单例模式的哈！原型模式的Spring不会管理

总结

Spring的整个生命周期：

首先先去调用注入对象的构造参数 —> createBean
然后去调用初始化bean的初始化前置处理器 -> postProcessBeforeInitialization
然后真正初始化bean的方法 -> init()
然后调用初始化bean的后置处理器 -> postProcessAfterInitialization
最后容器销毁去调用销毁方法 -> Destroy()