总述：spring框架是如今J2EE开发最重要框架之一，为企业级应用提供一系列轻量级解决方案，比如：基于依赖注入的核心机制、基于AOP的声明式事务管理、与多种持久层技术整合、整合后端各种组件等等。贯穿了表现层、业务层、持久层，实现无缝整合。

文章结构：（1） 框架总述；（2）以Bean为核心的IOC/DI机制；

---

一、框架总述：

图选自疯狂Java讲义。文字参考：此博主此文章。本博主在此摘抄并补充下

（1）Core Container（核心容器）：

包含有Core,Beans,Context,Expression Language模块。是框架的基础部分，提供IOC(控制反转)和依赖注入特性。这里的基础概念 是BeanFactory,它提供Factory模式的经典实现来消除对程序单例模式的需要，并真正地允许你从程序逻辑中分离出依赖关系和配置。

• Core模块主要包含Spring框架基本的核心工具类，Spring的其他组件都要使用到这个包里的类，Core模块是其他组件的基本核心。当然你也可以在自己的应用系统中使用这些工具类。
• Beans模块是所有应用都要用到的，它包含访问配置文件，创建和管理bean以及进行Inversion of Control/Dependency Injection(依赖注入)操作相关的所有类。
• Context模块构建于Core和Beans模块基础之上，提供了一种类似于JNDI注册器的框架式的对象访问方法。Context模块集成了Beans的特性，为Spring核心提供了大量的扩展，添加了对国际化（例如资源绑定），事件传播，资源加载和对Context的透明创建的支持。Context模块同时也支持J2EE的一些特性，例如EJB（java企业Bean）,JMX(Java Management Extensions，即Java管理扩展是一个为应用程序、设备、系统等植入管理功能的框架)和基础的远程处理。ApplicationContext接口是Context模块的关键。
• Expression Language 模块提供了一个强大的表达式语言用于在运行时查询和操纵对象。它是JSP2.1规范中定义的unifed expression language的一个扩展。该语言支持设置/获取属性的值，属性的分配，方法的调用，访问数组上下文（accession the context of arrays）,容器和索引器，逻辑和算数运算符，命名变量以及从Spring的IOC容器中根据名称检索对象。它也支持list投影，选择和一般的list聚合。

（2）WEB层：

Web上下文模块建立在应用程序上下文模块之上，为基于Web的应用程序提供了上下文。所以Spring框架支持与Jakarta Struts的集成。Web模块还简化了处理多部分请求以及将请求参数绑定到域对象的工作。Web层包含了Web,Web-Servlet，Web-Struts和Web-Porlet模块，具体说明如下。

• Web-Servlet模块web.servlet.jar:该模块包含Spring的model-view-controller(MVC)的实现。Spring的MVC框架使得模型范围内的代码和web forms之间能够清楚地分离开来，并与Spring框架的其他特性集成在一起。
• Web模块：提供了基础的面向Web的集成特性。例如，多文件上传，使用servlet listeners初始化IOC容器以及一个面向Web的应用上下文。它还包含Spring远程支持中Web的相关部分。
• Web-Porlet模块：提供了用于Portlet环境和Web-Servlet模块的MVC的实现。
• spring4.0以后加入了对websocket技术的支持.目的是浏览器与服务端建立全双工的通信方式，解决http请求-响应带来过多的资源消耗，同时对特殊场景应用提供了全新的实现方式，比如聊天、股票交易、游戏等对对实时性要求较高的行业领域。

（3）Data Access/Integration.持久层：

Data Access/Integration层包含有JDBC,ORM,OXM,JMS和Transaction模块，其中：

• JDBC模块提供了一个JDBC抽象层，它可以消除冗长的JDBC编码和解析数据库厂商特有的错误代码。这个模块包含了Spring对JDBC数据访问进行封装的所有类。
• ORM(Object Relational Mapping对象关系映射)模块为流行的对象-关系映射API,如JPA,JDO,Hibernate,iBatis等，提供了一个交互层。利用ORM封装包，可以混合使用所有Spring提供的特性进行O/R映射。如前边提到的简单声明性事务管理。

Spring框架插入了若干个ORM框架，从而提供了ORM的对象关系工具，其中包括JDO,hibernate和MyBatis。所有这些都遵从Spring的通用事务和DAO异常层次结构。

• OXM模块提供了一个对Object/XML映射实现的抽象层，Object/XML映射实现包括JAXB(JAXB能够使用Jackson对JAXB注解的支持实现(jackson-module-jaxb-annotations)，既方便生成XML，也方便生成JSON，这样一来可以更好的标志可以转换为JSON对象的JAVA类。
• JMS（Java Messaging Service）模块主要包含了一些制造和消费消息的特性。
• Transaction模块支持编程和声明性的事务管理，这些事务类必须实现特定的接口，并且对所有的POJO（实际就是普通JavaBeans）都适用。

（4）切面层：

1. AOP模块提供了一个符合AOP联盟标准的面向切面编程的实现

它让你可以定义例如方法拦截器和切点。从而将逻辑代码分开，降低它们之间的耦合性。利用source-level的元数据功能，还可以将各种行为信息合并到你的代码中，这有点像.Net技术中的attribute概念。

通过配置管理特性，SpringAOP模块直接将面向切面的编程功能集成到了Spring框架中，所以可以很容易地使Spring框架管理的任何对象支持AOP。Spring AOP模块为基于Spring的应用程序中的对象提供了事务管理服务。通过使用Spring AOP，不用依赖EJB组件，就可以将声明性事务管理集成到应用程序中。

2. Aspects模块提供了对AspectJ（一个面向切面的框架，它扩展了Java语言）的集成支持。

3.Instrumentation模块提供了class instrumentation 支持和classloader实现，使得可以在特定的应用服务器上使用。

（5）Test层：

此层支持使用JUnit和TestNG对Spring组件进行测试。

@RunWith(SpringJUnit4ClassRunner.class) // 使用Springtest测试框架
@ContextConfiguration("/spring/spring-*.xml") // 加载配置

---

二、以Bean为核心的IOC/DI机制：

总述理论核心：在spring中，所有的对象都会被spring核心容器管理。一切对象统称为Bean。

Spring容器可通过XML配置文件或者注解去管理这堆Bean。

（1）定义以及原理：

依赖注入（IOC/DI）：

spring容器负责将被依赖对象赋值给调用者的成员变量–相当于为调用者注入它依赖的实例。

依赖关系：

A对象需要调用B对象方法的情况–A依赖B。

原理：

1. 原始做法：

调用者主动创建被依赖对象，然后再调用被依赖对象的方法。

调用者需要通过像“new 对象”的操作去创建对象。

缺点：

必然导致调用者与被依赖对象实现类的硬编码耦合。（因为我不想知道你的创建过程、也不想主动去创建你）

2. 简单工厂模式：

调用者先找到被依赖对象的工厂，然后主动通过工厂去获取被依赖对象，最后再调用被依赖对象的方法。

调用者面向被依赖对象的接口编程；将被依赖对象的创建交给工厂；调用者通过工厂来获得被依赖组件。

缺点：

调用组件需要主动通过工厂去获取被依赖对象，必然带来调用组件与被依赖对象工厂的耦合。（同样，我也不想知道你这个工厂存在，我只想要个依赖对象）

3.Spring框架下的依赖注入：框架为调用者注入它依赖的实例。

优点：

程序无须例会被依赖对象的实现，也无须主动定位工厂。只需被动等待IOC容器分配依赖对象。

（2）应用：

依赖注入分为两种：[一]设值注入；[二]构造注入；

1. 设值注入：

指IOC容器通过成员遍历的setter方法来注入被依赖对象。

使用方法：可见我们没有硬编码上去创建依赖对象

<?xml version="1.0" encoding="GBK"?>
<!-- Spring配置文件的根元素，使用spring-beans-4.0.xsd语义约束 -->
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns="http://www.springframework.org/schema/beans"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
	http://www.springframework.org/schema/beans/spring-beans-4.0.xsd">
	<!-- 配置chinese实例，其实现类是Chinese类 -->
	<bean id="chinese" class="com.fuzhu.Chinese">
		<!-- 驱动调用chinese的setAxe()方法，将容器中stoneAxe作为传入参数 -->
		<property name="axe" ref="stoneAxe"/>
	</bean>
	<!-- 配置Axe实例 -->
	<bean id="axe" class="com.fuzhu.Axe"/>
	
</beans>

public class Chinese 
{
	private Axe axe;//定义个斧头引用
	// 设值注入所需的setter方法
	public void setAxe(Axe axe)
	{
		this.axe = axe;
	}
	// 实现依赖对象的方法useAxe方法
	public void useAxe()
	{
		// 调用axe的chop()方法，
		// 表明Chinese 对象依赖于axe对象
		System.out.println(axe.chop());
	}
}
//斧头类
public class Axe 
{
	public String chop()
	{
		return "石斧砍柴好慢";
	}
}

写个test类

public class BeanTest
{
	public static void main(String[] args)throws Exception
	{
		// 创建Spring容器
		ApplicationContext ctx = new
			ClassPathXmlApplicationContext("beans.xml");
		// 获取chinese 实例
		Chinese p = ctx.getBean("chinese" , Chinese.class);
		// 调用useAxe()方法
		p.useAxe();
	}
}

2. 构造注入：IOC容器使用构造器来注入被依赖对象。

在构造实例时，已经为其完成了依赖关系的初始化。本质就是当执行带参数的构造器时，就可利用构造器参数对成员变量执行初始化。《contructopr-arg… /》

使用方法：

<?xml version="1.0" encoding="GBK"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns="http://www.springframework.org/schema/beans"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
	http://www.springframework.org/schema/beans/spring-beans-4.0.xsd">
	<!-- 配置chinese实例，其实现类是Chinese -->
	<bean id="chinese" class="com.fuzhu.Chinese">
		<!-- 下面只有一个constructor-arg子元素，
			驱动Spring调用Chinese带一个参数的构造器来创建对象 -->
		<constructor-arg ref="axe" type="com.fuzhu.Axe"/>
	</bean>
	<!-- 配置Axe实例-->
	<bean id="axe" class="com.fuzhu.StoneAxe"/>
</beans>

public class Chinese 
{
	private Axe axe;
	// 构造注入所需的带参数的构造器
	public Chinese(Axe axe)
	{
		this.axe = axe;
	}
	// 实现依赖对象的方法useAxe()方法
	public void useAxe()
	{
		// 调用axe的chop()方法
		// 表明Chinese 对象依赖于axe对象
		System.out.println(axe.chop());
	}
}
public class  Axe
{
	public String chop()
	{
		return "石斧砍柴好慢";
	}
}

3. 注解注入装配：

以后再讲，其实是基于前两种注解方式实现的。

（3）IOC/DI依赖注入源码理解：（基于spring4.1.7）

重点理解两个过程：IoC容器初始化过程以及IoC容器依赖注入过程。

其实就是：资源定位、资源装载、资源解析、Bean生成，Bean注册、Bean依赖注入这几个过程（前五属于初始化过程）。方法：eclipse断点ClassPathXmlApplicationContext调用，不断跳进去，就看到spring执行栈了。

1. IoC容器初始化过程：

以上图思路进行详细讲述

初始化总过程：

资源定位（确定工厂创建和bean的配置文件）—>资源装载（在文件系统路径上对IOC配置文件、bean配置进行加载）—>资源解析（解析bean配置，解析xml元素）—>生成bean（根据DOM资源解析成bean）—>在IoC容器中注册（交给IoC容器管理，还有依赖注入的权限）

整体过程大致如上图（从下往上看的栈，）：

保存配置，并刷新工厂–>创建载入BeanFactory–>创建XmlBeanDefinitionReader–>创建处理每一个Resource–>转换成Document对象–>处理XML每个元素–>解析注册bean

---

[一]资源定位：

追踪：我们可在此句获取工厂前设断点然后debug追踪进去，查看IoC的资源定位

ApplicationContext ctx = new ClassPathXmlApplicationContext("/spring/spring-*.xml");

然后一路跳进去：

public ClassPathXmlApplicationContext(String configLocation) throws BeansException {
        this(new String[]{configLocation}, true, (ApplicationContext)null);
}
/*
	此处为资源定位核心调用层
*/
public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent) throws BeansException {
        super(parent);//有前面类图 可 以知道，最终 父类 为AbstractApplicationContext
        this.setConfigLocations(configLocations);//调用资源定位设置方法，然后我们跳进去寻找此方法位置，如下面代码
        if(refresh) {//接着执行容器刷新方法
            this.refresh();
        }

    }
    //这个是追踪上去的ClassPathXmlApplicationContext父类
