SpringBean生命周期之初始化篇

注意事项

阅读本文需要有一定的基础，并且要跟着调用链走，不然会很容易懵圈。

环境

Spring Framework Version：5.3.x

Gradle Version：7.5.1

源码解析

AbstractAutowireCapableBeanFactory

initializeBean

1. 调用Aware方法
2. 初始化之前回调BeanPostProcessor
3. 初始化Bean
4. 初始化之后回调BeanPostProcessor（代理对象也是在此生成）

protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
    //校验安全管理器，一般没有
    if (System.getSecurityManager() != null) {
        AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
            invokeAwareMethods(beanName, bean);
            return null;
        }, getAccessControlContext());
    }
    else {
        //如果当前bean实现了BeanNameAware、BeanClassLoaderAware、BeanFactoryAware这三个Aware接口中的一个或多个，那么会在此方法里调用设置值
        invokeAwareMethods(beanName, bean);
    }
    //包装bean
    Object wrappedBean = bean;
    if (mbd == null || !mbd.isSynthetic()) {
        //在Bean初始化之前回调各种BeanPostProcessor
        wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
    }

    try {
        //初始化Bean
        invokeInitMethods(beanName, wrappedBean, mbd);
    }
    catch (Throwable ex) {
        throw new BeanCreationException(
            (mbd != null ? mbd.getResourceDescription() : null),
            beanName, "Invocation of init method failed", ex);
    }
    if (mbd == null || !mbd.isSynthetic()) {
        //在Bean初始化之后回调各种BeanPostProcessor（包括动态代理对象生成）
        wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
    }

    return wrappedBean;
}

BeanPostProcessor是一个扩展点，在bean初始化前后可以对bean进行一些定制操作

invokeAwareMethods

private void invokeAwareMethods(String beanName, Object bean) {
    //当前bean是否是Aware类型的，如果是，进行一些列的判断并设置值，如果不是，直接跳过设置
    if (bean instanceof Aware) {
        if (bean instanceof BeanNameAware) {
            ((BeanNameAware) bean).setBeanName(beanName);
        }
        if (bean instanceof BeanClassLoaderAware) {
            ClassLoader bcl = getBeanClassLoader();
            if (bcl != null) {
                ((BeanClassLoaderAware) bean).setBeanClassLoader(bcl);
            }
        }
        if (bean instanceof BeanFactoryAware) {
            ((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
        }
    }
}

invokeInitMethods

1. 回调InitializingBean接口中的afterPropertiesSet方法
2. 调用自定义初始化方法（init-method属性）

protected void invokeInitMethods(String beanName, Object bean, @Nullable RootBeanDefinition mbd)
			throws Throwable {
    //当前bean是否是InitializingBean
    boolean isInitializingBean = (bean instanceof InitializingBean);
    if (isInitializingBean && (mbd == null || !mbd.hasAnyExternallyManagedInitMethod("afterPropertiesSet"))) {
        if (logger.isTraceEnabled()) {
            logger.trace("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");
        }
        //安全管理器!=null， 一般都是null
        if (System.getSecurityManager() != null) {
            try {
                AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () -> {
                    ((InitializingBean) bean).afterPropertiesSet();
                    return null;
                }, getAccessControlContext());
            }
            catch (PrivilegedActionException pae) {
                throw pae.getException();
            }
        }
        else {
            //回调InitializingBean接口中的afterPropertiesSet方法
            ((InitializingBean) bean).afterPropertiesSet();
        }
    }

    if (mbd != null && bean.getClass() != NullBean.class) {
        String initMethodName = mbd.getInitMethodName();
        if (StringUtils.hasLength(initMethodName) &&
            !(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
            !mbd.hasAnyExternallyManagedInitMethod(initMethodName)) {
            //调用自定义初始化方法（init-method属性）
            invokeCustomInitMethod(beanName, bean, mbd);
        }
    }
}

invokeCustomInitMethod

1. 获取需要进行调用的自定义初始化方法
2. 检查访问权限，如果没有就进行设置
3. 通过反射invoke

protected void invokeCustomInitMethod(String beanName, Object bean, RootBeanDefinition mbd)
    throws Throwable {

    String initMethodName = mbd.getInitMethodName();
    Assert.state(initMethodName != null, "No init method set");
    //使用反射获取到需要初始化的方法
    Method initMethod = (mbd.isNonPublicAccessAllowed() ?
                         BeanUtils.findMethod(bean.getClass(), initMethodName) :
                         ClassUtils.getMethodIfAvailable(bean.getClass(), initMethodName));

    if (initMethod == null) {
        if (mbd.isEnforceInitMethod()) {
            throw new BeanDefinitionValidationException("Could not find an init method named '" +
                                                        initMethodName + "' on bean with name '" + beanName + "'");
        }
        else {
            if (logger.isTraceEnabled()) {
                logger.trace("No default init method named '" + initMethodName +
                             "' found on bean with name '" + beanName + "'");
            }
            // Ignore non-existent default lifecycle methods.
            return;
        }
    }

    if (logger.isTraceEnabled()) {
        logger.trace("Invoking init method  '" + initMethodName + "' on bean with name '" + beanName + "'");
    }
    //看看初始化方法是否是接口方法，如果找到就是调用接口方法，否则调用原来的方法
    Method methodToInvoke = ClassUtils.getInterfaceMethodIfPossible(initMethod, bean.getClass());

    if (System.getSecurityManager() != null) {
        AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
            ReflectionUtils.makeAccessible(methodToInvoke);
            return null;
        });
        try {
            AccessController.doPrivileged((PrivilegedExceptionAction<Object>)
                                          () -> methodToInvoke.invoke(bean), getAccessControlContext());
        }
        catch (PrivilegedActionException pae) {
            InvocationTargetException ex = (InvocationTargetException) pae.getException();
            throw ex.getTargetException();
        }
    }
    else {
        try {
            //检查访问权限
            ReflectionUtils.makeAccessible(methodToInvoke);
            //通过反射去调用自定义初始化方法
            methodToInvoke.invoke(bean);
        }
        catch (InvocationTargetException ex) {
            throw ex.getTargetException();
        }
    }
}

applyBeanPostProcessorsAfterInitialization

@Override
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
    throws BeansException {

    Object result = existingBean;
    for (BeanPostProcessor processor : getBeanPostProcessors()) {
        //回调处理，我们来看看Spring内置的BeanPostProcessor有几个
        Object current = processor.postProcessAfterInitialization(result, beanName);
        if (current == null) {
            return result;
        }
        result = current;
    }
    return result;
}

我们可以看到，有7个内置的后处理器，代理是在AnnotationAwareAspectJAutoProxyCreator处理器中处理，不过是由父类实现（AbstractAutoProxyCreator），关于代理对象的创建，后续再单独讲解

至此，Bean的初始化就讲解完毕了，接下来我们进行总结

总结

这块来说相对比较简单，初始化时都做了哪些事？

1. 调用Aware方法进行设置值
2. 初始化之前回调BeanPostProcessor
3. 初始化方法
   1. 如果实现了InitializingBean接口，那么会进行回调afterPropertiesSet方法
   2. 通过反射调用自定义初始化方法（init-method属性）
4. 初始化之后回调BeanPostProcessor（没有循环依赖情况下，代理对象在此生成）