从RedisUtil redisUtil = (RedisUtil)app.getBean("redisUtil");说开来2

本文要分析的方法：
1.getSingleton(beanName)从单例缓存中取值
2.getObjectForBeanInstance(sharedInstance, name, beanName, null)获取一个普通的bean或FactoryBean
3.isPrototypeCurrentlyInCreation(beanName)判断是否正在创建beanName的实例，是则报错
4.getParentBeanFactory()检查BeanFactory中是否已经有了bean，但此时的parentBeanFactory 应该是null
5.markBeanAsCreated(beanName)判断是否只是类型检查，如果不是则把beanName放入标识为已创建bean的set集合中
6.getMergedLocalBeanDefinition(beanName)获取bean定义
7.checkMergedBeanDefinition检查bean定义是否是抽象类，是则报错
8.getDependsOn取出bean的依赖，如@autowired修饰的成员变量
9.isDependent(beanName, dependsOnBean)判断是否多次依赖
10.registerDependentBean(dependsOnBean, beanName)把依赖bean放入dependentBeanMap，dependenciesForBeanMap中
11.getBean(dependsOnBean)获取依赖的bean实例
1.getSingleton(beanName)从单例缓存中取值

protected Object getSingleton(String beanName, boolean allowEarlyReference) {
//从singletonObjects缓存中取
		Object singletonObject = this.singletonObjects.get(beanName);
		//没取到的话，判断singletonsCurrentlyInCreation是否有beanName
		if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
			synchronized (this.singletonObjects) {
			//从earlySingletonObjects缓存中取
				singletonObject = this.earlySingletonObjects.get(beanName);
				//没取到，判断allowEarlyReference的值
				if (singletonObject == null && allowEarlyReference) {
				//从singletonFactories中取
					ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
					//取到了把singletonObject放入earlySingletonObjects并从singletonFactories移除
					if (singletonFactory != null) {
						singletonObject = singletonFactory.getObject();
						this.earlySingletonObjects.put(beanName, singletonObject);
						this.singletonFactories.remove(beanName);
					}
				}
			}
		}
		return (singletonObject != NULL_OBJECT ? singletonObject : null);
	}

此方法完成功能：
1.从singletonObjects缓存中取
2.没取到的话，判断singletonsCurrentlyInCreation是否有beanName
3.从earlySingletonObjects缓存中取
4.没取到，判断allowEarlyReference的值
5.从singletonFactories中取
6.取到了把singletonObject放入earlySingletonObjects并从singletonFactories移除
singletonObjects作用：储存已创建的单例bean，但不包括非懒加载bean和factorybean
earlySingletonObjects作用：储存非懒加载bean和factorybean
singletonFactories作用储存factoryBean
2.getObjectForBeanInstance(sharedInstance, name, beanName, null)获取一个普通的bean或FactoryBean

protected Object getObjectForBeanInstance(
			Object beanInstance, String name, String beanName, RootBeanDefinition mbd) {

		// Don't let calling code try to dereference the factory if the bean isn't a factory.
		//是一个废弃的Factory并且不是FactoryBean的子类则报错
		if (BeanFactoryUtils.isFactoryDereference(name) && !(beanInstance instanceof FactoryBean)) {
			throw new BeanIsNotAFactoryException(transformedBeanName(name), beanInstance.getClass());
		}

		// Now we have the bean instance, which may be a normal bean or a FactoryBean.
		// If it's a FactoryBean, we use it to create a bean instance, unless the
		// caller actually wants a reference to the factory.
		是一个废弃的Factory或不是FactoryBean的子类则报错，直接返回实例
		if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {
			return beanInstance;
		}

		Object object = null;
		//如果bean定义为null，则从factoryBeanObjectCache取缓存
		if (mbd == null) {
			object = getCachedObjectForFactoryBean(beanName);
		}
		//如果没有，通过 getObjectFromFactoryBean(factory, beanName, !synthetic)方法取。
		if (object == null) {
			// Return bean instance from factory.
			FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
			// Caches object obtained from FactoryBean if it is a singleton.
			if (mbd == null && containsBeanDefinition(beanName)) {
				mbd = getMergedLocalBeanDefinition(beanName);
			}
			boolean synthetic = (mbd != null && mbd.isSynthetic());
			object = getObjectFromFactoryBean(factory, beanName, !synthetic);
		}
		return object;
	}

