spring源码阅读（1）- ioc依赖注入之bean加载

还是先看下DefaultListableBeanFactory的类结构图

 我们从User user = (User) beanFactory.getBean("user");入手进入bean的加载管理流程。

这里还是坚持走主线的流程，去掉无关的枝叶，尽量让业务变得简单。

开始进入代码，首先我们跟到AbstractBeanFactory这个类下面的doGetBean

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

		// 缓存中获取到bean结束
		Object sharedInstance = getSingleton(beanName);
		if (sharedInstance != null && args == null) {
			if (logger.isDebugEnabled()) {
			bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
		}

		else {

				// 加载依赖
				String[] dependsOn = mbd.getDependsOn();
				if (dependsOn != null) {
					for (String dependsOnBean : dependsOn) {
						getBean(dependsOnBean);
						registerDependentBean(dependsOnBean, beanName);
					}
				}

				// 创建bean实例，这里是我们需要深入剖析的关键，注意到这里有个回调
				if (mbd.isSingleton()) {
					sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
						public Object getObject() throws BeansException {
							return createBean(beanName, mbd, args);
                    }
				}

				else if (mbd.isPrototype()) {
					//创建原型实例，这个scope的实例是每次使用每次创建，其实该代码前后有个
                    //threadLocal变量，该变量其实是用来控制多线程对象实例化安全的
                    //对这个比较感兴趣的可以关注一下前后代码，我们还是关注大流程
					prototypeInstance = createBean(beanName, mbd, args);
				}

				else {
				}
		}

		return (T) bean;
	}

从摘除枝叶的代码可以看出核心流程了，spring原生的scope有singleton和prototype两种，singleton是创建一次，以后应用每次获取都是相同的对象，而prototype是每次getBean都创建一个对象。

我们根据上面的特性想一想，singleton肯定是实例化以后由spring容器管理起来了，以后的每次getBean都是获取相同的对象，管理起来肯定也就是缓存起来了，而prototype实例化就spring容器就不管理了，由此弄懂了getSingletion也就了解了prototype的实例化了。

我们来看下getSingleton的两个参数一个是beanName，一个是一个ObjectFactory对象的匿名类对象。

我们进入DefaultSingleTonBeanRegistry中的getSingleton

public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
		
		synchronized (this.singletonObjects) {
			Object singletonObject = this.singletonObjects.get(beanName);
			if (singletonObject == null) {
				
                //这里将正在加载的bean加入到了一个concurrencyHashMap中
				beforeSingletonCreation(beanName);
				//回调FactoryBean的getObject
				singletonObject = singletonFactory.getObject();
				//从map中移除
				afterSingletonCreation(beanName);
				//这里就是比getPrototype多的部分，我们想想估计这里面实现了内存管理bean
				addSingleton(beanName, singletonObject);
			}
			return (singletonObject != NULL_OBJECT ? singletonObject : null);
		}
	}

这里也是首先从缓存中获取实例，如果缓存中没有则需要创建，而创建回调了传入的ObjectFactory的getObject,创建成功获取到singletonObject，对于singleton单例的bean，我们还有一个非常重要的操作也就是缓存管理，这个部分在addSingleton中实现了。

我们先来看看获取到bean对于缓存的管理吧

protected void addSingleton(String beanName, Object singletonObject) {
		synchronized (this.singletonObjects) {
			this.singletonObjects.put(beanName, (singletonObject != null ? singletonObject : NULL_OBJECT));
			this.singletonFactories.remove(beanName);
			this.earlySingletonObjects.remove(beanName);
			this.registeredSingletons.add(beanName);
		}
	}
//单例对象，beanName和bean实例的映射关系
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<String, Object>(64);
//beanName和创建bean的工厂的映射关系
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<String, ObjectFactory<?>>(16);
//存在这里的对象还是处于创建中，可以获取到，用于解决循环依赖
private final Map<String, Object> earlySingletonObjects = new HashMap<String, Object>(16);
//保存所有已经注册bean，name的set集合
	private final Set<String> registeredSingletons = new LinkedHashSet<String>(64);

这里也就是我们分析的最终目的地了，创建的bean被spring容器管理起来了。