public AbstractXmlApplicationContext(ApplicationContext parent) {
        super(parent);
    }
    //再追踪AbstractXmlApplicationContext的父类AbstractRefreshableConfigApplicationContext。然后它拥有了以下方法，从而
public void setConfigLocation(String location) {
        this.setConfigLocations(StringUtils.tokenizeToStringArray(location, ",; \t\n"));
    }
/*
	资源定位方法
*/
    public void setConfigLocations(String... locations) {
        if(locations != null) {
            Assert.noNullElements(locations, "Config locations must not be null");
            this.configLocations = new String[locations.length];
// 该方法调用 SystemPropertyUtils.resolvePlaceholders(path) ；对 path 中的占位 符进行替换， eg ： path 路径中含有 ${user.dir} ，则将替换为： System.getProperty(user.dir);
            for(int i = 0; i < locations.length; ++i) {
                this.configLocations[i] = this.resolvePath(locations[i]).trim();
            }
        } else {
            this.configLocations = null;
        }

    }

根据资源定位核心调用层，我们可以看到他必执行AbstractApplicationContext中的refresh方法，执行容器刷新。部分叙述参考此博主此文章

public void refresh() throws BeansException, IllegalStateException {
        Object var1 = this.startupShutdownMonitor;
        //加锁同步了
        synchronized(this.startupShutdownMonitor) {
         //调用容器准备刷新的方法，获取 容器的当时时间，同时给容器设置同步标识  
            this.prepareRefresh();
            //告诉子类启动refreshBeanFactory()方法，Bean定义资源文件的载入从子类的refreshBeanFactory()方法启动  
            //并获取beanFactory
            ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();
            //为BeanFactory配置容器特性，例如类加载器、事件处理器等  
            this.prepareBeanFactory(beanFactory);

            try {
	            //为容器的某些子类指定特殊的BeanPost事件处理器  
                this.postProcessBeanFactory(beanFactory);
                //调用所有注册的BeanFactoryPostProcessor的Bean  
                this.invokeBeanFactoryPostProcessors(beanFactory);
                //为BeanFactory注册BeanPost事件处理器.  
                 //BeanPostProcessor是Bean后置处理器，用于监听容器触发的事件  
                this.registerBeanPostProcessors(beanFactory);
                //初始化信息源，和国际化相关.  
                this.initMessageSource();
                //初始化容器事件传播器. 
                this.initApplicationEventMulticaster();
                //调用子类的某些特殊Bean初始化方法
                this.onRefresh();
                //为事件传播器注册事件监听器.  
                this.registerListeners();
                //初始化所有剩余的单态Bean.  
                this.finishBeanFactoryInitialization(beanFactory);
                 //初始化容器的生命周期事件处理器，并发布容器的生命周期事件 
                this.finishRefresh();
            } catch (BeansException var5) {
	            //打印警告
                this.logger.warn("Exception encountered during context initialization - cancelling refresh attempt", var5);
                 //销毁以创建的单态Bean  
                this.destroyBeans();
                 //取消refresh操作，重置容器的同步标识.  
                this.cancelRefresh(var5);
                throw var5;
            }

        }
    }
    //获取工厂，让子类刷新内部 bean 工厂。
    /*
    关闭前面所有 bean 工厂，为新的上下文环境初始化一个新的 bean 工厂。这里需要子类来 协助完成资源位置定义 ,bean 载入和向 IOC 容器注册的过程
    容器真正调用的是其子类AbstractRefreshableApplicationContext实现的 refreshBeanFactory()方法
    见下方
    */
   protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
        this.refreshBeanFactory();//子类实现，调用子类的实现
        ConfigurableListableBeanFactory beanFactory = this.getBeanFactory();
        if(this.logger.isDebugEnabled()) {
            this.logger.debug("Bean factory for " + this.getDisplayName() + ": " + beanFactory);
        }

        return beanFactory;
    }

 

AbstractRefreshableApplicationContext实现的refreshBeanFactory

/*
在这个方法中，先判断BeanFactory是否存在，如果存在则先销毁beans并关闭beanFactory，接着创建DefaultListableBeanFactory，并调用loadBeanDefinitions(beanFactory)装载bean
*/
protected final void refreshBeanFactory() throws BeansException {  
       if (hasBeanFactory()) {//如果已经有容器，销 毁 容器中的bean，关闭容器  
           destroyBeans();  
           closeBeanFactory();  
       }  
       try {  
            //创建IoC容器  
            DefaultListableBeanFactory beanFactory = createBeanFactory();  
            beanFactory.setSerializationId(getId());  
           //对IoC容器进行定制化，如设置启动参数，开启注解的自动装配等  
           customizeBeanFactory(beanFactory);  
           //调用载入Bean定义的方法，主要这里使用了一个委派模式，在当前类中只定义了抽象的loadBeanDefinitions方法，具体的实现调用子类容器  
           loadBeanDefinitions(beanFactory);  
           synchronized (this.beanFactoryMonitor) {  
               this.beanFactory = beanFactory;  
           }  
       }  
       catch (IOException ex) {  
           throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);  
       }  
   }
    //为刷新准备上下文环境
protected void prepareRefresh() {
        this.startupDate = System.currentTimeMillis();
        this.active.set(true);
        if(this.logger.isInfoEnabled()) {
            this.logger.info("Refreshing " + this);
        }

        this.initPropertySources();
        this.getEnvironment().validateRequiredProperties();
    }

总的来说：资源定位做的就是：确定工厂位置，执行工厂初始化并刷新，建立好bean资源加载路径。等待bean资源装载。

---

[二]资源装载

设置工厂配置，刷新容器后，还要把我们的bean配置给资源加载器。

目标：

拿到资源加载器，可以classpath：那样直接拿到资源装载。

在这之前，很有必要大家一起区分：不同类中的loadBeanDefinitions解析职责。

在AbstractXmlApplicationContext类中，职责为：对applicationContext.xml的解析操作，就是解析工厂的那个xml

在AbstractBeanDefinitionReader类中，职责为：从指定的资源加载bean定义，真正实现在其子类，这里是做了些兼容性错误处理。

在XmlBeanDefinitionReader类中，是AbstractBeanDefinitionReader的子类，而且是一个真正的实现类 ，是实现BeanDefinitionReader接口的loadBeanDefinitions(Resource var1) 等方法的关键解析类。职责为：读取并真正解析 xml 文件。

AbstractRefreshableApplicationContext中只定义了抽象的loadBeanDefinitions方法，容器真正调用的是其子类AbstractXmlApplicationContext对该方法的实现。（全局搜索SHIFT）

/*
	！！！！资源装载以此为主线！！！这个是哪里的呢？？AbstractXmlApplicationContext实现的
*/
 protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
 //从beanfactory拿到reader
  // 这里使用XMLBeanDefinitionReader来载入bean定义信息的XML文件
        XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
        //这里配置reader的环境，其中ResourceLoader是我们用来定位bean定义信息资源位置的
        ///因为上下文本身实现了ResourceLoader接口，所以可以直接把上下文作为ResourceLoader传递给XmlBeanDefinitionReader。容器本身也是一个资源加载器        
        beanDefinitionReader.setEnvironment(this.getEnvironment());
        beanDefinitionReader.setResourceLoader(this);
        beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));
         //当Bean读取器读取Bean定义的Xml资源文件时，启用Xml的校验机制  
        this.initBeanDefinitionReader(beanDefinitionReader);
         //这里转到定义好的XmlBeanDefinitionReader中对载入bean信息进行处理
        this.loadBeanDefinitions(beanDefinitionReader);
    }

由上面代码得知进入AbstractXmlApplicationContext的loadBeanDefinitions（XmlBeanDefinitionReader参数）

protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {
		 //获取Bean定义资源的定位  
        Resource[] configResources = this.getConfigResources();
         //调用XmlBeanDefinitionReader来载入bean定义信息。 也就是AbstractBeanDefinitionReader类的loadBeanDefinitions去读取Bean资源
        if(configResources != null) {
            reader.loadBeanDefinitions(configResources);
        }
		//例子中使用了的是ClassPathXmlApplicationContext，所以跑下面的bean装载方法
        String[] configLocations = this.getConfigLocations();
        if(configLocations != null) {
            reader.loadBeanDefinitions(configLocations);
        }

    }

接着根据上面继续追踪，到了AbstractBeanDefinitionReader类的loadBeanDefinitions方法

 public int loadBeanDefinitions(String location, Set<Resource> actualResources) throws BeanDefinitionStoreException {
 //这里得到当前定义的ResourceLoader,默认的 我 们 使用DefaultResourceLoader
        ResourceLoader resourceLoader = this.getResourceLoader();
        //如果没有找到我们需要的ResourceLoader，直接抛出异常
        if(resourceLoader == null) {
            throw new BeanDefinitionStoreException("Cannot import bean definitions from location [" + location + "]: no ResourceLoader available");
        } else {
            int loadCount;
            if(!(resourceLoader instanceof ResourcePatternResolver)) {
            // 这里处理我们在定义位置时使用的各种pattern,需要ResourcePatternResolver来完成
                Resource resource = resourceLoader.getResource(location);
                loadCount = this.loadBeanDefinitions((Resource)resource);
                if(actualResources != null) {
                    actualResources.add(resource);
                }

                return loadCount;
            } else {
                try {
                 // 这里通过ResourceLoader来完成位置定位
                    Resource[] resources = ((ResourcePatternResolver)resourceLoader).getResources(location);
                    // 这里已经把一个位置定义转化为Resource接口，可以供XmlBeanDefinitionReader来使用了
                    loadCount = this.loadBeanDefinitions(resources);
                    if(actualResources != null) {
                        Resource[] var6 = resources;
                        int var7 = resources.length;

                        for(int var8 = 0; var8 < var7; ++var8) {
                            Resource resource = var6[var8];
                            actualResources.add(resource);
                        }
                    }

                    if(this.logger.isDebugEnabled()) {
                        this.logger.debug("Loaded " + loadCount + " bean definitions from location pattern [" + location + "]");
                    }

                    return loadCount;
                } catch (IOException var10) {
                    throw new BeanDefinitionStoreException("Could not resolve bean definition resource pattern [" + location + "]", var10);
                }
            }
        }
    }

