上一节介绍了封装bean对象的BeanDefinition接口。从前面小结对BeanFactory的介绍中，我们知道bean对象是存储在map中，通过调用getBean方法可以得到bean对象。在接口BeanFactory中定义了多个相同签名的getBean方法，如下所示：

	Object getBean(String name) throws BeansException;

	<T> T getBean(String name, Class<T> requiredType) throws BeansException;

	<T> T getBean(Class<T> requiredType) throws BeansException;

	Object getBean(String name, Object... args) throws BeansException;

	<T> T getBean(Class<T> requiredType, Object... args) throws BeansException;

DefaultListableBeanFactory

DefaultListableBeanFactory是Bean工厂的一个默认实现，我们可以对它进行拓展以便实现自定义的Bean工厂。作为默认的Bean工厂实现，肯定也实现了接口中定义的getBean方法。截取DefaultListableBeanFactory中与getBean方法相关的源码如下：

public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory

		implements ConfigurableListableBeanFactory, BeanDefinitionRegistry, Serializable {

	......

	@Override

	public <T> T getBean(Class<T> requiredType) throws BeansException {

		return getBean(requiredType, (Object[]) null);

	}

	@Override

	public <T> T getBean(Class<T> requiredType, Object... args) throws BeansException {

		NamedBeanHolder<T> namedBean = resolveNamedBean(requiredType, args);

		if (namedBean != null) {

			return namedBean.getBeanInstance();

		}

		BeanFactory parent = getParentBeanFactory();

		if (parent != null) {

			return parent.getBean(requiredType, args);

		}

		throw new NoSuchBeanDefinitionException(requiredType);

	}

	......

}

发现DefaultListableBeanFactory中只实现了两个getBean接口，BeanFactory中总共有五个接口，那另外三个接口呢？在哪里实现的？尤其是最重要的getBean(String name)接口。

查看DefaultListableBeanFactory类UML类图关系发现有一个AbstractBeanFactory抽象类，DefaultListableBeanFactory继承了AbstractBeanFactory，如下图所示：

AbstractBeanFactory

通过查找AbstractBeanFactory源码，终于找到BeanFactory接口中另外三个getBean方法的实现。源码如下：

package org.springframework.beans.factory.support;

import java.beans.PropertyEditor;

import java.security.AccessControlContext;

import java.security.AccessController;

import java.security.PrivilegedAction;

import java.security.PrivilegedActionException;

import java.security.PrivilegedExceptionAction;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collections;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Iterator;

import java.util.LinkedHashMap;

import java.util.LinkedHashSet;

import java.util.LinkedList;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.concurrent.ConcurrentHashMap;

import org.springframework.beans.BeanUtils;

import org.springframework.beans.BeanWrapper;

import org.springframework.beans.BeansException;

import org.springframework.beans.PropertyEditorRegistrar;

import org.springframework.beans.PropertyEditorRegistry;

import org.springframework.beans.PropertyEditorRegistrySupport;

import org.springframework.beans.SimpleTypeConverter;

import org.springframework.beans.TypeConverter;

import org.springframework.beans.TypeMismatchException;

import org.springframework.beans.factory.BeanCreationException;

import org.springframework.beans.factory.BeanCurrentlyInCreationException;

import org.springframework.beans.factory.BeanDefinitionStoreException;

import org.springframework.beans.factory.BeanFactory;

import org.springframework.beans.factory.BeanFactoryUtils;

import org.springframework.beans.factory.BeanIsAbstractException;

import org.springframework.beans.factory.BeanIsNotAFactoryException;

import org.springframework.beans.factory.BeanNotOfRequiredTypeException;

import org.springframework.beans.factory.CannotLoadBeanClassException;

import org.springframework.beans.factory.FactoryBean;

import org.springframework.beans.factory.NoSuchBeanDefinitionException;

import org.springframework.beans.factory.ObjectFactory;

import org.springframework.beans.factory.SmartFactoryBean;

import org.springframework.beans.factory.config.BeanDefinition;

import org.springframework.beans.factory.config.BeanDefinitionHolder;

import org.springframework.beans.factory.config.BeanExpressionContext;

import org.springframework.beans.factory.config.BeanExpressionResolver;

import org.springframework.beans.factory.config.BeanPostProcessor;

import org.springframework.beans.factory.config.ConfigurableBeanFactory;

