https://www.cnblogs.com/solverpeng/p/5689360.html

https://www.cnblogs.com/IvySue/p/6484599.html

一、Spring 官方文档中给出的 Spring 的整体结构。

二、我自己所理解的 Spring 整体结构图。

三、本次总结 Spring 核心部分

1.从上面图中可以看出，Beans 和 Context 和 Core 组件作为 Spring 的核心组件，它们构成了整个 Spring 的骨架。

2.从根本说来说，Spring 最终操纵的还是 Bean，所以说 Bean 是整个 Spring 核心中的核心。

3.和正常编程的思想不同，Spring 把对象之间的依赖关系转而由配置文件进行管理，也就是他的依赖注入机制。而这个注入关系在一个 IOC 容器中进行管理。

IOC 容器中包含有什么？其实就是被一个个 bean 包含的对象。IOC 容器可以看成是 beans 关系的一个集合。

4.这种设计策略完全类似于 Java 实现的 OOP 设计理念，构建一个数据结构，然后根据这个数据结构设计它的生存环境，并赋给它生命周期，使他在一定规律下不停的运动，在不停运动的过程中完成与其他个体的交互。

5.核心组件之间如何进行协同工作的：举一个非常好的例子，如果说 Bean 是一场话剧的演员的话，那么 Context 就是舞台，而 Core 就是道具，它们三个是演话剧最基本的元素。

我们知道 Bean 包装的是一个 Object，而 Object 中存在数据，而给这些数据提供生存环境就是 Context 要解决的问题，对于 Context 而言，它要发现每个 Bean，以及 Bean 与Bean 之间的关系，建立和维护好这种关系。所以 Context 就是 Bean 关系的集合，这个关系集合又叫 IOC 容器，而一旦建立起这个容器，Spring就可以进行工作了。那么 Core 是用来做什么的呢？发现、建立和维护 Bean 之间的关系所需要的一系列的工具，它为 Bean 组件和 Context 组件提供了支持。

四、Bean 组件

1.Bean 组件位于 Spring 的 org.springframework.beans 包下。

而这个包下的所有类主要解决了三件事情：Bean 的定义、Bean 的创建以及对 Bean 的解析。对于使用者来说，我们只需要关注 Bean 的创建就 ok。其他两个由 Spring 完成。

2.Spring Bean 的创建是典型的工厂模式，他的顶级接口是 BeanFactory。

3.Bean 的定义主要由 BeanDefinition 描述，Bean 的定义就是描述了在 Spring Config 文件中 <bean> 节点及其子节点的所有信息。当 Spring 成功解析你定义的一个 <bean> 节点后，在 Spring 内部就会转化为 BeanDefinition 对象。以后所有的操作都是由这个对象来完成。

4.Bean 的解析主要就是对 Spring 配置文件的解析，顶级接口为 BeanDefinitionReader 和 BeanDefinitionDocumentReader。

五、Context 组件

1.Context 组件位于 Spring 的 org.springframework.context 包下，它的作用就是为 Bean 提供一个运行时环境，并且维护好 Bean 之间的关系。

2.BeanFactory 作为 Context 的顶级接口。

ApplicationContext 为 Context 组件的常用接口，它除了能标识一个应用环境的基本信息外，他还继承了6个接口，他们扩展了 Context 的功能。

从上图可以看出 ApplicationContext 接口继承了 BeanFactory 接口，由此也可以看出 Spring 运行的主体是 Bean。另外间接继承了 ResourceLoader 接口，也就可以访问到外部资源。然后再看它的两个子接口：

（1）ConfigurableApplicationContext 表示该 Context 是可以修改的，也就是说在构建 Context 时用户可以添加或修改已有的配置。

（2）WebApplicationContext 就是为 Web 环境准备的 Context，它可以访问到 ServletContext。

对于 ApplicationContext 来说，必须要完成的几件事情：

（1）标识一个应用环境

（2）利用 BeanFactory 创建 Bean 对象

（3）保存对象关系表