不过我们还不能结束，还有不少细节需要我们关心的，比如如何实例化bean的，我们想能在运行期动态实例化对象的我们第一想到的也就是反射了，我们来找找这方面的点，看看spring在创建实例的问题上做了哪些工作，要知道我们能对bean做能多工作呢

我们来看看getObject回调部分的getObject:createBean

protected abstract Object createBean(String beanName, RootBeanDefinition mbd, Object[] args)
			throws BeanCreationException;

哎呀，这里我们找到了一个抽象函数，实现留给了子类。具体的实现留给了AbstractAutowireCapableBeanFactory

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

			// 这里是实例化后置处理器
		Object bean = resolveBeforeInstantiation(beanName, mbd);
		if (bean != null) 
			return bean;

		Object beanInstance = doCreateBean(beanName, mbd, args);
		
		return beanInstance;
	}

这里提到了一个分支功能点，实例化后置处理器的处理，我们离开主线看看这部分

protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
		Object bean = null;
		if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
			// Make sure bean class is actually resolved at this point.
			if (mbd.hasBeanClass() && !mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
				bean = applyBeanPostProcessorsBeforeInstantiation(mbd.getBeanClass(), beanName);
				if (bean != null) {
					bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
				}
			}
			mbd.beforeInstantiationResolved = (bean != null);
		}
		return bean;
	}

对于实现了实例化后置处理器的工厂需要执行，applyBeanPostProcessorsBeforeInstantiation（您应该对后置处理器的功能了解吧，就当你了解了啊^^），这个函数返回bean不为空的化就执行applyBeanPostProcessorsAfterInitialization，在看看执行这个函数之后的一段代码如果返回不为空的化就直接返回bean的短路操作，也就是意味着后续不处理了，要知道到目前位置我们还没有处理类的实例化。我们想想这个留给我们干啥用，等我分析完aop部分这个功能也就了解了。

我们继续来到主线AbstractAutowireCapableBeanFactory的doCreateBean

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) {
		// Instantiate the bean.
		BeanWrapper instanceWrapper = null;
		//实例化bean并返回一个bean的包装类
		instanceWrapper = createBeanInstance(beanName, mbd, args);
        //从包装类中获取bean实例
        final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);
		// bean合并后处理，autowired在这里预解析，这个点我们不讨论
		synchronized (mbd.postProcessingLock) {
			if (!mbd.postProcessed) {
				applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
				mbd.postProcessed = true;
			}
		}

		// Initialize the bean instance.
		Object exposedObject = bean;
		//注入属性
		populateBean(beanName, mbd, instanceWrapper);
		if (exposedObject != null) {
			exposedObject = initializeBean(beanName, exposedObject, mbd);
		}
		//注册disposableBean，如果配置了destroy-method
		registerDisposableBeanIfNecessary(beanName, bean, mbd);
		
		return exposedObject;
	}

这里基本上就是类似下面这段代码

Object object = new Object();
object.setXXX()
object.init-method();

嗯，就是这么简单，实例化一个类，注入类中的属性值，执行一些需要需要执行的方法，然后注册一个销毁的时候需要执行的方法，返回对象。

首先我们来看看实例化对象的代码吧，我们来看看是不是如我们之前预期的那样是一段反射的操作。

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) {
		// 解析出类的class
		Class<?> beanClass = resolveBeanClass(mbd, beanName);

		// 实例化bean
		return instantiateBean(beanName, mbd);
	}

protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd) {
		Object beanInstance;
		//根据不通的实例化策略实例化对象，
		beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);
			
		BeanWrapper bw = new BeanWrapperImpl(beanInstance);
		initBeanWrapper(bw);
		return bw;
		
}

这里做了实例化操作和包装对象

我们看看实例化部分，这有一个getInstantiationStrategy（），这里获取到的是CglibSubclassingInstantiationStrategy，我们再看看instantiate部分