此方法完成的功能：
1.是一个废弃的Factory并且不是FactoryBean的子类则报错
2.如果bean定义为null，则从factoryBeanObjectCache取缓存
3.如果没有，通过 getObjectFromFactoryBean(factory, beanName, !synthetic)方法取。
2.1getObjectFromFactoryBean(factory, beanName, !synthetic)方法：

protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) {
	//factory是单例并且singletonObjects含有beanName的key
		if (factory.isSingleton() && containsSingleton(beanName)) {
			synchronized (getSingletonMutex()) {
			//从factoryBeanObjectCache中获取beanName的缓存
				Object object = this.factoryBeanObjectCache.get(beanName);
				//没取到，通过doGetObjectFromFactoryBean获取
				if (object == null) {
					object = doGetObjectFromFactoryBean(factory, beanName);
					// Only post-process and store if not put there already during getObject() call above
					// (e.g. because of circular reference processing triggered by custom getBean calls)
					//从factoryBeanObjectCache取值，取到直接返回取到值
					Object alreadyThere = this.factoryBeanObjectCache.get(beanName);
					if (alreadyThere != null) {
						object = alreadyThere;
					}
					else {
					//没取到且object 且shouldPostProcess为true，执行postProcessObjectFromFactoryBean方法
					//获取，并放入factoryBeanObjectCache缓存中
						if (object != null && shouldPostProcess) {
							try {
								object = postProcessObjectFromFactoryBean(object, beanName);
							}
							catch (Throwable ex) {
								throw new BeanCreationException(beanName,
										"Post-processing of FactoryBean's singleton object failed", ex);
							}
						}
						this.factoryBeanObjectCache.put(beanName, (object != null ? object : NULL_OBJECT));
					}
				}
				return (object != NULL_OBJECT ? object : null);
			}
		}
		else {
			Object object = doGetObjectFromFactoryBean(factory, beanName);
			if (object != null && shouldPostProcess) {
				try {
					object = postProcessObjectFromFactoryBean(object, beanName);
				}
				catch (Throwable ex) {
					throw new BeanCreationException(beanName, "Post-processing of FactoryBean's object failed", ex);
				}
			}
			return object;
		}
	}

此方法完成的功能：
1.factory是单例并且singletonObjects含有beanName的key
2.从factoryBeanObjectCache中获取beanName的缓存
3.没取到，通过doGetObjectFromFactoryBean方法获取
4.从factoryBeanObjectCache取值，取到直接返回取到值
5.没取到且object 且shouldPostProcess为true，执行postProcessObjectFromFactoryBean方法，获取，并放入factoryBeanObjectCache缓存中
2.1.1没取到，通过doGetObjectFromFactoryBean方法获取

private Object doGetObjectFromFactoryBean(final FactoryBean<?> factory, final String beanName)
			throws BeanCreationException {

		Object object;
		try {
			if (System.getSecurityManager() != null) {
				AccessControlContext acc = getAccessControlContext();
				try {
					object = AccessController.doPrivileged(new PrivilegedExceptionAction<Object>() {
						@Override
						public Object run() throws Exception {
								return factory.getObject();
							}
						}, acc);
				}
				catch (PrivilegedActionException pae) {
					throw pae.getException();
				}
			}
			else {
				object = factory.getObject();
			}
		}
		catch (FactoryBeanNotInitializedException ex) {
			throw new BeanCurrentlyInCreationException(beanName, ex.toString());
		}
		catch (Throwable ex) {
			throw new BeanCreationException(beanName, "FactoryBean threw exception on object creation", ex);
		}

		// Do not accept a null value for a FactoryBean that's not fully
		// initialized yet: Many FactoryBeans just return null then.
		if (object == null && isSingletonCurrentlyInCreation(beanName)) {
			throw new BeanCurrentlyInCreationException(
					beanName, "FactoryBean which is currently in creation returned null from getObject");
		}
		return object;
	}

主要是执行factory.getObject();方法。
2.1.5.没取到且object 且shouldPostProcess为true，执行postProcessObjectFromFactoryBean方法，获取，并放入factoryBeanObjectCache缓存中