（4）能够捕获各种事件

Context 作为 Spring 的 IOC 容器，基本上整合了 Spring 的大部分功能，或者说是大部分功能的基础。

六、Core 组件

1.Core 组件作为 Spring 的核心组件，它其中包含了很多关键的类，其中一个重要的组成部分就是定义了资源的访问方式。将所有资源都抽象为一个接口 Resource。

Resource 类结构图：

从上图可以看到 Resource 类封装了各种可能的资源类型，继承了 InputStreamSource 接口，对使用者来说屏蔽了资源类型的不同。所有资源都可以通过 getInputStream() 获取到。

2.Context 与 Resource 之间的关系：Context 是把资源的加载、解析和描述工作委托给 ResourcePatternResolver 类来完成，他把资源的加载、解析和资源的定义整合到了一起便于

其他组件使用。

七、IOC 容器是如何进行工作的

1.IOC 容器实际上就是结合其他两个组件共建了一个 bean 关系网

2.如何创建 BeanFactory 工厂

3.如何创建 Bean 实例并构建 Bean 之间的关系网

4.如何对 Bean 进行扩展

八、上面内容是从宏观上对 Spring 核心的三个组件进行了介绍，其中大部分内容是借鉴的别人的，下面列出具体知识细节

源码分析

https://www.cnblogs.com/ITtangtang/p/3978349.html

1) BeanFactory

     Spring Bean的创建是典型的工厂模式，这一系列的Bean工厂，也即IOC容器为开发者管理对象间的依赖关系提供了很多便利和基础服务，在Spring中有许多的IOC容器的实现供用户选择和使用，其相互关系如下：

其中BeanFactory作为最顶层的一个接口类，它定义了IOC容器的基本功能规范，BeanFactory 有三个子类：ListableBeanFactory、HierarchicalBeanFactory 和AutowireCapableBeanFactory。但是从上图中我们可以发现最终的默认实现类是 DefaultListableBeanFactory，他实现了所有的接口。那为何要定义这么多层次的接口呢？查阅这些接口的源码和说明发现，每个接口都有他使用的场合，它主要是为了区分在 Spring 内部在操作过程中对象的传递和转化过程中，对对象的数据访问所做的限制。例如 ListableBeanFactory 接口表示这些 Bean 是可列表的，而 HierarchicalBeanFactory 表示的是这些 Bean 是有继承关系的，也就是每个Bean 有可能有父 Bean。AutowireCapableBeanFactory 接口定义 Bean 的自动装配规则。这四个接口共同定义了 Bean 的集合、Bean 之间的关系、以及 Bean 行为.

(2) BeanDefinition

     SpringIOC容器管理了我们定义的各种Bean对象及其相互的关系，Bean对象在Spring实现中是以BeanDefinition来描述的，其继承体系如下：

Bean 的解析过程非常复杂，功能被分的很细，因为这里需要被扩展的地方很多，必须保证有足够的灵活性，以应对可能的变化。Bean 的解析主要就是对 Spring 配置文件的解析。这个解析过程主要通过下图中的类完成：

AbstractBeanDefinitionReader的loadBeanDefinitions方法源码如下：

其次，真正执行加载功能是其子类XmlBeanDefinitionReader的loadBeanDefinitions方法。 通过源码分析，载入Bean定义资源文件的最后一步是将Bean定义资源转换为Document对象，该过程由documentLoader实现

Bean定义资源的载入解析分为以下两个过程：

首先，通过调用XML解析器将Bean定义资源文件转换得到Document对象，但是这些Document对象并没有按照Spring的Bean规则进行解析。这一步是载入的过程

其次，在完成通用的XML解析之后，按照Spring的Bean规则对Document对象进行解析。

按照Spring的Bean规则对Document对象解析的过程是在接口BeanDefinitionDocumentReader的实现类DefaultBeanDefinitionDocumentReader中实现的。

16、解析过后的BeanDefinition在IoC容器中的注册：