public Object instantiate(RootBeanDefinition beanDefinition, String beanName, BeanFactory owner) {
		// 对于有方法需要覆盖的或替换的需要用cglib动态代理		
        //没有直接反射
		if (beanDefinition.getMethodOverrides().isEmpty()) {
			Constructor<?> constructorToUse;
			synchronized (beanDefinition.constructorArgumentLock) {
				constructorToUse = (Constructor<?>) beanDefinition.resolvedConstructorOrFactoryMethod;
				if (constructorToUse == null) {
					final Class<?> clazz = beanDefinition.getBeanClass();
				
					return clazz.getDeclaredConstructor((Class[]) null);
						
					constructorToUse =	clazz.getDeclaredConstructor((Class[]) null);
                    //上面几步就是为了获取一个constructor构造器
						//通过构造器实例化对象
					beanDefinition.resolvedConstructorOrFactoryMethod = constructorToUse;
					
				
			}
			return BeanUtils.instantiateClass(constructorToUse);
		}
		else {
			// Must generate CGLIB subclass.
			return instantiateWithMethodInjection(beanDefinition, beanName, owner);
		}

public static <T> T instantiateClass(Constructor<T> ctor, Object... args) throws BeanInstantiationException {
			ReflectionUtils.makeAccessible(ctor);
			return ctor.newInstance(args);
		
	}

首先判断实例化的方式：分为反射实例化和cglib代理实例化，我们暂是不管代理实例化

针对反射实例化我们先获取了一个构造器这里我们只是剖析了无参构造器，带参的构造器还是比较复杂的，然后通过构造器在instantiateClass中执行反射newInstance实例化对象

到这里对象的实例已经创建完毕了。

我们继续doCreateBean创建完实例接下来我们到了populateBean(beanName, mbd, instanceWrapper);属性注入部分，我们来剖析这部分代码

protected void populateBean(String beanName, RootBeanDefinition mbd, BeanWrapper bw) {
		PropertyValues pvs = mbd.getPropertyValues();

		
		//这里执行了实例化后置处理器的after方法，
        //遍历所有的后置处理器，如果postProcessAfterInstantiation返回false，属性注入就不执行了
		boolean continueWithPropertyPopulation = true;
		if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
			for (BeanPostProcessor bp : getBeanPostProcessors()) {
				if (bp instanceof InstantiationAwareBeanPostProcessor) {
					InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
                    //返回失败，属性注入结束
					if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
						continueWithPropertyPopulation = false;
						break;
					}
				}
			}
		}
        //短路
		if (!continueWithPropertyPopulation) {
			return;
		}

        //根据注入类型，查找依赖的bean
		if (mbd.getResolvedAutowireMode() == RootBeanDefinition.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;
		}

        //应用postProcessPropertyValues方法
		boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
		boolean needsDepCheck = (mbd.getDependencyCheck() != RootBeanDefinition.DEPENDENCY_CHECK_NONE);

		if (hasInstAwareBpps || needsDepCheck) {
			PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
			if (hasInstAwareBpps) {
				for (BeanPostProcessor bp : getBeanPostProcessors()) {
					if (bp instanceof InstantiationAwareBeanPostProcessor) {
						InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
						pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
					}
				}
			}
		}
        //属性注入
		applyPropertyValues(beanName, mbd, bw, pvs);
	}

属性注入的流程：

1、执行实例化后置处理器的postProcessAfterInstantiation

2、根据注入类型提取bean，存入propertyValues

3、应用postProcessPropertyValues，在属性注入前对对象的最后一次处理机会

4、注入属性

---

离开会主线，我们先来看看bean依赖的问题吧

这里的bean依赖有2个类别分别是：

1. AUTOWIRE_BY_TYPE、
2. AUTOWIRE_BY_NAME

两个类别的目的一样，但是实现确实差别较大，我们挑一个简单的看吧，另一个也就理解了，如果确实对这方面实现感兴趣可研究

AUTOWIRE_BY_NAME

