提供了编程的基础技术教程

zl程序教程

您现在的位置是：首页 >  其他

当前栏目

Bean的生命周期

2023-03-14 22:49:48 时间

Bean的生命周期


（1）调用InstantiationAwareBeanPostProcessor的Before/AfterInstantiation尝试返回一个代理对象

        如果返回null,继续下面的步骤，否则直接返回。

（2）createBeanInstance(beanName, mbd, args)创建bean

（3）population:Bean的属性赋值

       @Autoward的属性注入(AutowiredAnnotationBeanPostProcessor impl InstantiationAwareBeanPostProcessor)

（4）initializeBean：初始化

         4.1处理aware接口

         4.2applyBeanPostProcessorsBeforeInitialization

         4.3initMethod

                  比如init-method,@PostConstruct等配置的初始化方法

        4.4applyBeanPostProcessorsAfterInitialization

                   AOP就是在这里实现的：AnnotationAwareAspectJAutoProxyCreator的postProcessAfterInitialization方法实现包装Bean


1.jpg


1、 AbstractAutowireCapableBeanFactory.createBean


如果


不返回null,直接返回对象


返回null,执行  Object beanInstance = doCreateBean(beanName, mbdToUse, args)  真正的去创建对象


    //public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory implements AutowireCapableBeanFactory
    protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) throws BeanCreationException {
        //获取Bean的定义信息
        RootBeanDefinition mbdToUse = mbd;
 
        try {
            // Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
            //（1）（1）（1）给BeanPostProcessors一个机会返回一个目标代理，如果返回不为空，直接返回
            Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
            if (bean != null) {
                return bean;
            }
        }
        catch (Throwable ex) {
            
        }
        
        //（2）（2）（2）创建对象的核心方法
        Object beanInstance = doCreateBean(beanName, mbdToUse, args);
        
        return beanInstance;
    }


1.1、resolveBeforeInstantiation(beanName, mbdToUse)


这里点进去下面代码的（1.1）和（1.2）进去以后就会发现


bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);


1）遍历所有的BeanPostProcessor


2）获取InstantiationAwareBeanPostProcessor


3）执行InstantiationAwareBeanPostProcessor的postProcessBeforeInstantiation方法


bean = applyBeanPostProcessorsAfterInstantiation(targetType, beanName);


1）遍历所有的BeanPostProcessor


2）获取InstantiationAwareBeanPostProcessor


3）执行InstantiationAwareBeanPostProcessor的postProcessAfterInstantiation方法


    public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory implements AutowireCapableBeanFactory
    protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
        
                    //（1.1）（1.1）（1.1）（1.1）（1.1）（1.1）（1.1）（1.1）
                    bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
                    if (bean != null) {
                        //（1.2）（1.2）（1.2）（1.2）（1.2）（1.2）（1.2）（1.2）（1.2）（1.2）
                        bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
                    }
            
        }
        return bean;
    }


总结：


上面的意思是在bean创建之前先调用InstantiationAwareBeanPostProcessor的Before/AfterInstantiation方法，进行拦截一下


但是一般都返回null,就是没什么用（菜鸡还没发现大神的用途）


1.2、 doCreateBean创建Bean


  1. 1.创建对象
  2. 2.给对象赋值（@Autward）
  3. 3.初始化Bean

//AbstractAutowireCapableBeanFactory
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)
            throws BeanCreationException {
 
        // Instantiate the bean.
        BeanWrapper instanceWrapper = null;
        
        //(1)(1)(1)创建对象
        if (instanceWrapper == null) {
            instanceWrapper = createBeanInstance(beanName, mbd, args);
        }
 
 
        // Initialize the bean instance.
        Object exposedObject = bean;
        try {
         
            //(2)(2)(2)给属性赋值，@Autoward
            populateBean(beanName, mbd, instanceWrapper);
            if (exposedObject != null) {
                //(3)(3)(3)初始化Bean
                exposedObject = initializeBean(beanName, exposedObject, mbd);
            }
        }
 
 
        return exposedObject;
    }


2.1、创建对象


没什么好说的，这里说的创建对象就是创建一个属性为null的对象(我说的简单了)


2.2、给属性赋值


调用InstantiationAwareBeanPostProcessor的postProcessPropertyValues方法完成赋值


比如：调用AutowiredAnnotationBeanPostProcessor的postProcessPropertyValues实现@Autoward赋值


//AbstractAutowireCapableBeanFactory
protected void populateBean(String beanName, RootBeanDefinition mbd, BeanWrapper bw) {
        
        
        //省略
 
        if (hasInstAwareBpps || needsDepCheck) {
            PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
            if (hasInstAwareBpps) {
                for (BeanPostProcessor bp : getBeanPostProcessors()) {
                    if (bp instanceof InstantiationAwareBeanPostProcessor) {
                        InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
                        //☆☆☆调用AutowiredAnnotationBeanPostProcessor的postProcessPropertyValues实现@Autoward赋值
                        pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
                        if (pvs == null) {
                            return;
                        }
                    }
                }
            }
 
        }
 
        applyPropertyValues(beanName, mbd, bw, pvs);
    }


2.3、初始化Bean


1.如果实现BeanFactoryAware等接口，调用setBeanFactory注入对象

2.调用beanProcessor的postProcessBeforeInitialization