让我们继续跟踪程序的执行顺序，接下来会到我们第3步中分析DefaultBeanDefinitionDocumentReader对Bean定义转换的Document对象解析的流程中，在其parseDefaultElement方法中完成对Document对象的解析后得到封装BeanDefinition的BeanDefinitionHold对象，然后调用BeanDefinitionReaderUtils的registerBeanDefinition方法向IoC容器注册解析的Bean，BeanDefinitionReaderUtils的注册的源码如下：

四、IOC容器的依赖注入

1、依赖注入发生的时间

当Spring IoC容器完成了Bean定义资源的定位、载入和解析注册以后，IoC容器中已经管理类Bean定义的相关数据，但是此时IoC容器还没有对所管理的Bean进行依赖注入，依赖注入在以下两种情况发生：

(1).用户第一次通过getBean方法向IoC容索要Bean时，IoC容器触发依赖注入。

(2).当用户在Bean定义资源中为<Bean>元素配置了lazy-init属性，即让容器在解析注册Bean定义时进行预实例化，触发依赖注入。

BeanFactory接口定义了Spring IoC容器的基本功能规范，是Spring IoC容器所应遵守的最底层和最基本的编程规范。BeanFactory接口中定义了几个getBean方法，就是用户向IoC容器索取管理的Bean的方法，我们通过分析其子类的具体实现，理解Spring IoC容器在用户索取Bean时如何完成依赖注入。

AbstactBeanFactory的getBean，会进行

3、AbstractAutowireCapableBeanFactory创建Bean实例对象：

通过对方法源码的分析，我们看到具体的依赖注入实现在以下两个方法中：

(1).createBeanInstance：生成Bean所包含的java对象实例。

(2).populateBean ：对Bean属性的依赖注入进行处理。

下面继续分析这两个方法的代码实现。

4、createBeanInstance方法创建Bean的java实例对象：

在createBeanInstance方法中，根据指定的初始化策略，使用静态工厂、工厂方法或者容器的自动装配特性生成java实例对象，创建对象的源码如下：

经过对上面的代码分析，我们可以看出，对使用工厂方法和自动装配特性的Bean的实例化相当比较清楚，调用相应的工厂方法或者参数匹配的构造方法即可完成实例化对象的工作，但是对于我们最常使用的默认无参构造方法就需要使用相应的初始化策略(JDK的反射机制或者CGLIB)来进行初始化了，在方法getInstantiationStrategy().instantiate中就具体实现类使用初始策略实例化对象。

5、SimpleInstantiationStrategy类使用默认的无参构造方法创建Bean实例化对象：