所以，AbstractBeanDefinitionReader的loadBeanDefinitions方法源码分析可以看出该方法做了以下两件事：

（1）首先，调用资源加载器的获取资源方法resourceLoader.getResource(location)，获取到要加载的资源。
（2）其次，真正执行加载功能是其子类XmlBeanDefinitionReader实现的loadBeanDefinitions方法。

另外，此时调用的是DefaultResourceLoader中的getSource()方法定位Resource。

然后我们再仔细看下各个类想拿到资源加载器就是通过getResourceLoader，拿到AbstractBeanDefinitionReader类定义的resourceLoader。这样的话，我们可通过此方式在工程spring下的任何地方拿到资源加载器，“随处加载”了。

public interface ResourceLoader {
    String CLASSPATH_URL_PREFIX = "classpath:";

    Resource getResource(String var1);//拿到资源

    ClassLoader getClassLoader();//拿到类加载器
}

总的来说，资源装载就是：根据之前确定好的bean资源配置路径，拿到资源、拿到加载器，并把bean配置丢进XmlBeanDefinitionReader。等待Bean资源解析。

---

[三]Bean资源解析：其实就是刚我们遇到的XmlBeanDefinitionReader类啦。真正去解析xml。解析的关注重心请注意到doLoadBeanDefinitions方法，从这里进行分发。从而到下一部生成bean对象。

目标：

将XML文件转为DOM对象。进而交DocumentLoader和DocumentBuilderFactory处理dom对象给doLoadBeanDefinitions方法，从而为bean生成作铺垫

//这里是载入XML形式Bean定义资源文件方法 
public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {
        Assert.notNull(encodedResource, "EncodedResource must not be null");
        if(this.logger.isInfoEnabled()) {
            this.logger.info("Loading XML bean definitions from " + encodedResource.getResource());
        }
		 //获取当前的线程变量，它是用于保存处理的resource的  
        Set<EncodedResource> currentResources = (Set)this.resourcesCurrentlyBeingLoaded.get();
        if(currentResources == null) {
            currentResources = new HashSet(4);
            this.resourcesCurrentlyBeingLoaded.set(currentResources);//保存当前的resource 
        }
        if(!((Set)currentResources).add(encodedResource)) {
            throw new BeanDefinitionStoreException("Detected cyclic loading of " + encodedResource + " - check your import definitions!");
        } else {
            int var5;
            try {
             //将资源文件转为InputStream的IO流 
                InputStream inputStream = encodedResource.getResource().getInputStream();

                try {
                 //从InputStream中得到XML的解析源   
                    InputSource inputSource = new InputSource(inputStream);
                    if(encodedResource.getEncoding() != null) {
                        inputSource.setEncoding(encodedResource.getEncoding());
                    }
			//这里是具体的读取过程  
                    var5 = this.doLoadBeanDefinitions(inputSource, encodedResource.getResource());
                } finally {
                //关闭从Resource中得到的IO流   
                    inputStream.close();
                }
            } catch (IOException var15) {
                throw new BeanDefinitionStoreException("IOException parsing XML document from " + encodedResource.getResource(), var15);
            } finally {
                ((Set)currentResources).remove(encodedResource);
                if(((Set)currentResources).isEmpty()) {
                    this.resourcesCurrentlyBeingLoaded.remove();
                }

            }

            return var5;
        }
    }
//从特定XML文件中实际载入Bean定义资源的方法 ，就是转成dom对象后交给这里去进一步处理从而转换出bean
    protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource) throws BeanDefinitionStoreException {
        try {
        //将XML文件转换为DOM对象，解析过程由documentLoader实现
            Document doc = this.doLoadDocument(inputSource, resource);
             //这里是启动对Bean定义解析的详细过程，该解析过程会用到Spring的Bean配置规则
            return this.registerBeanDefinitions(doc, resource);
        } catch (BeanDefinitionStoreException var4) {
            throw var4;
        } catch (SAXParseException var5) {
            throw new XmlBeanDefinitionStoreException(resource.getDescription(), "Line " + var5.getLineNumber() + " in XML document from " + resource + " is invalid", var5);
        } catch (SAXException var6) {
            throw new XmlBeanDefinitionStoreException(resource.getDescription(), "XML document from " + resource + " is invalid", var6);
        } catch (ParserConfigurationException var7) {
            throw new BeanDefinitionStoreException(resource.getDescription(), "Parser configuration exception parsing XML from " + resource, var7);
        } catch (IOException var8) {
            throw new BeanDefinitionStoreException(resource.getDescription(), "IOException parsing XML document from " + resource, var8);
        } catch (Throwable var9) {
            throw new BeanDefinitionStoreException(resource.getDescription(), "Unexpected exception parsing XML document from " + resource, var9);
        }
    }

然后沿着doLoadDocument继续追踪，追踪到一个接口DocumentLoader和一个实现类DefaultDocumentLoader。以下是DefaultDocumentLoader这个实现类的部分代码

public Document loadDocument(InputSource inputSource, EntityResolver entityResolver, ErrorHandler errorHandler, int validationMode, boolean namespaceAware) throws Exception {
  //创建文件解析器工厂  
        DocumentBuilderFactory factory = this.createDocumentBuilderFactory(validationMode, namespaceAware);
        if(logger.isDebugEnabled()) {
            logger.debug("Using JAXP provider [" + factory.getClass().getName() + "]");
        }
//创建文档解析器  
        DocumentBuilder builder = this.createDocumentBuilder(factory, entityResolver, errorHandler);
        //解析Spring的Bean定义资源
        return builder.parse(inputSource);
    }
    //再根据上面方法追踪到它也执行了本类的一个方法：
    //调用了Javaee的JAXP标准，根据定位的Bean定义资源文件，加载读入并转换成为Document对象过程完成
protected DocumentBuilder createDocumentBuilder(DocumentBuilderFactory factory, EntityResolver entityResolver, ErrorHandler errorHandler) throws ParserConfigurationException {
        DocumentBuilder docBuilder = factory.newDocumentBuilder();
        if(entityResolver != null) {
            docBuilder.setEntityResolver(entityResolver);
        }

        if(errorHandler != null) {
            docBuilder.setErrorHandler(errorHandler);
        }

        return docBuilder;
    }

总的来说

Bean资源解析就是，先通过 XML解析器讲Bean定义资源文件转换得到Document对象，但是这堆Document对象没有按照spring的Bean规则的，所以不可直接转换成bean对象。然后完成XML解析变成Document对象后，就调用spring的解析方法按照Spring的Bean规则去对Document进行解析，生成Bean对象。

---

[四]生成Bean：还是关注XmlBeanDefinitionReader类的doLoadBeanDefinitions方法，他进行了一个调用：registerBeanDefinitions。

//按照Spring的Bean语义要求 将Bean 定 义  资源解析并转换为容器内部数据结构 
public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
//得到BeanDefinitionDocumentReader来对xml格式的BeanDefinition解析  
        BeanDefinitionDocumentReader documentReader = this.createBeanDefinitionDocumentReader();
        //读取环境的配置设置
        documentReader.setEnvironment(this.getEnvironment());
        //获得容器中注册的Bean数量  
        int countBefore = this.getRegistry().getBeanDefinitionCount();
         //解析过程入口，这里使用了委派模式，BeanDefinitionDocumentReader只是个接口，//具体的解析实现过程有实现类DefaultBeanDefinitionDocumentReader完成 
        documentReader.registerBeanDefinitions(doc, this.createReaderContext(resource));
        //统计解析的Bean数量
        return this.getRegistry().getBeanDefinitionCount() - countBefore;
    }
    //在此方法真正去转化document对象成为bean
 protected BeanDefinitionDocumentReader createBeanDefinitionDocumentReader() {
        return (BeanDefinitionDocumentReader)BeanDefinitionDocumentReader.class.cast(BeanUtils.instantiateClass(this.documentReaderClass));
    }

接下来就是document元素的一个个解析，然后转化成bean对象了。

我们根据上面的解析入口可以追踪到 BeanDefinitionDocumentReader接口的实现类DefaultBeanDefinitionDocumentReader。在这个类进行详细的document元素解析成我们平常工程用的bean。但本博主不打算继续看了，因为对我们掌握spring的IOC原理并不影响。

[五]在IoC容器注册解析生成的Bean：

目标：到IoC容器注册

我们能猜到他在类DefaultBeanDefinitionDocumentReader生成bean后必然会丢给IoC容器去注册，交给它管理。但是我们怎么找到呢？？根据上面生成bean中的解析入口，我们CTRL+F查registerBeanDefinitions。

再进一步追踪到parseDefaultElement方法，可以看到这里就是识别主标签，从而进行解析生成bean。

/*
	根据标签去选择bean元素生成法
*/
private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
        if(delegate.nodeNameEquals(ele, "import")) {
            this.importBeanDefinitionResource(ele);
        } else if(delegate.nodeNameEquals(ele, "alias")) {
            this.processAliasRegistration(ele);
        } else if(delegate.nodeNameEquals(ele, "bean")) {//找到啦，我们继续追踪这里。
            this.processBeanDefinition(ele, delegate);
        } else if(delegate.nodeNameEquals(ele, "beans")) {
            this.doRegisterBeanDefinitions(ele);
        }

    }
//进入解析和注册分发啦
protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
        BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
        if(bdHolder != null) {
            bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);

            try {
            //注册分发： 继续追踪
                BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, this.getReaderContext().getRegistry());
            } catch (BeanDefinitionStoreException var5) {
                this.getReaderContext().error("Failed to register bean definition with name '" + bdHolder.getBeanName() + "'", ele, var5);
            }

            this.getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
        }

    }

    //终于找到你了，注册！！
    //BeanDefinitionReaderUtils类的