import org.springframework.beans.factory.config.DestructionAwareBeanPostProcessor;

import org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessor;

import org.springframework.beans.factory.config.Scope;

import org.springframework.core.DecoratingClassLoader;

import org.springframework.core.NamedThreadLocal;

import org.springframework.core.ResolvableType;

import org.springframework.core.convert.ConversionService;

import org.springframework.util.Assert;

import org.springframework.util.ClassUtils;

import org.springframework.util.ObjectUtils;

import org.springframework.util.StringUtils;

import org.springframework.util.StringValueResolver;

public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport implements ConfigurableBeanFactory {

  	......

	@Override

	public Object getBean(String name) throws BeansException {

		return doGetBean(name, null, null, false);

	}

	@Override

	public <T> T getBean(String name, Class<T> requiredType) throws BeansException {

		return doGetBean(name, requiredType, null, false);

	}

	@Override

	public Object getBean(String name, Object... args) throws BeansException {

		return doGetBean(name, null, args, false);

	}

	public <T> T getBean(String name, Class<T> requiredType, Object... args) throws BeansException {

		return doGetBean(name, requiredType, args, false);

	}

	@SuppressWarnings("unchecked")

	protected <T> T doGetBean(

			final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)

			throws BeansException {

		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 + "'");

				}

			}

			bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);

		}

		else {

			// 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 {

				final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);

				checkMergedBeanDefinition(mbd, beanName, args);

				// 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);

						getBean(dep);

					}

				}

				// 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);

				}

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

				}

				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;

			}

		}

		// Check if required type matches the type of the actual bean instance.

		if (requiredType != null && bean != null && !requiredType.isAssignableFrom(bean.getClass())) {

			try {

				return getTypeConverter().convertIfNecessary(bean, requiredType);

			}

			catch (TypeMismatchException ex) {

				if (logger.isDebugEnabled()) {

					logger.debug("Failed to convert bean '" + name + "' to required type '" +

							ClassUtils.getQualifiedName(requiredType) + "'", ex);

				}

				throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());

			}

		}

		return (T) bean;

	}

  	......

}

在三个相同签名getBean方法中，均调用doGetBean方法。doGetBean方法负责从Bean工厂中获取bean对象的具体实现，下面来看看该方法的具体实现：

  1. 检查手动注册的单例集合缓存中是否含有该bean对象，若有，则取出返回，否则继续执行；
  2. 检查该bean是否已经创建，从而判断是否属于循环引用，若是，抛出异常返回，否则继续执行；
  3. 判断bean工厂中是否存在该bean definition，若存在，则取出返回，否则继续执行；
  4. 初始化该bean所依赖的bean对象；
  5. 判断该bean是否是单例模式（singleton），若是，创建单例对象，否则继续执行；
  6. 判断该bean是否是原型模式（prototype），若是，创建原型对象，否则继续执行；
  7. 创建自定义类型（scope）bean对象。

从上面对doGetBean方法分析，可看出创建并获取bean对象是一个非常复杂的过程，并不是简简单单的放入Map中再从其中取出。

小结

本文对IOC容器的核心getBean()方法作了简单的分析，初步了解了IOC容器中getBean()方法的执行流程原理，这对于帮助我们理解IOC容器是十分有帮助的。目前对IOC机制的各个模块都有了一定的了解，下面可以综合各个模块，串联起来研究IOC依赖注入的完整流程。

下文将以ClassPathXmlApplicationContext作为xml文件加载器，实现Spring IOC的类加载，通过断点跟踪来了解IOC对象注入完整流程。