3.调用初始化方法，比如init-method,@PostConstruct等配置的方法

4.调用beanProcessor的postProcessAfterInitialization


//AbstractAutowireCapableBeanFactory
protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {
        
        //（1）（1）（1）实现BeanFactoryAware等接口调用里面的setXXX方法
        invokeAwareMethods(beanName, bean);
        
 
        Object wrappedBean = bean;
        if (mbd == null || !mbd.isSynthetic()) {
            //（2）（2）（2）
            wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
        }
 
        try {
             //（3）（3）（3）
            invokeInitMethods(beanName, wrappedBean, mbd);
        }
        catch (Throwable ex) {}
 
        if (mbd == null || !mbd.isSynthetic()) {
            //（4）（4）（4）
            wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
        }
        return wrappedBean;
    }
}


2.3.1、调用BeanFactoryAware等接口的set方法


//AbstractAutowireCapableBeanFactory
private void invokeAwareMethods(final String beanName, final Object bean) {
        if (bean instanceof Aware) {
            if (bean instanceof BeanNameAware) {
                ((BeanNameAware) bean).setBeanName(beanName);
            }
            if (bean instanceof BeanClassLoaderAware) {
                ((BeanClassLoaderAware) bean).setBeanClassLoader(getBeanClassLoader());
            }
            if (bean instanceof BeanFactoryAware) {
                ((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
            }
        }
    }


2.3.2、调用beanProcessor的postProcessBeforeInitialization


AbstractAutowireCapableBeanFactory
public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
            throws BeansException {
 
        Object result = existingBean;
        for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
            result = beanProcessor.postProcessBeforeInitialization(result, beanName);
            if (result == null) {
                return result;
            }
        }
        return result;
    }


2.3.3、调用初始化方法，比如init-method,@PostConstruct等配置的方法


//AbstractAutowireCapableBeanFactory
protected void invokeInitMethods(String beanName, final Object bean, RootBeanDefinition mbd)
            throws Throwable {
 
        boolean isInitializingBean = (bean instanceof InitializingBean);
        if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
            if (logger.isDebugEnabled()) {
                logger.debug("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");
            }
            if (System.getSecurityManager() != null) {
                try {
                    AccessController.doPrivileged(new PrivilegedExceptionAction<Object>() {
                        @Override
                        public Object run() throws Exception {
                            ((InitializingBean) bean).afterPropertiesSet();//☆☆☆
                            return null;
                        }
                    }, getAccessControlContext());
                }
                catch (PrivilegedActionException pae) {
                    throw pae.getException();
                }
            }
            else {
                ((InitializingBean) bean).afterPropertiesSet();//☆☆☆
            }
        }
 
        if (mbd != null) {
            String initMethodName = mbd.getInitMethodName();
            if (initMethodName != null && !(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
                    !mbd.isExternallyManagedInitMethod(initMethodName)) {
                invokeCustomInitMethod(beanName, bean, mbd);//☆☆☆
            }
        }
    }


2.3.4、调用beanProcessor的postProcessAfterInitialization（☆☆☆）


//AbstractAutowireCapableBeanFactory
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
            throws BeansException {
 
        Object result = existingBean;
        for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
            result = beanProcessor.postProcessAfterInitialization(result, beanName);
            if (result == null) {
                return result;
            }
        }
        return result;
    }


 其中AOP就在这一层完成☆☆☆☆☆☆☆


首先@EnableAspectJAutoProxy会引入@Import(AspectJAutoProxyRegistrar.class)（beanProcessor）类

AnnotationAwareAspectJAutoProxyCreator（beanProcessor）会在初始化之前调用postProcessBeforeInitialization

AnnotationAwareAspectJAutoProxyCreator（beanProcessor）会在初始化之后调用

postProcessAfterInitialization(实现AOP功能)


//AbstractAutoProxyCreator
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if (bean != null) {
            Object cacheKey = getCacheKey(bean.getClass(), beanName);
            if (!this.earlyProxyReferences.contains(cacheKey)) {
                //AOP☆☆☆
                return wrapIfNecessary(bean, beanName, cacheKey);
            }
        }
        return bean;
    }


//AbstractAutoProxyCreator
protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
        
 
        // Create proxy if we have advice.
        //获取能匹配到的通知并且封装为拦截器
        Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
        if (specificInterceptors != DO_NOT_PROXY) {
            this.advisedBeans.put(cacheKey, Boolean.TRUE);
            //传入通知拦截器和bean,创建代理
            Object proxy = createProxy(
                    bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
            this.proxyTypes.put(cacheKey, proxy.getClass());
            return proxy;
        }
 
        this.advisedBeans.put(cacheKey, Boolean.FALSE);
        return bean;
    }


1.3 、把对象放入IOC容器中


略


2、总结


2.1、


beanProcessor十分重要，而且有两大种BeanProcessor


一种是在创建对象之前调用postProcessBefore/AfterInstantiation方法；（Instantiation）


一种是在init之前和之后调用  postProcessBefore/AfterInitialization方法；  (initialization)


2.2、


一AOP为例，


引入一个新功能就加注解EnableAspectJAutoProxy


注解上就会引入@Import(AspectJAutoProxyRegistrar.class)


这个register就会引入特殊的BeanProcessor，看看postProcessBefore/After 方法实现了什么增强就大体理解新增功能了


相关文章