public static void registerBeanDefinition(BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry) throws BeanDefinitionStoreException {
 //得到需要 注册 的 bean名字
        String beanName = definitionHolder.getBeanName();
         //开始注册。锁定registerBeanDefinition方法
        registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());
         // 别名也是可以 通过IOC容器和bean联系起来的进行注册 
        String[] aliases = definitionHolder.getAliases();
        if(aliases != null) {
            String[] var4 = aliases;
            int var5 = aliases.length;

            for(int var6 = 0; var6 < var5; ++var6) {
                String alias = var4[var6];
                registry.registerAlias(beanName, alias);
            }
        }

    }
    //锁定registerBeanDefinition方法后，然而我们发现的是一个接口BeanDefinitionRegistry，因此我们必须找到他的实现类，但是我们却只是发现很多他的抽象类AbstractAutowireCapableBeanFactory、AbstractBeanFactory、FactoryBeanRegistrySupport、DefaultSingletonBeanRegistry等等（感慨编写spring大佬的心累（我找得更累！！））

终于找到非抽象实现类啦：DefaultListableBeanFactory（其实我当时查的快疯，是查他的继承树才查到这个的。）

使用一个HashMap的集合对象存放IoC容器中注册解析的BeanDefinition

//~~~！！！实现了BeanDefinitionRegistry接口
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition) throws BeanDefinitionStoreException {
//一堆验证beanDefinition的正确性
        Assert.hasText(beanName, "Bean name must not be empty");
        Assert.notNull(beanDefinition, "BeanDefinition must not be null");
        if(beanDefinition instanceof AbstractBeanDefinition) {
            try {
                ((AbstractBeanDefinition)beanDefinition).validate();
            } catch (BeanDefinitionValidationException var4) {
                throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName, "Validation of bean definition failed", var4);
            }
        }
 //先看看在容器里是不是已经有了同名的bean,如果有抛出异常。
        BeanDefinition oldBeanDefinition = (BeanDefinition)this.beanDefinitionMap.get(beanName);
        if(oldBeanDefinition != null) {
            if(!this.isAllowBeanDefinitionOverriding()) {
                throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName, "Cannot register bean definition [" + beanDefinition + "] for bean '" + beanName + "': There is already [" + oldBeanDefinition + "] bound.");
            }

            if(oldBeanDefinition.getRole() < beanDefinition.getRole()) {
                if(this.logger.isWarnEnabled()) {
                    this.logger.warn("Overriding user-define d bean definition for bean '" + beanName + "' with a framework-generated bean definition: replacing [" + oldBeanDefinition + "] with [" + beanDefinition + "]");
                }
            } else if(this.logger.isInfoEnabled()) {
                this.logger.info("Overriding bean definition for bean '" + beanName + "': replacing [" + oldBeanDefinition + "] with [" + beanDefinition + "]");
            }
        } else {
        //没重复就把bean的名字加到IOC容器中去
            this.beanDefinitionNames.add(beanName);
            this.manualSingletonNames.remove(beanName);
            this.frozenBeanDefinitionNames = null;
        }
//这里把bean的名字和Bean定义联系起来放到一个HashMap中去,IOC容器通过这个Map来维护容器里的Bean定义信息。
        this.beanDefinitionMap.put(beanName, beanDefinition);
        if(oldBeanDefinition != null || this.containsSingleton(beanName)) {
            this.resetBeanDefinition(beanName);
        }

    }

总的来说就是：把beandefinition丢给工厂用hashmap存好。

IOC容器初始化总结：

（1）通过setConfigLocations载入spring配置文件；

（2）初始化容器入口通过refresh方法，进入AbstractApplicationContext实现的refresh方法。

（3）然后通过obtainFreshBeanFactory方法进入子类AbstractRefreshableApplicationContext实现的refreshBeanFactory刷新一个容器工厂

（4）在此创建了DefaultListableBeanFactory类，并调用loadBeanDefinitions(beanFactory)装载bean定义

（5）接着以AbstractRefreshableApplicationContext为中心回到此类，进入其子类AbstractXmlApplicationContext实现的loadBeanDefinitions方法。对applicationContext.xml的解析操作，就是解析工厂的那个xml。

（6）再接着通过AbstractXmlApplicationContext的loadBeanDefinitions进入到AbstractBeanDefinitionReader类的loadBeanDefinitions。通过获取资源方法resourceLoader.getResource(location)，获取到要加载的资源。再真正执行加载功能是其子类XmlBeanDefinitionReader实现的loadBeanDefinitions方法。

（6）接着进入XmlBeanDefinitionReader中的loadBeanDefinitions。（XmlBeanDefinitionReader通过调用其父类中调用的DefaultResourceLoader的getResource方法获取要加载的资源）DocumentLoader将Bean定义资源转换成Document对象。

（7）doLoadBeanDefinitions中进入DefaultBeanDefinitionDocumentReader类的registerBeanDefinitions 解 析 D ocument对象

（8）解析完后，调用DefaultListableBeanFactory类中使用一个HashMap的集合对象存放IoC容器中注册解析的BeanDefinition

---

2.IoC容器依赖注入过程：

[ 一 ]先来读懂beanfactory的继承逻辑树

类图。我们根据DefaultListableBeanFactory继续追踪上去。一会详讲此逻辑线。参考此博主此文章，非常感谢他，写得太棒了。让我学到很多。

先来读懂它beanfactory的继承树逻辑线。图取自此文章

解析上图：

BeanFactory是Spring的最根的接口，类的工厂接口。HierarchicalBeanFactory接口是在继承BeanFactory的基础上，实现BeanFactory的父子关系。Hierarchical表示的是这些 Bean 是有继承关系的，也就是每个 Bean 有可能有父 Bean。

AutowireCapableBeanFactory接口是在继承BeanFactory的基础上，实现Bean的自动装配功能。定义 Bean 的自动装配规则。

ListableBeanFactory接口是在继承BeanFactory的基础上，实现Bean的list集合操作功能。表示这些 Bean 是可列表的。

ConfigurableBeanFactory接口是在继承HierarchicalBeanFactory的基础上，实现BeanFactory的全部配置管理功能， SingletonBeanRegistry是单例bean的注册接口

ConfigurableListableBeanFactory接口是继承AutowireCapableBeanFactory，ListableBeanFactory，ConfigurableBeanFactory三个接口的一个综合接口。

AliasRegistry接口是别名注册接口，SimpleAliasRegistry类是简单的实现别名注册接口的类。

DefaultSingletonBeanRegistry是默认的实现SingletonBeanRegistry接口的类，同时，继承类SimpleAliasRegistry 。

FactoryBeanRegistrySupport是实现FactoryBean注册的功能实现。继承类DefaultSingletonBeanRegistry 。负责FactoryBean相关的操作,并缓存FactoryBean的getObject实例化的bean. 判断factory是单例,同时已经new好了单例时,先尝试去缓存找;如果找不到或者不是单例,委托doGetObjectFromFactoryBean实例化一个。

AbstractBeanFactory是部分实现接口ConfigurableBeanFactory，并继承类FactoryBeanRegistrySupport 。这个是最顶层的抽象IOC容器空构造器，主要用来具体实现了BeanFactory接口。

AbstractAutowireCapableBeanFactory是实现接口AutowireCapableBeanFactory，并继承类 AbstractBeanFactory 。主要的功能就是实现了默认的bean创建方法createBean().而在这个创建过程中，提供了诸如bean的属性注入，初始化方法的调用，自动装配的实现，bean处理器的调用。

DefaultListableBeanFactory实现接口 ConfigurableListableBeanFactory、BeanDefinitionRegistry（bean定义的注册接口）， 并继承AbstractAutowireCapableBeanFactory，实现全部类管理的功能。

可以看出DefaultListableBeanFactory就是springIoC机制的入口。

---

[二]IoC容器依赖注入源码详讲：上面可知我们从实现BeanFactory的AbstractBeanFactory入手

1.我们从DefaultListableBeanFactory开始不断追踪父类，直到找到了AbstractBeanFactory。