protected Object postProcessObjectFromFactoryBean(Object object, String beanName) {
		return applyBeanPostProcessorsAfterInitialization(object, beanName);
	}

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;
	}

这里主要执行了了bean的后处理器中postProcessAfterInitialization方法。BeanPostProcessor 是在之前文章中refresh（）方法放进去的。
此时getBean方法的前俩步就分析完了。总结一下：
先从单例缓存中取实例，取到之后判断是普通bean还是factoryBean，如果是普通则直接返回实例，如果是factoryBean则调用factory.getObeject方法返回实例。
接下来继续分析没有创建实例或不是单例的情况。
3.isPrototypeCurrentlyInCreation(beanName)判断是否正在创建beanName的实例，是则报错

protected boolean isPrototypeCurrentlyInCreation(String beanName) {
		Object curVal = this.prototypesCurrentlyInCreation.get();
		return (curVal != null &&
				(curVal.equals(beanName) || (curVal instanceof Set && ((Set<?>) curVal).contains(beanName))));
	}

此方法判断了类型为prototype的bean是否正在创建，在创建则报错
4.getParentBeanFactory()检查BeanFactory中是否已经有了bean，但此时的parentBeanFactory 应该是null
5.markBeanAsCreated(beanName)判断是否只是类型检查，如果不是则把beanName放入标识为已创建bean的set集合中

protected void markBeanAsCreated(String beanName) {
		if (!this.alreadyCreated.contains(beanName)) {
			this.alreadyCreated.add(beanName);
		}
	}

6.getMergedLocalBeanDefinition(beanName)获取bean定义

protected RootBeanDefinition getMergedLocalBeanDefinition(String beanName) throws BeansException {
		// Quick check on the concurrent map first, with minimal locking.
		RootBeanDefinition mbd = this.mergedBeanDefinitions.get(beanName);
		if (mbd != null) {
			return mbd;
		}
		return getMergedBeanDefinition(beanName, getBeanDefinition(beanName));
	}

先从mergedBeanDefinitions缓存里面取，没有则到getMergedBeanDefinition方法里取。

protected RootBeanDefinition getMergedBeanDefinition(
			String beanName, BeanDefinition bd, BeanDefinition containingBd)
			throws BeanDefinitionStoreException {

		synchronized (this.mergedBeanDefinitions) {
			RootBeanDefinition mbd = null;

			// Check with full lock now in order to enforce the same merged instance.
			//从mergedBeanDefinitions缓存中取
			if (containingBd == null) {
				mbd = this.mergedBeanDefinitions.get(beanName);
			}
			//没取到，如果没有父bean，那么此bean为rootbean
			if (mbd == null) {
				if (bd.getParentName() == null) {
					// Use copy of given root bean definition.
					if (bd instanceof RootBeanDefinition) {
						mbd = ((RootBeanDefinition) bd).cloneBeanDefinition();
					}
					else {
						mbd = new RootBeanDefinition(bd);
					}
				}
				//没取到且有父bean，创建父BeanDefinition，并做好重写的关联关系
				else {
					// Child bean definition: needs to be merged with parent.
					BeanDefinition pbd;
					try {
						String parentBeanName = transformedBeanName(bd.getParentName());
						if (!beanName.equals(parentBeanName)) {
							pbd = getMergedBeanDefinition(parentBeanName);
						}
						else {
							if (getParentBeanFactory() instanceof ConfigurableBeanFactory) {
								pbd = ((ConfigurableBeanFactory) getParentBeanFactory()).getMergedBeanDefinition(parentBeanName);
							}
							else {
								throw new NoSuchBeanDefinitionException(bd.getParentName(),
										"Parent name '" + bd.getParentName() + "' is equal to bean name '" + beanName +
										"': cannot be resolved without an AbstractBeanFactory parent");
							}
						}
					}
					catch (NoSuchBeanDefinitionException ex) {
						throw new BeanDefinitionStoreException(bd.getResourceDescription(), beanName,
								"Could not resolve parent bean definition '" + bd.getParentName() + "'", ex);
					}
					// Deep copy with overridden values.
					mbd = new RootBeanDefinition(pbd);
					mbd.overrideFrom(bd);
				}

				// Set default singleton scope, if not configured before.
				//没配置scop，默认是单例
				if (!StringUtils.hasLength(mbd.getScope())) {
					mbd.setScope(RootBeanDefinition.SCOPE_SINGLETON);
				}

				// A bean contained in a non-singleton bean cannot be a singleton itself.
				// Let's correct this on the fly here, since this might be the result of
				// parent-child merging for the outer bean, in which case the original inner bean
				// definition will not have inherited the merged outer bean's singleton status.
				此时containingBd是null，
				if (containingBd != null && !containingBd.isSingleton() && mbd.isSingleton()) {
					mbd.setScope(containingBd.getScope());
				}

				// Only cache the merged bean definition if we're already about to create an
				// instance of the bean, or at least have already created an instance before.
				//缓存合并之后的实例
				if (containingBd == null && isCacheBeanMetadata() && isBeanEligibleForMetadataCaching(beanName)) {
					this.mergedBeanDefinitions.put(beanName, mbd);
				}
			}

			return mbd;
		}
	}

