spring 源码学习笔记（二）—— spring ioc 之依赖注入

欢迎访问我的个人博客休息的风

上一篇spring系列博客spring 源码学习笔记（一）—— spring ioc 之加载XML转换为BeanDefinition讲到spring如何将xml文件转换为内存的数据结构。本篇博客将继续上篇博客，继续分析如何利用beanDefinition创建bean对象，并且对对象进行依赖注入。

下图是整个创建bean并依赖注入的过程：（看不清可右击在新页签进行查看）



AbstractAutowireCapableBeanFactory为创建bean的核心类，很多操作都在这个类里实现；我们主要关注这个类的方法。createBean方法作为入口

protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {

if (logger.isDebugEnabled()) {
logger.debug("Creating instance of bean '" + beanName + "'");
}
//这里的RootBeanDefinition就是之前从xml解析转换的内存数据结构
RootBeanDefinition mbdToUse = mbd;

//省略代码。。。。
try {
// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
//这里会去调用BeanPostProcessorsBeforeInstantiation，
// 包括用于aop的AnnotationAwareAspectJAutoProxyCreator处理器
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
if (bean != null) {
return bean;
}
}
//省略代码。。。。
try {
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
if (logger.isDebugEnabled()) {
logger.debug("Finished creating instance of bean '" + beanName + "'");
}
return beanInstance;
}

doCreateBean方法用于真正创建bean实例

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
throws BeanCreationException {

// Instantiate the bean.
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
//创建bean包装类实例
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
final Object bean = instanceWrapper.getWrappedInstance();
Class<?> beanType = instanceWrapper.getWrappedClass();
if (beanType != NullBean.class) {
mbd.resolvedTargetType = beanType;
}

//省略代码。。。

// Initialize the bean instance.
Object exposedObject = bean;
try {
//填充RootBeanDefinition的字段
populateBean(beanName, mbd, instanceWrapper);
//初始化bean
exposedObject = initializeBean(beanName, exposedObject, mbd);
}

createBeanInstance方法创建的是bean的包装类实例BeanWrapperImpl。后面populateBean方法中，需要通过这个包装类进行依赖注入。

protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
PropertyValues pvs = mbd.getPropertyValues();
//省略代码。。。。

if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
//这里进行实例的后置处理，aop的AnnotationAwareAspectJAutoProxyCreator也在这里调用
if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
continueWithPropertyPopulation = false;
break;
}
}
}
}

if (!continueWithPropertyPopulation) {
return;
}

if (mbd.getResolvedAutowireMode() == RootBeanDefinition.
c2af
AUTOWIRE_BY_NAME ||
mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
MutablePropertyValues newPvs = new MutablePropertyValues(pvs);

// Add property values based on autowire by name if applicable.
//通过名称自动装配
if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {
autowireByName(beanName, mbd, bw, newPvs);
}

// Add property values based on autowire by type if applicable.
//通过类自动装配
if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
autowireByType(beanName, mbd, bw, newPvs);
}

pvs = newPvs;
}

//省略代码。。。。

//设置属性值
applyPropertyValues(beanName, mbd, bw, pvs);
}

这里只是在beanDefinition层面上注入,调用initializeBean方法开始对象的初始化。

protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
invokeAwareMethods(beanName, bean);
return null;
}, getAccessControlContext());
}
else {
//实现Aware接口的设置
invokeAwareMethods(beanName, bean);
}

Object wrappedBean = bean;
if (mbd == null || !mbd.isSynthetic()) {
//初始化前置处理器
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
}

try {
//调用afterPropertiesSet后再调用类的构造函数
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()) {
//初始化后置处理器
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}

return wrappedBean;
}

到此，基本的依赖注入过程已成形，这里总结一下整个过程：调用实例化前置处理器->创建包装类，对beanDefinition进行属性填充->根据beanDefinition进行初始化->初始化前后分别调用各自的处理器，初始时调用afterPropertiesSet->返回单例注册到DefaultListableBeanFactory中