Spring IOC容器分析(3) -- DefaultListableBeanFactory的更多相关文章

  1. Spring IOC容器分析(2) -- BeanDefinition

    上文对Spring IOC容器的核心BeanFactory接口分析发现:在默认Bean工厂DefaultListableBeanFactory中对象不是以Object形成存储,而是以BeanDefin ...

  2. Spring IOC容器分析(4) -- bean创建获取完整流程

    上节探讨了Spring IOC容器中getBean方法,下面我们将自行编写测试用例,深入跟踪分析bean对象创建过程. 测试环境创建 测试示例代码如下: package org.springframe ...

  3. Spring IOC容器分析(1) -- BeanFactory

    搭建好源码阅读环境后,就可以慢慢走进Spring殿堂了.IOC是Inversion of Control的缩写,控制反转的意思.很多人可能都知道IOC是spring的核心,将对象的创建初始化等权限交由 ...

  4. 【spring源码分析】spring ioc容器之前生今世--DefaultListableBeanFactory源码解读

    spring Ioc容器的实现,从根源上是beanfactory,但真正可以作为一个可以独立使用的ioc容器还是DefaultListableBeanFactory,因此可以这么说, DefaultL ...

  5. spring beans源码解读之 ioc容器之始祖--DefaultListableBeanFactory

    spring Ioc容器的实现,从根源上是beanfactory,但真正可以作为一个可以独立使用的ioc容器还是DefaultListableBeanFactory,因此可以这么说, DefaultL ...

  6. Spring源码分析：Spring IOC容器初始化

    概述: Spring 对于Java 开发来说,以及算得上非常基础并且核心的框架了,在有一定开发经验后,阅读源码能更好的提高我们的编码能力并且让我们对其更加理解.俗话说知己知彼,百战不殆.当你对Spri ...

  7. Spring IOC 容器源码分析

    声明!非原创,本文出处 Spring 最重要的概念是 IOC 和 AOP,本篇文章其实就是要带领大家来分析下 Spring 的 IOC 容器.既然大家平时都要用到 Spring,怎么可以不好好了解 S ...

  8. Spring IOC容器源码分析

    注:本文转自https://javadoop.com/post/spring-ioc Spring 最重要的概念是 IOC 和 AOP,本篇文章其实就是要带领大家来分析下 Spring 的 IOC 容 ...

  9. Spring IOC 容器源码分析 - 余下的初始化工作

    1. 简介 本篇文章是"Spring IOC 容器源码分析"系列文章的最后一篇文章,本篇文章所分析的对象是 initializeBean 方法,该方法用于对已完成属性填充的 bea ...

随机推荐

  1. System.Object简介

    Object中的公共方法解释: 公共方法: Equals: public class Object { public virtual Boolean Equals(Object obj) { //如果 ...

  2. ubuntu 11.04侧边栏怎么添加图标

    打开想添加的软件,图标会出现在侧边栏,右击之,点Keep In Launcher即可

  3. BaseServlet，让一个servlet处理多个请求

    BaseServlet 第一次学习servlet的时候是跟着传智播客免费的教学视频,其中崔希凡讲的是我学过自认讲的最好的一位,BaseServlet也是跟着他写过一次,当时很多东西不能理解,后来慢慢发 ...

  4. pseudocode of zigzag conversion

    1.Title : The string "PAYPALISHIRING" is written in a zigzag pattern on a given number of ...

  5. Extjs6（五）——写一个包含toolbar、form、grid的子页面

    本文基于ext-6.0.0 这个页面布局是很多管理系统的常用布局,具体如下图: 一.页面主体personalInfo.js 整个页面采用border布局,分成三部分,这个personalInfo.js ...

  6. ajax上传图片的本质

    1.图片上传到服务器. 2.后台将图片地址传到html页面,以图片形式展现. 3.后天将图片地址加入到input表单中,表单处于隐藏状态. 4.前端删除图片,通过js操作,移除图片与表单数据. 5.图 ...

  7. BootStrap Table和Mybatis Plus实现服务端分页

    一.后台java代码(Mybatis Plus分页) (1)Mybatis Plus分页的配置,在mybatis的xml文件中增加如下配置(Mybatis Plus官方文档:http://baomid ...

  8. MongoDB覆盖索引查询

    官方的MongoDB的文档中说明,覆盖查询是以下的查询: 1. 所有的查询字段是索引的一部分 2. 所有的查询返回字段在同一个索引中 由于所有出现在查询中的字段是索引的一部分, MongoDB 无需在 ...

  9. CRUSH: Controlled, Scalable, Decentralized Placement of Replicated Data译文

    原文地址:http://www.oschina.net/translate/crush-controlled-scalable-decentralized-placement-of-replicate ...

  10. idea中的汉语注释出现乱码的解决方案

    日记 - idea中的汉语注释出现乱码的解决方案 我是个idea的忠实用户,新公司的项目都是用eclipse做的,通过svn拉下代码后发现,注释的内容里,中文内容都是乱码.问过项目负责人,说可能是GB ...