此方法完成的功能：
1.从mergedBeanDefinitions缓存中取
2.没取到，如果没有父bean，那么此bean为rootbean
3.没取到且有父bean，创建父BeanDefinition，并把子beanDefinition中的个属性通过mbd.overrideFrom(bd);方法赋到父BeanDefinition中。
4.没配置scop，默认是单例
5.缓存合并之后的实例
7.checkMergedBeanDefinition检查bean定义是否是抽象类，是则报错

8.getDependsOn取出bean的依赖，如@autowired修饰的成员变量

9.isDependent(beanName, dependsOnBean)判断是否多次依赖和循环依赖

private boolean isDependent(String beanName, String dependentBeanName, Set<String> alreadySeen) {
		String canonicalName = canonicalName(beanName);
		if (alreadySeen != null && alreadySeen.contains(beanName)) {
			return false;
		}
		Set<String> dependentBeans = this.dependentBeanMap.get(canonicalName);
		if (dependentBeans == null) {
			return false;
		}
		if (dependentBeans.contains(dependentBeanName)) {
			return true;
		}
		for (String transitiveDependency : dependentBeans) {
			if (alreadySeen == null) {
				alreadySeen = new HashSet<String>();
			}
			alreadySeen.add(beanName);
			if (isDependent(transitiveDependency, dependentBeanName, alreadySeen)) {
				return true;
			}
		}
		return false;
	}

dependentBeanMap中的数据在下一步放入。
10.registerDependentBean(dependsOnBean, beanName)把依赖bean放入
dependentBeanMap，dependenciesForBeanMap中

public void registerDependentBean(String beanName, String dependentBeanName) {
		// A quick check for an existing entry upfront, avoiding synchronization...
		String canonicalName = canonicalName(beanName);
		Set<String> dependentBeans = this.dependentBeanMap.get(canonicalName);
		if (dependentBeans != null && dependentBeans.contains(dependentBeanName)) {
			return;
		}

		// No entry yet -> fully synchronized manipulation of the dependentBeans Set
		synchronized (this.dependentBeanMap) {
			dependentBeans = this.dependentBeanMap.get(canonicalName);
			if (dependentBeans == null) {
				dependentBeans = new LinkedHashSet<String>(8);
				this.dependentBeanMap.put(canonicalName, dependentBeans);
			}
			dependentBeans.add(dependentBeanName);
		}
		synchronized (this.dependenciesForBeanMap) {
			Set<String> dependenciesForBean = this.dependenciesForBeanMap.get(dependentBeanName);
			if (dependenciesForBean == null) {
				dependenciesForBean = new LinkedHashSet<String>(8);
				this.dependenciesForBeanMap.put(dependentBeanName, dependenciesForBean);
			}
			dependenciesForBean.add(canonicalName);
		}
	}

dependentBeanMap作用：用于解决循环依赖问题。
dependenciesForBeanMap作用：通过此map可以知道user这个bean被多少个bean依赖了
11.getBean(dependsOnBean)获取依赖的bean实例
这是一个回调方法。我们就是从这个方法开始分析的。所以此处不分析了