public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport implements ConfigurableBeanFactory {
//真正实现向IoC容器获取Bean的功能，也是触发依赖注入功能的地方  
	protected <T> T doGetBean(String name, Class<T> requiredType, final Object[] args, boolean typeCheckOnly) throws BeansException {
	//根据指定的名称获取被管理Bean的名称，剥离指定名称中对容器的相关依赖  
       //如果指定的是别名，将别名转换为规范的Bean名称  
        final String beanName = this.transformedBeanName(name);
        Object sharedInstance = this.getSingleton(beanName);
        Object bean;
         //IoC容器创建单态模式Bean实例对象  
        if(sharedInstance != null && args == null) {
            if(this.logger.isDebugEnabled()) {
            //如果指定名称的Bean在容器中已有单态模式的Bean被创建，直接返回  
               //已经有创建的Bean 
                if(this.isSingletonCurrentlyInCreation(beanName)) {
                    this.logger.debug("Returning eagerly cached instance of singleton bean '" + beanName + "' that is not fully initialized yet - a consequence of a circular reference");
                } else {
                    this.logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
                }
            }
			//获取给定Bean的实例对象，主要是完成FactoryBean的相关处理  
           //注意：BeanFactory是管理容器中Bean的工厂，而FactoryBean是  
           //创建创建对象的工厂Bean，两者之间有区别  
            bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, (RootBeanDefinition)null);
        } else {
        //缓存没有正在创建的单态模式Bean  
           //缓存中已经有已经创建的原型模式Bean，但是由于循环引用的问题导致实  
           //例化对象失败 
            if(this.isPrototypeCurrentlyInCreation(beanName)) {
                throw new BeanCurrentlyInCreationException(beanName);
            }
			//对IoC容器中是否存在指定名称的BeanDefinition进行检查，首先检查是否  
           //能在当前的BeanFactory中获取的所需要的Bean，如果不能则委托当前容器  
           //的父级容器去查找，如果还是找不到则沿着容器的继承体系向父级容器查找
            BeanFactory parentBeanFactory = this.getParentBeanFactory();
            //当前容器的父级容器存在，且当前容器中不存在指定名称的Bean  
            if(parentBeanFactory != null && !this.containsBeanDefinition(beanName)) {
             //解析指定Bean名称的原始名称 
                String nameToLookup = this.originalBeanName(name);
                if(args != null) {
                //委派父级容器根据指定名称和显式的参数查找 
                    return parentBeanFactory.getBean(nameToLookup, args);
                }
					//委派父级容器根据指定名称和类型查找
                return parentBeanFactory.getBean(nameToLookup, requiredType);
            }
		  //创建的Bean是否需要进行类型验证，一般不需要  
            if(!typeCheckOnly) {
            //向容器标记指定的Bean已经被创建 
                this.markBeanAsCreated(beanName);
            }

            try {
             //根据指定Bean名称获取其父级的Bean定义，主要解决Bean继承时子类  
           //合并父类公共属性问题 
                final RootBeanDefinition mbd = this.getMergedLocalBeanDefinition(beanName);
                this.checkMergedBeanDefinition(mbd, beanName, args);
                 //获取当前Bean所有依赖Bean的名称 
                String[] dependsOn = mbd.getDependsOn();
                String[] var11;//用来暂存dependsOn ，用var11来循环
                //如果当前Bean有依赖Bean 
                if(dependsOn != null) {
                    var11 = dependsOn;
                    int var12 = dependsOn.length;
					
                    for(int var13 = 0; var13 < var12; ++var13) {
                     //递归调用getBean方法，获取当前Bean的依赖Bean  
                        String dependsOnBean = var11[var13];
                        if(this.isDependent(beanName, dependsOnBean)) {
                            throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Circular depends-on relationship between '" + beanName + "' and '" + dependsOnBean + "'");
                        }
					 //把被依赖Bean注册给当前依赖的Bean  
                        this.registerDependentBean(dependsOnBean, beanName);
                        this.getBean(dependsOnBean);
                    }
                }
		 //创建单态模式Bean的实例对象 
                if(mbd.isSingleton()) {
                //这里使用了一个匿名内部类，创建Bean实例对象，并且注册给所依赖的对象  
                    sharedInstance = this.getSingleton(beanName, new ObjectFactory<Object>() {
                        public Object getObject() throws BeansException {
                            try {
                             //创建一个指定Bean实例对象，如果有父级继承，则合并子类和父类的定义！！！！！就是在此再次分发到创建bean的实现方法
                                return AbstractBeanFactory.this.createBean(beanName, mbd, args);
                            } catch (BeansException var2) {
                             //显式地从容器单态模式Bean缓存中清除实例对象  
                                AbstractBeanFactory.this.destroySingleton(beanName);
                                throw var2;
                            }
                        }
                    });
                    //获取给定Bean的实例对象  
                    bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
                } else if(mbd.isPrototype()) { //IoC容器创建原型模式Bean实例对象  
                    var11 = null;

                    Object prototypeInstance;//原型模式(Prototype)是每次都会创建一个新的对象 
                    try {
                    //回调beforePrototypeCreation方法，默认的功能是注册当前创//建的原型对象  
                        this.beforePrototypeCreation(beanName);
                         //创建指定Bean对象实例  
                        prototypeInstance = this.createBean(beanName, mbd, args);
                    } finally {
                  //回调afterPrototypeCreation方法，默认的功能告诉IoC容器指//定Bean的原型对象不再创建了
                        this.afterPrototypeCreation(beanName);
                    }
				//获取给定Bean的实例对象  
                    bean = this.getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
                } else {
           //要创建的Bean既不是单态模式，也不是原型模式，则根据Bean定义资源中  
           //配置的生命周期范围，选择实例化Bean的合适方法，这种在Web应用程序中  
           //比较常用，如：request、session、application等生命周期
                    String scopeName = mbd.getScope();
                    Scope scope = (Scope)this.scopes.get(scopeName);
                    //Bean定义资源中没有配置生命周期范围，则Bean定义不合法
                    if(scope == null) {
                        throw new IllegalStateException("No Scope registered for scope '" + scopeName + "'");
                    }

                    try {
                     //这里又使用了一个匿名内部类，获取一个指定生命周期范围的实例
                        Object scopedInstance = scope.get(beanName, new ObjectFactory<Object>() {
                            public Object getObject() throws BeansException {
                                AbstractBeanFactory.this.beforePrototypeCreation(beanName);

                                Object var1;
                                try {
                                    var1 = AbstractBeanFactory.this.createBean(beanName, mbd, args);
                                } finally {
                                    AbstractBeanFactory.this.afterPrototypeCreation(beanName);
                                }

                                return var1;
                            }
                        });
                         //获取给定Bean的实例对象  
                        bean = this.getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
                    } catch (IllegalStateException var21) {
                        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", var21);
                    }
                }
            } catch (BeansException var23) {
                this.cleanupAfterBeanCreationFailure(beanName);
                throw var23;
            }
        }
 //对创建的Bean实例对象进行类型检查  
        if(requiredType != null && bean != null && !requiredType.isAssignableFrom(bean.getClass())) {
            try {
                return this.getTypeConverter().convertIfNecessary(bean, requiredType);
            } catch (TypeMismatchException var22) {
                if(this.logger.isDebugEnabled()) {
                    this.logger.debug("Failed to convert bean '" + name + "' to required type [" + ClassUtils.getQualifiedName(requiredType) + "]", var22);
                }

                throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
            }
        } else {
            return bean;
        }
    }
}

我们可以很清晰看到，创建bean的时候所做的判断：

（1）如果Bean定义的单态模式(Singleton)，则容器在创建之前先从缓存中查找，以确保整个容器中只存在一个实例对象

（2） 如果Bean定义的是原型模式(Prototype)，则容器每次都会创建一个新的实例对象。

（3）两者都不是，则根据Bean定义资源中配置的生命周期范围，选择实例化Bean的合适方法，这种在Web应用程序中 比较常用，如：request、session、application等生命周期。

上面的源码只是定义了根据Bean定义的模式，采取的不同创建Bean实例对象的策略，具体的Bean实例对象的创建过程由实现了ObejctFactory接口的匿名内部类的createBean方法完成，ObejctFactory使用委派模式，具体的Bean实例创建过程交由其实现类AbstractAutowireCapableBeanFactory完成，我们继续分析AbstractAutowireCapableBeanFactory的createBean方法的源码，理解其创建Bean实例的具体实现过程

2.因此我们根据上面所述继续追踪，现追踪AbstractBeanFactory的一个匿名内部类的createBean方法

实际上这方法的实现就是在我们从DefaultListableBeanFactory追踪父类过来的途中遇到的AbstractAutowireCapableBeanFactory类，是AbstractBeanFactory子类。

//创建Bean实 例对象  
protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) throws BeanCreationException {
        if(this.logger.isDebugEnabled()) {
            this.logger.debug("Creating instance of bean '" + beanName + "'");
        }
//判断需要创建的Bean是否可以实例化，即是否可以通过当前的类加载器加载  
        this.resolveBeanClass(mbd, beanName, new Class[0]);
//校验和准备Bean中的方法覆盖 
        try {
            mbd.prepareMethodOverrides();
        } catch (BeanDefinitionValidationException var5) {
            throw new BeanDefinitionStoreException(mbd.getResourceDescription(), beanName, "Validation of method overrides failed", var5);
        }

        Object beanInstance;
        try {
        //如果Bean配置了初始化前和初始化后的处理器，则试图返回一个需要创建
        //Bean的代理对象
            beanInstance = this.resolveBeforeInstantiation(beanName, mbd);
            if(beanInstance != null) {
                return beanInstance;
            }
        } catch (Throwable var6) {
            throw new BeanCreationException(mbd.getResourceDescription(), beanName, "BeanPostProcessor before instantiation of bean failed", var6);
        }
//真正创建Bean的入口  
        beanInstance = this.doCreateBean(beanName, mbd, args);
        if(this.logger.isDebugEnabled()) {
            this.logger.debug("Finished creating instance of bean '" + beanName + "'");
        }

        return beanInstance;
    }

//真正创建bean的方法
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, Object[] args) {
//封装被创建的Bean对象  
        BeanWrapper instanceWrapper = null;
        if(mbd.isSingleton()) {//单态模式的Bean，先从容器中缓存中获取同名Bean
            instanceWrapper = (BeanWrapper)this.factoryBeanInstanceCache.remove(beanName);
        }
		//容器没有的话
        if(instanceWrapper == null) {
         //创建实例对象  
            instanceWrapper = this.createBeanInstance(beanName, mbd, args);
        }

        final Object bean = instanceWrapper != null?instanceWrapper.getWrappedInstance():null;
        //获取实例化对象的类型  
        Class<?> beanType = instanceWrapper != null?instanceWrapper.getWrappedClass():null;
        Object var7 = mbd.postProcessingLock;
        //调用PostProcessor后置处理器  
        synchronized(mbd.postProcessingLock) {
            if(!mbd.postProcessed) {
                this.applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
                mbd.postProcessed = true;
            }
        }
 //向容器中缓存单态模式的Bean对象，以防循环引用  
        boolean earlySingletonExposure = mbd.isSingleton() && this.allowCircularReferences && this.isSingletonCurrentlyInCreation(beanName);
        if(earlySingletonExposure) {
            if(this.logger.isDebugEnabled()) {
                this.logger.debug("Eagerly caching bean '" + beanName + "' to allow for resolving potential circular references");
            }
 //这里是一个匿名内部类，为了防止循环引用，尽早持有对象的引用  
            this.addSingletonFactory(beanName, new ObjectFactory<Object>() {
                public Object getObject() throws BeansException {
                    return AbstractAutowireCapableBeanFactory.this.getEarlyBeanReference(beanName, mbd, bean);
                }
            });
        }
		 //Bean对象的初始化，依赖注入在此触发  
       //这个exposedObject在初始化完成之后返回作为依赖注入完成后的Bean 
        Object exposedObject = bean;
        try {
        //将Bean实例对象封装，并且Bean定义中配置的属性值赋值给实例对象
            this.populateBean(beanName, mbd, instanceWrapper);
            if(exposedObject != null) {
            //初始化Bean对象  
                exposedObject = this.initializeBean(beanName, exposedObject, mbd);
            }
        } catch (Throwable var17) {
            if(var17 instanceof BeanCreationException && beanName.equals(((BeanCreationException)var17).getBeanName())) {
                throw (BeanCreationException)var17;
            }

            throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Initialization of bean failed", var17);
        }

        if(earlySingletonExposure) {
         //获取指定名称的已注册的单态模式Bean对象  
            Object earlySingletonReference = this.getSingleton(beanName, false);
            if(earlySingletonReference != null) {
             //根据名称获取的以注册的Bean和正在实例化的Bean是同一个  
                if(exposedObject == bean) {
                //当前实例化的Bean初始化完成  
                    exposedObject = earlySingletonReference;
                } else if(!this.allowRawInjectionDespiteWrapping && this.hasDependentBean(beanName)) {//当前Bean依赖其他Bean，并且当发生循环引用时不允许新创建实例对象 
                    String[] dependentBeans = this.getDependentBeans(beanName);
                    Set<String> actualDependentBeans = new LinkedHashSet(dependentBeans.length);
                    String[] var12 = dependentBeans;//用来暂存当前bean
                    int var13 = dependentBeans.length;
			//获取当前Bean所依赖的其他Bean 
                    for(int var14 = 0; var14 < var13; ++var14) {
                        String dependentBean = var12[var14];
                        //对依赖Bean进行类型检查  
                        if(!this.removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
                            actualDependentBeans.add(dependentBean);
                        }
                    }

                    if(!actualDependentBeans.isEmpty()) {
                        throw new BeanCurrentlyInCreationException(beanName, "Bean with name '" + beanName + "' has been injected into other beans [" + StringUtils.collectionToCommaDelimitedString(actualDependentBeans) + "] in its raw version as part of a circular reference, but has eventually been " + "wrapped. This means that said other beans do not use the final version of the " + "bean. This is often the result of over-eager type matching - consider using " + "'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
                    }
                }
            }
        }
		//注册完成依赖注入的Bean  
        try {
            this.registerDisposableBeanIfNecessary(beanName, bean, mbd);
            return exposedObject;
        } catch (BeanDefinitionValidationException var16) {
            throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", var16);
        }
    }

上面还是一堆校验以及状态判断。

其中真正实现是分发到：

createBeanInstance：生成Bean所包含的Java对象实例。
populateBean ：对Bean属性的依赖注入进行处理。

3.那么我们来看下createBeanInstance方法的代码，还是在AbstractAutowireCapableBeanFactory类中。

在此方法中，根据指定的初始化策略，使用静态工厂、工厂方法或者容器的自动装配特性生成java实例对象。

//创建Bean的实例对象  
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) {
  //检查确认Bean是可实例化的  
        Class<?> beanClass = this.resolveBeanClass(mbd, beanName, new Class[0]);
        //使用工厂方法对Bean进行实例化  
        if(beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
            throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
        } else if(mbd.getFactoryMethodName() != null) {
        //调用工厂方法实例化  
            return this.instantiateUsingFactoryMethod(beanName, mbd, args);
        } else { //使用容器的自动装配方法进行实例化 
            boolean resolved = false;
            boolean autowireNecessary = false;
            if(args == null) {
                Object var7 = mbd.constructorArgumentLock;
                synchronized(mbd.constructorArgumentLock) {
                    if(mbd.resolvedConstructorOrFactoryMethod != null) {
                        resolved = true;
                        //决定是否使用自动装配的构造器
                        autowireNecessary = mbd.constructorArgumentsResolved;
                    }
                }
            }
		//autowireConstructor构造器方法配置了自动装配属性，使用容器的自动装配实例化，容器的自动装配是根据参数类型匹配Bean的构造方法
            if(resolved) {
               //根据标记位autowireNecessary而决定采用无参构造器还是自动装配构造器
                return autowireNecessary?this.autowireConstructor(beanName, mbd, (Constructor[])null, (Object[])null):this.instantiateBean(beanName, mbd);
            } else {
               //使用Bean的构造方法进行实例化
                Constructor<?>[] ctors = this.determineConstructorsFromBeanPostProcessors(beanClass, beanName);
               //根据是否有参数还是已经配置了自动装配模式，去选择构造器，无参构造器还是自动装配构造器。
                return ctors == null && mbd.getResolvedAutowireMode() != 3 && !mbd.hasConstructorArgumentValues() && ObjectUtils.isEmpty(args)?this.instantiateBean(beanName, mbd):this.autowireConstructor(beanName, mbd, ctors, args);
            }
        }
    }