protected void autowireByName(
			String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {

        //查找需要依赖的属性
		String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
		for (String propertyName : propertyNames) {
            //根据依赖的属性名称执行getBean，这里也就是一个递归了
			Object bean = getBean(propertyName);
            //将获取的属性加入
			pvs.add(propertyName, bean);
			registerDependentBean(propertyName, beanName);
				
		}
	}

这里就是根据beanName从容器中获取bean，这里是一个递归了，获取到的属性加入pvs。AUTOWI're_BYNAME就是这么简单。

然后就是

if (pvs == null || pvs.isEmpty()) {
			return;
		}

		MutablePropertyValues mpvs = null;
		List<PropertyValue> original;

			original = mpvs.getPropertyValueList();

		TypeConverter converter = getCustomTypeConverter();
		if (converter == null) {
			converter = bw;
		}

		BeanDefinitionValueResolver valueResolver = new BeanDefinitionValueResolver(this, beanName, mbd, converter);

		// Create a deep copy, resolving any references for values.
		List<PropertyValue> deepCopy = new ArrayList<PropertyValue>(original.size());
		boolean resolveNecessary = false;
		for (PropertyValue pv : original) {
			if (pv.isConverted()) {
				deepCopy.add(pv);
			}
			else {
				String propertyName = pv.getName();
				Object originalValue = pv.getValue();
				Object resolvedValue = valueResolver.resolveValueIfNecessary(pv, originalValue);
				Object convertedValue = resolvedValue;
				boolean convertible = bw.isWritableProperty(propertyName) &&
						!PropertyAccessorUtils.isNestedOrIndexedProperty(propertyName);
				if (convertible) {
					convertedValue = convertForProperty(resolvedValue, propertyName, bw, converter);
				}
				// Possibly store converted value in merged bean definition,
				// in order to avoid re-conversion for every created bean instance.
				if (resolvedValue == originalValue) {
					if (convertible) {
						pv.setConvertedValue(convertedValue);
					}
					deepCopy.add(pv);
				}
				else if (convertible && originalValue instanceof TypedStringValue &&
						!((TypedStringValue) originalValue).isDynamic() &&
						!(convertedValue instanceof Collection || ObjectUtils.isArray(convertedValue))) {
					pv.setConvertedValue(convertedValue);
					deepCopy.add(pv);
				}
				else {
					resolveNecessary = true;
					deepCopy.add(new PropertyValue(pv, convertedValue));
				}
			}
		}
		if (mpvs != null && !resolveNecessary) {
			mpvs.setConverted();
		}

		// Set our (possibly massaged) deep copy.
		try {
			bw.setPropertyValues(new MutablePropertyValues(deepCopy));
		}
		catch (BeansException ex) {
			throw new BeanCreationException(
					mbd.getResourceDescription(), beanName, "Error setting property values", ex);
		}

这里实现的功能就是属性的解析与对应类型的转换了，加上最后的对象对应属性的设置。

接下来就是initializeBean了

protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {
		//调用bean实现的相关的aware接口方法
		invokeAwareMethods(beanName, bean);
		

		Object wrappedBean = bean;
		if (mbd == null || !mbd.isSynthetic()) {
            //调用后置处理器的applyBeanPostProcessorsBeforeInitialization
			wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
		}

		//这里面是通过反射调用了配置的init-method的方法
		invokeInitMethods(beanName, wrappedBean, mbd);
		

		if (mbd == null || !mbd.isSynthetic()) {
            //调用后置处理器的applyBeanPostProcessorsAfterInitialization
			wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
		}
		return wrappedBean;
	}

这个里面就比较简单了，都是bean生命周期相关的部分接口方法调用：

包括后置处理器的

bean相关的BeanNameAware、BeanFactoryAware、BeanClassLoaderAware

applyBeanPostProcessorsBeforeInitialization/applyBeanPostProcessorsAfterInitialization，

afterPropertiesSet()

反射调用init-method定义的方法

在就是注册一个销毁方法了

protected void registerDisposableBeanIfNecessary(String beanName, Object bean, RootBeanDefinition mbd) {
		AccessControlContext acc = (System.getSecurityManager() != null ? getAccessControlContext() : null);
		if (!mbd.isPrototype() && requiresDestruction(bean, mbd)) {
			if (mbd.isSingleton()) {
				//单例的注册需要销毁的bean，此方法中会处理实现DisposableBean的bean
                //并且对所有的bean使用DestructionAwareBeanPostProcessors处理
				registerDisposableBean(beanName,
						new DisposableBeanAdapter(bean, beanName, mbd, getBeanPostProcessors(), acc));
			
		}
	}

DefaultSingletonBeanRegistry.registerDisposableBean会将需要执行destory的bean加入到disposableBeans中，容器关闭是会回调这个Map中的所有销毁方法。