总述：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);
}
}
}