上面看到一个无参构造器：instantiateBean

 //使用默认的无参构造方法实例化Bean对象  
protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd) {
        try {
            Object beanInstance;
            //获取系统的安全管理接口，JDK标准的安全管理API  
            if(System.getSecurityManager() != null) {
             //这里是一个匿名内置类，根据实例化策略创建实例对象 
                beanInstance = AccessController.doPrivileged(new PrivilegedAction<Object>() {
                    public Object run() {
                        return AbstractAutowireCapableBeanFactory.this.getInstantiationStrategy().instantiate(mbd, beanName, AbstractAutowireCapableBeanFactory.this);
                    }
                }, this.getAccessControlContext());
            } else {
            //将实例化的对象封装起来
                beanInstance = this.getInstantiationStrategy().instantiate(mbd, beanName, this);
            }

            BeanWrapper bw = new BeanWrapperImpl(beanInstance);
            this.initBeanWrapper(bw);
            return bw;
        } catch (Throwable var6) {
            throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Instantiation of bean failed", var6);
        }
    }

4.我们都看到了，无论什么调用什么构造器，返回的都是统一的BeanWrapper

BeanWrapper是什么贵？org.springframework.beans.BeanWrapper是Spring框架中重要的组件类。BeanWrapper相当于一个代理器，Spring通过BeanWrapper完成Bean属性的填充工作。在Bean实例被InstantiationStrategy创建出来之后，容器主控程序将Bean实例通过BeanWrapper包装起来。

由于它是接口，必然有个实现类，实现依赖注入的具体实现。那就是BeanWrapperImpl，它的作用是：（1）Bean包裹器；（2）属性访问器；（3）属性编辑器注册表。

5.我们接着回到createBean，它还有个实现分发populateBean 方法：对Bean属性的依赖注入进行处理

过程是两部分：属性值解析和注入

//将Bean属性设置到生成的实例对象上 
protected void populateBean(String beanName, RootBeanDefinition mbd, BeanWrapper bw) {
	//获取容器在解析Bean定义资源时为BeanDefiniton中设置的属性值
        PropertyValues pvs = mbd.getPropertyValues();
        //实例对象为null 
        if(bw == null) {
         //属性值不为空  
            if(!((PropertyValues)pvs).isEmpty()) {
                throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
            }
        } else {
         //在设置属性之前调用Bean的PostProcessor后置处理器  
            boolean continueWithPropertyPopulation = true;
            if(!mbd.isSynthetic() && this.hasInstantiationAwareBeanPostProcessors()) {
                Iterator var6 = this.getBeanPostProcessors().iterator();

                while(var6.hasNext()) {
                    BeanPostProcessor bp = (BeanPostProcessor)var6.next();
                    if(bp instanceof InstantiationAwareBeanPostProcessor) {
                        InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor)bp;
                        if(!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
                            continueWithPropertyPopulation = false;
                            break;
                        }
                    }
                }
            }
		//依赖注入开始，首先处理autowire自动装配的注入  
            if(continueWithPropertyPopulation) {
                if(mbd.getResolvedAutowireMode() == 1 || mbd.getResolvedAutowireMode() == 2) {
                    MutablePropertyValues newPvs = new MutablePropertyValues((PropertyValues)pvs);
                     //对autowire自动装配的处理，根据Bean名称自动装配注入  
                    if(mbd.getResolvedAutowireMode() == 1) {
                        this.autowireByName(beanName, mbd, bw, newPvs);
                    }
					 //根据Bean类型自动装配注入 
                    if(mbd.getResolvedAutowireMode() == 2) {
                        this.autowireByType(beanName, mbd, bw, newPvs);
                    }

                    pvs = newPvs;
                }
			//检查容器是否持有用于处理单态模式Bean关闭时的后置处理器 
                boolean hasInstAwareBpps = this.hasInstantiationAwareBeanPostProcessors();
              //Bean实例对象没有依赖，即没有继承基类 
                boolean needsDepCheck = mbd.getDependencyCheck() != 0;
                if(hasInstAwareBpps || needsDepCheck) {
                //从实例对象中提取属性描述符  
                    PropertyDescriptor[] filteredPds = this.filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
                    if(hasInstAwareBpps) {
                        Iterator var9 = this.getBeanPostProcessors().iterator();

                        while(var9.hasNext()) {
                            BeanPostProcessor bp = (BeanPostProcessor)var9.next();
                            if(bp instanceof InstantiationAwareBeanPostProcessor) {
                                InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor)bp;
                                //使用BeanPostProcessor处理器处理属性值  
                                pvs = ibp.postProcessPropertyValues((PropertyValues)pvs, filteredPds, bw.getWrappedInstance(), beanName);
                                if(pvs == null) {
                                    return;
                                }
                            }
                        }
                    }

                    if(needsDepCheck) {
                    //为要设置的属性进行依赖检查  
                        this.checkDependencies(beanName, mbd, filteredPds, (PropertyValues)pvs);
                    }
                }
			  //对属性进行注入  ，解析并注入依赖属性的过程  就在这个方法里面
			  /*
			  属性转换也有两情况：
			  1.属性值类型不需要转换时，不需要解析属性值，直接准备进行依赖注入。
			  2.属性值需要进行类型转换时，如对其他对象的引用等，首先需要解析属性值，然后对解析后的属性值进行依赖注入。
			  */
                this.applyPropertyValues(beanName, mbd, bw, (PropertyValues)pvs);
            }
        }
    }

6.那么我们继续追踪applyPropertyValues方法

