spring源码分析-bean的加载初探

我已经参透了符文，你输了 ！ — 瑞兹

网上有许多对bean加载的讲解文章，条例非常清晰，看完后会不想再自己写，就像我看了张爱玲的小说，不再想写小说，因为我觉得我写人物的心理永远也不会写的比她真实，深刻。就像高晓松说，他看了《百年孤独》再也不会想写小说一样。可是别人写的再好，毕竟是别人的，我还是要写出来。

本文抄袭了博客
由于我脑子里面已经有了一些认识，所以有些细节没有补全，若又不解，可取翻阅上面这边博客

在实现bean的加载前，spring为加载BeanDefinition做了大量的工作，但本文只讨论spring完成BeanDefinition的读取后的bean加载过程。

概述

再深入细节前，有必要先对整体的流程有个了解，也许你看完一遍后会不知所云，可是等你了解了细节，再回头看这张图会有不畏浮云遮望眼的感觉。

故事开始

故事从AbstractBeanFacotry的getBean开始，以下是它的继承结构

至于，这些接口定义的行为，在上一篇DefaultListableBeanFactory已经做了介绍。

如下是doGetBean方法，该方法显示了整个bean加载的骨架，这个方法值得你耐性看几遍

      //先对name进行转换，因为name可能是别名或者是FactoryBean的名字
       final String beanName = transformedBeanName(name);
		Object bean;
		
		//首先尝试从三级缓存中逐级查找
		// Eagerly check singleton cache for manually registered singletons.
		Object sharedInstance = getSingleton(beanName);
		if (sharedInstance != null && args == null) {
			if (logger.isDebugEnabled()) {
				if (isSingletonCurrentlyInCreation(beanName)) {
					logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +
							"' that is not fully initialized yet - a consequence of a circular reference");
				}
				else {
					logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
				}
			}
			//由于可能是从singletonFactories这一级缓存中取出一个的factory,所以要进一步执行其getObject方法，并执行
			bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
		}

		else {
		    //若是scope为prototype时候，是不能解决循环依赖的
			// Fail if we're already creating this bean instance:
			// We're assumably within a circular reference.
			if (isPrototypeCurrentlyInCreation(beanName)) {
				throw new BeanCurrentlyInCreationException(beanName);
			}
			//尝试去父工厂获取
			// Check if bean definition exists in this factory.
			BeanFactory parentBeanFactory = getParentBeanFactory();
			if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
				// Not found -> check parent.
				String nameToLookup = originalBeanName(name);
				if (args != null) {
					// Delegation to parent with explicit args.
					return (T) parentBeanFactory.getBean(nameToLookup, args);
				}
				else {
					// No args -> delegate to standard getBean method.
					return parentBeanFactory.getBean(nameToLookup, requiredType);
				}
			}

			if (!typeCheckOnly) {
				markBeanAsCreated(beanName);
			}

			try {
			    //由于beanName对应的BeanDefinition默认实现是GenericBeanDefinition，需要把它转化成RootBeanDefinition
				final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
				checkMergedBeanDefinition(mbd, beanName, args);

				//保证当前bean依赖的bean先被初始化
				// Guarantee initialization of beans that the current bean depends on.
				String[] dependsOn = mbd.getDependsOn();
				if (dependsOn != null) {
					for (String dep : dependsOn) {
						if (isDependent(beanName, dep)) {
							throw new BeanCreationException(mbd.getResourceDescription(), beanName,
									"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
						}
						registerDependentBean(dep, beanName);
						try {
							getBean(dep);
						}
						catch (NoSuchBeanDefinitionException ex) {
							throw new BeanCreationException(mbd.getResourceDescription(), beanName,
									"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
						}
					}
				}

				//正式开始一个bean的创建
				// Create bean instance.
				if (mbd.isSingleton()) {
					sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
						@Override
						public Object getObject() throws BeansException {
							try {
								return createBean(beanName, mbd, args);
							}
							catch (BeansException ex) {
								// Explicitly remove instance from singleton cache: It might have been put there
								// eagerly by the creation process, to allow for circular reference resolution.
								// Also remove any beans that received a temporary reference to the bean.
								destroySingleton(beanName);
								throw ex;
							}
						}
					});
					bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
				}
				//若scope为prototype的构造过程
				else if (mbd.isPrototype()) {
					// It's a prototype -> create a new instance.
					Object prototypeInstance = null;
					try {
						beforePrototypeCreation(beanName);
						prototypeInstance = createBean(beanName, mbd, args);
					}
					finally {
						afterPrototypeCreation(beanName);
					}
					bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
				}
				//若scope为singleton的创建过程
				else {
					String scopeName = mbd.getScope();
					final Scope scope = this.scopes.get(scopeName);
					if (scope == null) {
						throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
					}
					try {
						Object scopedInstance = scope.get(beanName, new ObjectFactory<Object>() {
							@Override
							public Object getObject() throws BeansException {
								beforePrototypeCreation(beanName);
								try {
									return createBean(beanName, mbd, args);
								}
								finally {
									afterPrototypeCreation(beanName);
								}
							}
						});
						bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
					}
					catch (IllegalStateException ex) {
						throw new BeanCreationException(beanName,
								"Scope '" + scopeName + "' is not active for the current thread; consider " +
								"defining a scoped proxy for this bean if you intend to refer to it from a singleton",
								ex);
					}
				}
			}
			catch (BeansException ex) {
				cleanupAfterBeanCreationFailure(beanName);
				throw ex;
			}

读完上面的代码，我们要做的事就是，再去回到本文章的头部，看一看那张图，在脑中留下整个流程的印象。