spring bean的生命周期getbean()

对象的生命周期:

对象的生命周期-----从出生到死亡,不同的对象有不同的成长过程,对象在对象的存活期间会发生各种动作，做很多的事情，生命因此不同。

spring bean对象的生命周期

创建/实例化
属性赋值
初始化
销毁

初步理解

稍微阅读一点源码,知道spring中getbean是学习bean生命周期的入口.
getbean > dogetbean > createbean >docreatebean
贴上代码,为了方便贴的源码都去掉了无用代码,只关注需要理解的流程.
从spring-BeanFactory接口的getbean开始

AbstractBeanFactory.class
    public Object getBean(String name) {
        return doGetBean(name, null, null, false);
    }

doGebean 源码方法特别长，去掉注释和主线逻辑无关的代码。

protected <T> T doGetBean(
            final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly){

            // Create bean instance. 创建一个bean实例
                if (mbd.isSingleton()) {
                    sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
                        @Override
                        public Object getObject() throws BeansException {
                            
                                return createBean(beanName, mbd, args);        
                    });
                    bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
                }
    }

这一步获取到一个bean实例。getsingleton方法分传参传入了一个匿名内部类对象。
查看createbean是怎么创建这个bean的。
spring-AutowireCapableBeanFactory接口

protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args){
        
        RootBeanDefinition mbdToUse = mbd;
        
        // Prepare method overrides.处理被重写的方法
            mbdToUse.prepareMethodOverrides();
        
            // Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
            //给后处理器一个机会，返回一个代理对象
            Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
            if (bean != null) {
                return bean;
            }
        //生命周期需要关注的流程，doCreateBean
        Object beanInstance = doCreateBean(beanName, mbdToUse, args);
        
        return beanInstance;
    }

createbean方法中三段有用的代码、我都保留了。1.处理被重写的方法。2.给后处理器一个机会，返回一个代理对象。这是springaop的入口，看springaop从这里开始看。3.本次学习的主线doCreateBean。
继续理解doCreateBean

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) {

// Instantiate the bean. 实例化bean，得到一个原始的对象
        BeanWrapper instanceWrapper  = createBeanInstance(beanName, 

// Initialize the bean instance. 初始化bean，对对象进行包装（属性填充）
        Object exposedObject = bean;
        try {
        //属性填充
            populateBean(beanName, mbd, instanceWrapper);
            if (exposedObject != null) {
        //初始化工作
                exposedObject = initializeBean(beanName, exposedObject, mbd);
            }
        }

    }

docreatebean里面主要执行了三个步骤，创建对象、包装对象、初始化对象。这里就是springbean生命周期的前三个步骤了，spring bean在容器关闭之前会被回收（销毁）。这就是spring中bean的整个生命周期了。创建 > 属性填充 > 实例化 > 销毁。

理解spring bean的生命周期不仅仅是知道创建、属性填充、实例化、销毁这四个流程。更重要的是理解bean的生命周期过程中做了些什么事情。

再一次梳理整个生命周期。

getbean方法

直接调用了dogetbean。

@Override
    public Object getBean(String name) throws BeansException {
        return doGetBean(name, null, null, false);
    }

2.doGetBean方法
传入参数：beanname、bean的类型、构造函数的参数、类型检查

1. 别名处理
2. 单例缓存池中去获取bean
3. 缓存池中没有获取到bean，自己创建bean
4. 保证当前bean所依赖的bean的初始化
5. 创建bean实例
6. 检查bean的类型是否和需要的匹配，能匹配直接返回，不能匹配尝试能不能转换，都不行就抛异常。

3.createBean方法,翻译方法注释：这个类的核心方法：创建一个bean实例、填充属性、提供bean的后处理器。

/**
     * Central method of this class: creates a bean instance,
     * populates the bean instance, applies post-processors, etc. 
     * 类的中心方法：创建一个bean实例、填充属性、提供bean的后处理器。
     * @see #doCreateBean
     */
    @Override
    protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) throws BeanCreationException {
        if (logger.isDebugEnabled()) {
            logger.debug("Creating instance of bean '" + beanName + "'");
        }
        RootBeanDefinition mbdToUse = mbd;
        // Prepare method overrides.
        try {
            mbdToUse.prepareMethodOverrides();
        }
        
        try {
            // Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
            //给bean的后处理器一个机会返回一个代理bean
            Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
            if (bean != null) {
                return bean;
            }
        }

        Object beanInstance = doCreateBean(beanName, mbdToUse, args);

        return beanInstance;
    }

拎几段代码出来讲
//给bean的后处理器一个机会返回一个代理bean resolveBeforeInstantiation(beanName, mbdToUse);bean实例化前后执行的后处理器

doCreateBean方法

1. 实例化bean
2. 允许后处理器去修改合并后的bean定义
3. 暴露早期对象，用于解决循环依赖 循环依赖的解决
4. 属性填充
5. 初始化bean
   如果实现Aware接口就调用Aware接口的方法，调用所有的后处理器

最后再梳理整个生命周期。

未完。。。