在使用默认的无参构造方法创建Bean的实例化对象时，方法getInstantiationStrategy().instantiate调用了SimpleInstantiationStrategy类中的实例化Bean的方法，其源码如下：

 //使用BeanUtils实例化，通过反射机制调用”构造方法.newInstance(arg)”来进行实例化  
           return BeanUtils.instantiateClass(constructorToUse);  
       }  
       else {
           //使用CGLIB来实例化对象  
           return instantiateWithMethodInjection(beanDefinition, beanName, owner);

CGLIB是一个常用的字节码生成器的类库，它提供了一系列API实现java字节码的生成和转换功能。我们在学习JDK的动态代理时都知道，JDK的动态代理只能针对接口，如果一个类没有实现任何接口，要对其进行动态代理只能使用CGLIB。

CGLIB好像被移除了

五、IoC容器的高级特性

1、介绍

  通过前面4篇文章对Spring IoC容器的源码分析，我们已经基本上了解了Spring IoC容器对Bean定义资源的定位、读入和解析过程，同时也清楚了当用户通过getBean方法向IoC容器获取被管理的Bean时，IoC容器对Bean进行的初始化和依赖注入过程，这些是Spring IoC容器的基本功能特性。Spring IoC容器还有一些高级特性，如使用lazy-init属性对Bean预初始化、FactoryBean产生或者修饰Bean对象的生成、IoC容器初始化Bean过程中使用BeanPostProcessor后置处理器对Bean声明周期事件管理和IoC容器的autowiring自动装配功能等。

2、Spring IoC容器的lazy-init属性实现预实例化：

  通过前面我们对IoC容器的实现和工作原理分析，我们知道IoC容器的初始化过程就是对Bean定义资源的定位、载入和注册，此时容器对Bean的依赖注入并没有发生，依赖注入主要是在应用程序第一次向容器索取Bean时，通过getBean方法的调用完成。

当Bean定义资源的<Bean>元素中配置了lazy-init属性时，容器将会在初始化的时候对所配置的Bean进行预实例化，Bean的依赖注入在容器初始化的时候就已经完成。这样，当应用程序第一次向容器索取被管理的Bean时，就不用再初始化和对Bean进行依赖注入了，直接从容器中获取已经完成依赖注入的现成Bean，可以提高应用第一次向容器获取Bean的性能。

下面我们通过代码分析容器预实例化的实现过程：

(1).refresh()

先从IoC容器的初始会过程开始，通过前面文章分析，我们知道IoC容器读入已经定位的Bean定义资源是从refresh方法开始的，我们首先从AbstractApplicationContext类的refresh方法入手分析，源码如下在refresh方法中ConfigurableListableBeanFactorybeanFactory = obtainFreshBeanFactory();启动了Bean定义资源的载入、注册过程，而finishBeanFactoryInitialization方法是对注册后的Bean定义中的预实例化(lazy-init=false，Spring默认就是预实例化，即为true)的Bean进行处理的地方。

(2).finishBeanFactoryInitialization处理预实例化Bean：

当Bean定义资源被载入IoC容器之后，容器将Bean定义资源解析为容器内部的数据结构BeanDefinition注册到容器中，AbstractApplicationContext类中的finishBeanFactoryInitialization方法对配置了预实例化属性的Bean进行预初始化过程

(3)、DefaultListableBeanFactory对配置lazy-init属性单态Bean的预实例化：

通过对lazy-init处理源码的分析，我们可以看出，如果设置了lazy-init属性，则容器在完成Bean定义的注册之后，会通过getBean方法，触发对指定Bean的初始化和依赖注入过程，这样当应用第一次向容器索取所需的Bean时，容器不再需要对Bean进行初始化和依赖注入，直接从已经完成实例化和依赖注入的Bean中取一个线程的Bean，这样就提高了第一次获取Bean的性能。

3、FactoryBean的实现：

   在Spring中，有两个很容易混淆的类：BeanFactory和FactoryBean。 BeanFactory：Bean工厂，是一个工厂(Factory)，我们Spring IoC容器的最顶层接口就是这个BeanFactory，它的作用是管理Bean，即实例化、定位、配置应用程序中的对象及建立这些对象间的依赖。

FactoryBean：工厂Bean，是一个Bean，作用是产生其他bean实例。通常情况下，这种bean没有什么特别的要求，仅需要提供一个工厂方法，该方法用来返回其他bean实例。通常情况下，bean无须自己实现工厂模式，Spring容器担任工厂角色；但少数情况下，容器中的bean本身就是工厂，其作用是产生其它bean实例。

当用户使用容器本身时，可以使用转义字符”&”来得到FactoryBean本身，以区别通过FactoryBean产生的实例对象和FactoryBean对象本身。在BeanFactory中通过如下代码定义了该转义字符：StringFACTORY_BEAN_PREFIX = "&";如果myJndiObject是一个FactoryBean，则使用&myJndiObject得到的是myJndiObject对象，而不是myJndiObject产生出来的对象。

Spring IoC容器的autowiring属性自动依赖注入是一个很方便的特性，可以简化开发时的配置，但是凡是都有两面性，自动属性依赖注入也有不足，首先，Bean的依赖关系在配置文件中无法很清楚地看出来，对于维护造成一定困难。其次，由于自动依赖注入是Spring容器自动执行的，容器是不会智能判断的，如果配置不当，将会带来无法预料的后果，所以自动依赖注入特性在使用时还是综合考虑。