//解析并注入依赖属性的过程 
protected void applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs) {
        if(pvs != null && !pvs.isEmpty()) {
         //封装属性值
            MutablePropertyValues mpvs = null;
            if(System.getSecurityManager() != null && bw instanceof BeanWrapperImpl) {
             //设置安全上下文，JDK安全机制  
                ((BeanWrapperImpl)bw).setSecurityContext(this.getAccessControlContext());
            }

            List original;
            if(pvs instanceof MutablePropertyValues) {           
                mpvs = (MutablePropertyValues)pvs;
                 //属性值已经转换  
                if(mpvs.isConverted()) {
                    try {
                     //为实例化对象设置属性值 ，依赖注入真真正正地实现在此！！！！！
                        bw.setPropertyValues(mpvs);
                        return;
                    } catch (BeansException var18) {
                        throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Error setting property values", var18);
                    }
                }
			 //获取属性值对象的原始类型值  
                original = mpvs.getPropertyValueList();
            } else {
                original = Arrays.asList(pvs.getPropertyValues());
            }
			//获取用户自定义的类型转换  
            TypeConverter converter = this.getCustomTypeConverter();
            if(converter == null) {
                converter = bw;
            }
		//创建一个Bean定义属性值解析器，将Bean定义中的属性值解析为Bean实例对象  
       //的实际值
            BeanDefinitionValueResolver valueResolver = new BeanDefinitionValueResolver(this, beanName, mbd, (TypeConverter)converter);
             //为属性的解析值创建一个拷贝，将拷贝的数据注入到实例对象中  
            List<PropertyValue> deepCopy = new ArrayList(original.size());
            boolean resolveNecessary = false;
            Iterator var11 = original.iterator();//用迭代器去遍历

            while(true) {
                while(var11.hasNext()) {
                    PropertyValue pv = (PropertyValue)var11.next();
                     //属性值不需要转换  
                    if(pv.isConverted()) {
                        deepCopy.add(pv);
                    } else {//属性值需要转换 
                        String propertyName = pv.getName();
                        //原始的属性值，即转换之前的属性值  
                        Object originalValue = pv.getValue();
                          //转换属性值，例如将引用转换为IoC容器中实例化对象引用 ！！！！！ 对属性值的解析！！
                        Object resolvedValue = valueResolver.resolveValueIfNecessary(pv, originalValue);
                        //转换之后的属性值 
                        Object convertedValue = resolvedValue;
                         //属性值是否可以转换  
                        boolean convertible = bw.isWritableProperty(propertyName) && !PropertyAccessorUtils.isNestedOrIndexedProperty(propertyName);
                        if(convertible) {
                         //使用用户自定义的类型转换器转换属性值  
                            convertedValue = this.convertForProperty(resolvedValue, propertyName, bw, (TypeConverter)converter);
                        }
				//存储转换后的属性值，避免每次属性注入时的转换工作
                        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();
                }
				//进行属性依赖注入  ，依赖注入的真真正正实现依赖的注入方法在此！！！
                try {
                    bw.setPropertyValues(new MutablePropertyValues(deepCopy));
                    return;
                } catch (BeansException var19) {
                    throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Error setting property values", var19);
                }
            }
        }
    }

总结applyPropertyValues方法（完成属性转换）：

属性值类型不需要转换时，不需要解析属性值，直接准备进行依赖注入。
属性值需要进行类型转换时，如对其他对象的引用等，首先需要解析属性值，然后对解析后的属性值进行依赖注入。

而且我们看到调用了resolveValueIfNecessary方法对属性值的解析

---

7.追踪resolveValueIfNecessary，发现是在BeanDefinitionValueResolver类

当容器在对属性进行依赖注入时，如果发现属性值需要进行类型转换，
如属性值是容器中另一个Bean实例对象的引用，则容器首先需要根据属性值解析出所引用的对象，
然后才能将该引用对象注入到目标实例对象的属性上去，对属性进行解析的由resolveValueIfNecessary方法实现。

可知：创建与注入是个递归的过程

//解析属性值，对注入类型进行转换 
public Object resolveValueIfNecessary(Object argName, Object value) {
//对引用类型的属性进行解析
        if(value instanceof RuntimeBeanReference) {
            RuntimeBeanReference ref = (RuntimeBeanReference)value;
            //调用引用类型属性的解析方法  
            return this.resolveReference(argName, ref);
        } else if(value instanceof RuntimeBeanNameReference) { //对属性值是引用容器中另一个Bean名称的解析  
            String refName = ((RuntimeBeanNameReference)value).getBeanName();
            refName = String.valueOf(this.doEvaluate(refName));
             //从容器中获取指定名称的Bean 
            if(!this.beanFactory.containsBean(refName)) {
                throw new BeanDefinitionStoreException("Invalid bean name '" + refName + "' in bean reference for " + argName);
            } else {
                return refName;
            }
        } else if(value instanceof BeanDefinitionHolder) { //对Bean类型属性的解析，主要是Bean中的内部类  
            BeanDefinitionHolder bdHolder = (BeanDefinitionHolder)value;
            return this.resolveInnerBean(argName, bdHolder.getBeanName(), bdHolder.getBeanDefinition());
        } else if(value instanceof BeanDefinition) {
            BeanDefinition bd = (BeanDefinition)value;
            String innerBeanName = "(inner bean)#" + ObjectUtils.getIdentityHexString(bd);
            return this.resolveInnerBean(argName, innerBeanName, bd);
        } else if(value instanceof ManagedArray) {//对集合数组类型的属性解析 
            ManagedArray array = (ManagedArray)value;
              //获取数组的类型  
            Class<?> elementType = array.resolvedElementType;
            if(elementType == null) {
            //获取数组元素的类型  
                String elementTypeName = array.getElementTypeName();
                if(StringUtils.hasText(elementTypeName)) {
                    try {
                    //使用反射机制创建指定类型的对象  
                        elementType = ClassUtils.forName(elementTypeName, this.beanFactory.getBeanClassLoader());
                        array.resolvedElementType = elementType;
                    } catch (Throwable var9) {
                        throw new BeanCreationException(this.beanDefinition.getResourceDescription(), this.beanName, "Error resolving array type for " + argName, var9);
                    }
                } else {
                //没有获取到数组的类型，也没有获取到数组元素的类型，则直接设置数  
               //组的类型为Object 
                    elementType = Object.class;
                }
            }
			 //创建指定类型的数组  
            return this.resolveManagedArray(argName, (List)value, elementType);
        } else if(value instanceof ManagedList) {//解析list类型的属性值  
            return this.resolveManagedList(argName, (List)value);
        } else if(value instanceof ManagedSet) { //解析set类型的属性值 
            return this.resolveManagedSet(argName, (Set)value);
        } else if(value instanceof ManagedMap) { //解析map类型的属性值 
            return this.resolveManagedMap(argName, (Map)value);
        } else if(value instanceof ManagedProperties) { //解析props类型的属性值，props其实就是key和value均为字符串的map  
            Properties original = (Properties)value;
            //创建一个拷贝，用于作为解析后的返回值  
            Properties copy = new Properties();

            Object propKey;
            Object propValue;
            for(Iterator var19 = original.entrySet().iterator(); var19.hasNext(); copy.put(propKey, propValue)) {
                Entry<Object, Object> propEntry = (Entry)var19.next();
                propKey = propEntry.getKey();
                propValue = propEntry.getValue();
                if(propKey instanceof TypedStringValue) {
                    propKey = this.evaluate((TypedStringValue)propKey);
                }

                if(propValue instanceof TypedStringValue) {
                    propValue = this.evaluate((TypedStringValue)propValue);
                }
            }

            return copy;
        } else if(value instanceof TypedStringValue) {//解析字符串类型的属性值  
            TypedStringValue typedStringValue = (TypedStringValue)value;
            Object valueObject = this.evaluate(typedStringValue);

            try {
            //获取属性的目标类型  
                Class<?> resolvedTargetType = this.resolveTargetType(typedStringValue);
                 //对目标类型的属性进行解析，递归调用 。没有获取到属性的目标对象，则按Object类型返回  
                return resolvedTargetType != null?this.typeConverter.convertIfNecessary(valueObject, resolvedTargetType):valueObject;
            } catch (Throwable var10) {
                throw new BeanCreationException(this.beanDefinition.getResourceDescription(), this.beanName, "Error converting typed String value for " + argName, var10);
            }
        } else {
            return this.evaluate(value);
        }
    }

刚也说了解析引用类型是特殊的：resolveReference方法

   //解析引用类型的属性值  
private Object resolveReference(Object argName, RuntimeBeanReference ref) {
        try {
          //获取引用的Bean名称  
            String refName = ref.getBeanName();
            refName = String.valueOf(this.doEvaluate(refName));
            //如果引用的对象在父类容器中，则从父类容器中获取指定的引用对象  
            if(ref.isToParent()) {
                if(this.beanFactory.getParentBeanFactory() == null) {
                    throw new BeanCreationException(this.beanDefinition.getResourceDescription(), this.beanName, "Can't resolve reference to bean '" + refName + "' in parent factory: no parent factory available");
                } else {
                    return this.beanFactory.getParentBeanFactory().getBean(refName);
                }
            } else {
             //从当前的容器中获取指定的引用Bean对象，如果指定的Bean没有被实例化  
           //则会递归触发引用Bean的初始化和依赖注入  
                Object bean = this.beanFactory.getBean(refName);
                //将当前实例化对象的依赖引用对象  
                this.beanFactory.registerDependentBean(refName, this.beanName);
                return bean;
            }
        } catch (BeansException var5) {
            throw new BeanCreationException(this.beanDefinition.getResourceDescription(), this.beanName, "Cannot resolve reference to bean '" + ref.getBeanName() + "' while setting " + argName, var5);
        }
    }

8.并且我们注意到applyPropertyValues方法（刚刚的AbstractAutowireCapableBeanFactory类）中，分发了一个方法实现对属性值的依赖注入setPropertyValues

前面也说到BeanWrapper接口的实现类就是BeanWrapperImpl。一系列的依赖注入都在这个里面，那么我们往上查找PropertyAccessor接口，并且发现路过的抽象类AbstractPropertyAccessor，终于找到了setPropertyValues方法的实现，有个模板模式，就是调用在AbstractPropertyAccessor中的抽象方法setPropertyValue（此方法在BeanWrapperImpl实现了！！）

//实现属性依赖注入功能
private void setPropertyValue(BeanWrapperImpl.PropertyTokenHolder tokens, PropertyValue pv) throws BeansException {
 //PropertyTokenHolder主要保存属性的名称、路径，以及集合的size等信息
        String propertyName = tokens.canonicalName;
        String actualName = tokens.actualName;
        Object propValue;
        //keys是用来保存集合类型属性的size  
        if(tokens.keys != null) {
         //将属性信息拷贝
            BeanWrapperImpl.PropertyTokenHolder getterTokens = new BeanWrapperImpl.PropertyTokenHolder(null);
            getterTokens.canonicalName = tokens.canonicalName;
            getterTokens.actualName = tokens.actualName;
            getterTokens.keys = new String[tokens.keys.length - 1];
            System.arraycopy(tokens.keys, 0, getterTokens.keys, 0, tokens.keys.length - 1);

            try {
             //获取属性值，该方法内部使用JDK的内省( Introspector)机制，调用属性//的getter(readerMethod)方法，获取属性的值  
                propValue = this.getPropertyValue(getterTokens);
            } catch (NotReadablePropertyException var21) {
                throw new NotWritablePropertyException(this.getRootClass(), this.nestedPath + propertyName, "Cannot access indexed value in property referenced in indexed property path '" + propertyName + "'", var21);
            }
			//获取集合类型属性的长度  
            String key = tokens.keys[tokens.keys.length - 1];
            if(propValue == null) {
                if(!this.isAutoGrowNestedPaths()) {
                    throw new NullValueInNestedPathException(this.getRootClass(), this.nestedPath + propertyName, "Cannot access indexed value in property referenced in indexed property path '" + propertyName + "': returned null");
                }

                int lastKeyIndex = tokens.canonicalName.lastIndexOf(91);
                getterTokens.canonicalName = tokens.canonicalName.substring(0, lastKeyIndex);
                propValue = this.setDefaultValue(getterTokens);
            }

            Object convertedValue;
            Object newArray;
            Class requiredType;
            PropertyDescriptor pd;
            //注入array类型的属性值 
            if(propValue.getClass().isArray()) {
            //获取属性的描述符  
                pd = this.getCachedIntrospectionResults().getPropertyDescriptor(actualName);
                 //获取数组的类型 
                requiredType = propValue.getClass().getComponentType();
                //获取数组的长度  
                int arrayIndex = Integer.parseInt(key);
                Object oldValue = null;

                try {
                //获取数组以前初始化的值  
                    if(this.isExtractOldValueForEditor() && arrayIndex < Array.getLength(propValue)) {
                        oldValue = Array.get(propValue, arrayIndex);
                    }
				//将属性的值赋值给数组中的元素
                    convertedValue = this.convertIfNecessary(propertyName, oldValue, pv.getValue(), requiredType, TypeDescriptor.nested(this.property(pd), tokens.keys.length));
                    int length = Array.getLength(propValue);
                    if(arrayIndex >= length && arrayIndex < this.autoGrowCollectionLimit) {
                        Class<?> componentType = propValue.getClass().getComponentType();
                        newArray = Array.newInstance(componentType, arrayIndex + 1);
                        System.arraycopy(propValue, 0, newArray, 0, length);
                        this.setPropertyValue(actualName, newArray);
                        propValue = this.getPropertyValue(actualName);
                    }

                    Array.set(propValue, arrayIndex, convertedValue);
                } catch (IndexOutOfBoundsException var20) {
                    throw new InvalidPropertyException(this.getRootClass(), this.nestedPath + propertyName, "Invalid array index in property path '" + propertyName + "'", var20);
                }
            } else {
                Object convertedValue;
                if(propValue instanceof List) {//注入list类型的属性值
                    pd = this.getCachedIntrospectionResults().getPropertyDescriptor(actualName);
                     //获取list集合的类型 
                    requiredType = GenericCollectionTypeResolver.getCollectionReturnType(pd.getReadMethod(), tokens.keys.length);
                    List<Object> list = (List)propValue;
                    //获取list集合的size
                    int index = Integer.parseInt(key);
                    convertedValue = null;
                    if(this.isExtractOldValueForEditor() && index < list.size()) {
                        convertedValue = list.get(index);
                    }
					 //获取list解析后的属性值  
                    convertedValue = this.convertIfNecessary(propertyName, convertedValue, pv.getValue(), requiredType, TypeDescriptor.nested(this.property(pd), tokens.keys.length));
                    int size = list.size();
                     //如果list的长度大于属性值的长度，则多余的元素赋值为null  
                    if(index >= size && index < this.autoGrowCollectionLimit) {
                        for(int i = size; i < index; ++i) {
                            try {//如果list的长度大于属性值的长度，则多余的元素赋值为null  
                                list.add((Object)null);
                            } catch (NullPointerException var19) {
                                throw new InvalidPropertyException(this.getRootClass(), this.nestedPath + propertyName, "Cannot set element with index " + index + " in List of size " + size + ", accessed using property path '" + propertyName + "': List does not support filling up gaps with null elements");
                            }
                        }

                        list.add(convertedValue);
                    } else {  //如果list的长度小于属性值的长度，为list属性赋值  
                        try {
                            list.set(index, convertedValue);
                        } catch (IndexOutOfBoundsException var18) {
                            throw new InvalidPropertyException(this.getRootClass(), this.nestedPath + propertyName, "Invalid list index in property path '" + propertyName + "'", var18);
                        }
                    }
                } else {  //注入map类型的属性值  
                    if(!(propValue instanceof Map)) {
                        throw new InvalidPropertyException(this.getRootClass(), this.nestedPath + propertyName, "Property referenced in indexed property path '" + propertyName + "' is neither an array nor a List nor a Map; returned value was [" + propValue + "]");
                    }

                    pd = this.getCachedIntrospectionResults().getPropertyDescriptor(actualName);
                  //获取map集合key的类型 
                    requiredType = GenericCollectionTypeResolver.getMapKeyReturnType(pd.getReadMethod(), tokens.keys.length);
                      //获取map集合value的类型
                    Class<?> mapValueType = GenericCollectionTypeResolver.getMapValueReturnType(pd.getReadMethod(), tokens.keys.length);
                    Map<Object, Object> map = (Map)propValue;//强转
                     //解析map类型属性key值  
                    TypeDescriptor typeDescriptor = TypeDescriptor.valueOf(requiredType);
                      //解析map类型属性value值 
                    convertedValue = this.convertIfNecessary((String)null, (Object)null, key, requiredType, typeDescriptor);
                    Object oldValue = null;
                    if(this.isExtractOldValueForEditor()) {
                        oldValue = map.get(convertedValue);
                    }

                    newArray = this.convertIfNecessary(propertyName, oldValue, pv.getValue(), mapValueType, TypeDescriptor.nested(this.property(pd), tokens.keys.length));
                    //将解析后的key和value值赋值给map集合属性
                    map.put(convertedValue, newArray);
                }
            }
        } else { //对非集合类型的属性注入 
            PropertyDescriptor pd = pv.resolvedDescriptor;
            if(pd == null || !pd.getWriteMethod().getDeclaringClass().isInstance(this.object)) {
                pd = this.getCachedIntrospectionResults().getPropertyDescriptor(actualName);
                 //无法获取到属性名或者属性没有提供setter(写方法)方法 
                if(pd == null || pd.getWriteMethod() == null) {
                 //如果属性值是可选的，即不是必须的，则忽略该属性值  
                    if(pv.isOptional()) {
                        logger.debug("Ignoring optional value for property '" + actualName + "' - property not found on bean class [" + this.getRootClass().getName() + "]");
                        return;
                    }
      //如果属性值是必须的，则抛出无法给属性赋值，因为每天提供setter方法异常  
                    PropertyMatches matches = PropertyMatches.forProperty(propertyName, this.getRootClass());
                    throw new NotWritablePropertyException(this.getRootClass(), this.nestedPath + propertyName, matches.buildErrorMessage(), matches.getPossibleMatches());
                }

                pv.getOriginalPropertyValue().resolvedDescriptor = pd;
            }

            propValue = null;

            PropertyChangeEvent propertyChangeEvent;
            try {
                Object originalValue = pv.getValue();//拿到初始值
                Object valueToApply = originalValue;
                final Method readMethod;
                if(!Boolean.FALSE.equals(pv.conversionNecessary)) {
                    if(pv.isConverted()) {
                        valueToApply = pv.getConvertedValue();
                    } else {
                        if(this.isExtractOldValueForEditor() && pd.getReadMethod() != null) {
                          //获取属性的getter方法(读方法)，JDK内省机制
                            readMethod = pd.getReadMethod();
                            //如果属性的getter方法不是public访问控制权限的，即访问控制权限比较严格，  
                           //则使用JDK的反射机制强行访问非public的方法(暴力读取属性值)
                          if(!Modifier.isPublic(readMethod.getDeclaringClass().getModifiers()) && !readMethod.isAccessible()) {
                                if(System.getSecurityManager() != null) {
                                //匿名内部类，根据权限修改属性的读取控制限制  
                                    AccessController.doPrivileged(new PrivilegedAction<Object>() {
                                        public Object run() {
                                            readMethod.setAccessible(true);
                                            return null;
                                        }
                                    });
                                } else {
                                    readMethod.setAccessible(true);
                                }
                            }

                            try {
                            //属性没有提供getter方法时，调用潜在的读取属性值//的方法，获取属性值  
                                if(System.getSecurityManager() != null) {
                                    propValue = AccessController.doPrivileged(new PrivilegedExceptionAction<Object>() {
                                        public Object run() throws Exception {
                                            return readMethod.invoke(BeanWrapperImpl.this.object, new Object[0]);
                                        }
                                    }, this.acc);
                                } else {
                                    propValue = readMethod.invoke(this.object, new Object[0]);
                                }
                            } catch (Exception var22) {
                                Exception ex = var22;
                                if(var22 instanceof PrivilegedActionException) {
                                    ex = ((PrivilegedActionException)var22).getException();
                                }

                                if(logger.isDebugEnabled()) {
                                    logger.debug("Could not read previous value of property '" + this.nestedPath + propertyName + "'", ex);
                                }
                            }
                        }
				 //设置属性的注入值  
                        valueToApply = this.convertForProperty(propertyName, propValue, originalValue, new TypeDescriptor(this.property(pd)));
                    }

                    pv.getOriginalPropertyValue().conversionNecessary = Boolean.valueOf(valueToApply != originalValue);
                }
			 //根据JDK的内省机制，获取属性的setter(写方法)方法 
                readMethod = pd instanceof GenericTypeAwarePropertyDescriptor?((GenericTypeAwarePropertyDescriptor)pd).getWriteMethodForActualAccess():pd.getWriteMethod();
                //如果属性的setter方法是非public，即访问控制权限比较严格，则使用JDK的反射机制，  
               //强行设置setter方法可访问(暴力为属性赋值) 
                if(!Modifier.isPublic(readMethod.getDeclaringClass().getModifiers()) && !readMethod.isAccessible()) {
                  //如果使用了JDK的安全机制，则需要权限验证  
                    if(System.getSecurityManager() != null) {
                        AccessController.doPrivileged(new PrivilegedAction<Object>() {
                            public Object run() {
                                readMethod.setAccessible(true);
                                return null;
                            }
                        });
                    } else {
                        readMethod.setAccessible(true);
                    }
                }

                final Object value = valueToApply;
                if(System.getSecurityManager() != null) {
                    try {
                     //将属性值设置到属性上去  
                        AccessController.doPrivileged(new PrivilegedExceptionAction<Object>() {
                            public Object run() throws Exception {
                                readMethod.invoke(BeanWrapperImpl.this.object, new Object[]{value});
                                return null;
                            }
                        }, this.acc);
                    } catch (PrivilegedActionException var17) {
                        throw var17.getException();
                    }
                } else {
                    readMethod.invoke(this.object, new Object[]{valueToApply});
                }
            } catch (TypeMismatchException var23) {
                throw var23;
            } catch (InvocationTargetException var24) {
                propertyChangeEvent = new PropertyChangeEvent(this.rootObject, this.nestedPath + propertyName, propValue, pv.getValue());
                if(var24.getTargetException() instanceof ClassCastException) {
                    throw new TypeMismatchException(propertyChangeEvent, pd.getPropertyType(), var24.getTargetException());
                }

                throw new MethodInvocationException(propertyChangeEvent, var24.getTargetException());
            } catch (Exception var25) {
                propertyChangeEvent = new PropertyChangeEvent(this.rootObject, this.nestedPath + propertyName, propValue, pv.getValue());
                throw new MethodInvocationException(propertyChangeEvent, var25);
            }
        }

    }

很复杂的一个解析方法：将属性的值注入到Bean实例对象中情况如下：

1. 对于集合类型的属性，将其属性值解析为目标类型的集合后直接赋值给属性

2. 对于非集合类型的属性，大量使用了JDK的反射和内省机制，通过属性的getter方法(reader method)获取指定属性注入以前的值，同时调用属性的setter方法(writer method)为属性设置注入后的值。

---

依赖注入总结：

（一）DefaultListableBeanFactory父类AbstractBeanFactory根据Bean的状态定义（单例、存在、原型）进行构造方法分发。分发到AbstractAutowireCapableBeanFactory类的createBean方法

（二）createBean方法负责Bean实例要求状态判断以及再度分发到doCreateBean实现创建实例（再次配置判断）。并在doCreateBean再度分发去createBeanInstance去Bean所包含的Java对象实例以及去populateBean 方法对Bean属性的依赖注入进行处理（以此为责任分发中心）。

（三）在createBeanInstance方法中真正地根据之前的配置判断设置选择真正合适的构造器（自动装配、无参构造器）；

（四）在populateBean 方法中真正地将Bean属性设置到生成的实例对象上 ，但在过程中注入依赖属性的是在applyPropertyValues方法（完成属性转换），调用BeanDefinitionValueResolver类调用resolveValueIfNecessary方法对属性值的解析，属性的真正注入实现在BeanWrapperImpl类。

---

好了，Spring应用、原理以及粗读源码系列（一）–框架总述、以Bean为核心的机制（IoC容器初始化以及依赖注入）讲完了

这个系列以应用为基本点，结合源码讲解那堆应用的机制原理，我会加快脚步学习，分享经验给大家，希望大家喜欢。欢迎在下面指出错误，共同学习！！你的点赞是对我最好的支持！！

更多内容，可以访问JackFrost的博客