Spring IOC与AOP源码分析，吊锤面试官 SO easy！

本文对Spring相关知识点做了归纳整理，包括 Spring 优势、其框架结构、核心思想，并对IoC思想及AOP思想进行手动实现，增强对Spring 核心思想的理解。之后对Spring IoC、AOP 的实现方式和特性进行介绍，并对照源码理解其实现思路。

Spring 优势

• 方便解耦，简化开发

  「[注：IoC(降低组件耦合性)、DI(降低业务对象替换的复杂性)]」

• AOP编程的思想

  「[注：通用任务集中管理，使得代码可更好的复用]」

• 声明式事务的支持

  「[注：@Transaction]」

• 轻量级框架，代码侵入性低，可自由选择框架部分组件

• 方便集成各种优秀框架

Spring 核心结构

img

• Spring核心容器（Core Container）：容器是Spring框架最核心的部分，管理Bean的创建(IoC)、配置(DI)和管理(Context)，所有的Spring模块都构建于核心容器之上.

• 面向切面编程（AOP）：Spring应用系统中开发切面的基础，代码解耦，增强复用。

• 数据访问与集成（Data Access）：Spring的JDBC和DAO模块封装大量样板代码，使得数据库代码变得简洁，也可避免数据库资源释放失败引发的问题。由JDBC、Transactions（AOP模块支持）、ORM、OXM 和 JMS等模块组成。

• Web：提供了SpringMVC框架给Web应⽤，还提供了多种构建和其它应⽤交互的远程调⽤⽅ 案。SpringMVC框架在Web层提升了应⽤的松耦合⽔平。

• Test 为了使得开发者能够很⽅便的进⾏测试，Spring提供了测试模块以致⼒于Spring应⽤的测试。通过该模块，Spring为使⽤Servlet、JNDI等编写单元测试提供了⼀系列的mock对象实现。

核心思想

IoC（Inversion of Control）控制反转

❝

IoC 是一个技术思想，而Spring对其进行了实现

❞

控制反转：对象创建(实例化、管理)的权利交给外部环境(Spring框架、IoC容器)

解决问题：解决对象间的耦合问题

img

IoC 和 DI 的区别

DI（Dependancy Injection）依赖注⼊

❝

IoC和DI描述的是同一件事情（对象实例化及依赖关系维护），只不过角度不一样罢了

IoC：站在对象的角度，对象实例化及其管理交给容器

DI：站在容器角度，容器会把对象依赖的其他对象注入

❞

AOP（Aspect oriented Programming）面向切面编程

OOP与AOP

❝

OOP是一种垂直继承体系（三大特征：封装、继承和多态)

「AOP为解决纵向重复问题，抽取横向逻辑代码，分离业务逻辑和横切逻辑，解耦合」

❞

AOP解决问题

「解决纵向重复问题，抽取横向逻辑代码，分离业务逻辑和横切逻辑，解耦合」

IoC和AOP的手动实现

IoC与DI实现

1. 定义beans.xml，其中定义：

   • 需要创建的对象的id和全限定类名 ⇒ 反射创建对象，id为标识

   • 属性名及依赖对象id ⇒ 通过对应类中的 Set方法 注入依赖属性

2. 定义BeanFactory，读取解析xml，通过反射实例化对象，统一管理，并提供外部获取对象的接口方法

AOP 事务管理

1. 将 Connection 与当前线程绑定，手动控制 JDBC 的 Connection 事务(关闭自动提交事务)

2. 创建代理工厂类，对代理类进行事务增强

3. 使用代理类对象替代对象进行方法的调用

Spring IoC 应用

IoC 实现方式及其对应启动方法

1. 纯 xml 实现（bean 信息定义全部配置在 xml 中）

   // JavaSE 应用启动
   ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
   // 或者读取绝对路径下的配置文件（不推荐）
   ApplicationContext applicationContext = new FileSystemXmlApplicationContext("c:/beans.xml");
   
   // JavaWeb 应用
   /**
    配置 ContextLoaderListener 类（web.xml）
    监听器机制加载 xml
   */
   

   
   
       Archetype Created Web Application
       
       
           contextConfigLocation
           classpath:applicationContext.xml
       
       
       
           org.springframework.web.context.ContextLoaderListener
       
   
   

2. xml + 注解（部分 bean 使用 xml 定义，部分 bean 使用注解定义）

   和纯 xml 实现一致

3. 纯注解 （所有 bean 都是用注解来定义）

   // JavaSE 应用启动
   ApplicationContext applicationContext = new AnnotationConfigApplicationContext(Spring.class);
   
   // JavaWeb 应用
   /**
    配置 ContextLoaderListener 类（web.xml）
    监听器机制加载 注解配置类
   */
   

   
   
       Archetype Created Web Application
       
       
           contextClass
           org.springframework.web.context.support.AnnotationConfigWebAppli cationContext
       
       
       
           contextConfigLocation
           com.lagou.edu.SpringConfig
       
       
       
           org.springframework.web.context.ContextLoaderListener
       
   
   

BeanFactory 与  ApplicationContext  区别

❝

BeanFactory是Spring框架中IoC容器的顶层接⼝,它只是⽤来定义⼀些基础功能,定义⼀些基础规范,⽽ApplicationContext是它的⼀个⼦接⼝，所以ApplicationContext是具备BeanFactory提供的全部功能的。

ApplicationContext是容器的⾼级接⼝，⽐ BeanFactory要拥有更多的功能，⽐如说国际化⽀持和资源访问（xml，java配置类）等等

❞

实例化Bean的三种方式

1. 使用无参构造器

2. 使用静态方法创建

3. 使用实例化方法创建

Bean 的作用范围及生命周期

• singleton（单例模式）

  ❝

  单例模式的 bean 对象生命周期与容器相同

  ❞

• prototype（多例模式）

  ❝

  多例模式的 bean 对象，Spring 框架只负责创建，不负责销毁

  ❞

Xml 模式下 Bean 标签的属性

• id：bean 的唯一标识

• class：创建 Bean 对象的全限定类名

• name：给 bean 提供一个或多个名称

• factory-bean：指定创建当前 bean 对象的工厂bean 的唯一标识（当指定此属性，class 属性失效）

• factory-method：指定创建当前对象的工厂方法

  • 「注：若配合 factory-bean 使用，class 属性失效，若配合 class 属性使用，方法必须是 static 修饰的」

• scope：bean 作用域，默认 singleton

• init-method：指定 bean 对象初始化方法，在 bean 装配后调用，必须是无参方法。

• destory-method：指定 bean 对象销毁方法，在 bean 销毁前执行，只在 scope 为 singleton 时起作用（因为多例模式下Spring框架只负责创建）

DI 依赖注入的 xml 配置

• 依赖注入分类

  • name：对应参数名

  • index：对应构造函数中指定索引

  • value：指定基本类型或 String 类型数据

  • ref：指定其他 Bean 类型的数据，值为 bean 的 id

  • 「注：当没有无参构造时，必须提供与构造参数个数及数据类型匹配的配置参数」

  • 使用标签 为构造函数赋值，其属性如下：

  • name：注入时调用的 set 方法名去掉 set 后的词缀

  • value：指定基本类型或 String 类型数据

  • ref：指定其他 Bean 类型的数据，值为 bean 的 id

  • 使用标签对应 set 方法，标签属性如下：

  • 按注入的方式分类

  • 按注入的数据类型分类

  1. 「基本类型、String」

  2. 「复杂类型 [Array，List，Set，Map，Properties]」

     示例( 以set方法注入为例，构造函数注入同样 )：

     
     
      
             array1
             array2
         
     
     
     
     
      
             list1
             list2
         
     
     
     
     
      
             set1
             set2
         
     
     
     
     
      
     
     
     
     
      
     
     

     ❝

     在List结构的集合数据注⼊时，array , list , set这三个标签通⽤，另外注值的value标签内部 可以直接写值，也可以使⽤bean标签配置⼀个对象，或者⽤ref标签引⽤⼀个已经配合的bean 的唯⼀标识。在Map结构的集合数据注⼊时，map标签使⽤entry⼦标签实现数据注⼊，entry标签可以使 ⽤key和value属性指定存⼊map中的数据。使⽤value-ref属性指定已经配置好的bean的引⽤。同时entry标签中也可以使⽤ref标签，但是不能使⽤bean标签。⽽property标签中不能使 ⽤ref或者bean标签引⽤对象

     ❞

  3. 「其他 Bean 类型」

  1. 构造函数注入

  2. set 方法注入

注解与 xml 标签对应关系

❝

xml 与注解相结合模式下，通常第三方jar 中的bean 定义在 xml 中，自己开发的 bean 定义使用注解

❞

1. 配置方面

   • @Configuration 注解，对应 beans.xml 文件

   • @ComponentScan 注解，替代 context:component-scan

   • @PropertySource，引⼊外部属性配置⽂件

   • @Import 引⼊其他配置类

   • @Value 对变量赋值，可以直接赋值，也可以使⽤ ${} 读取资源配置⽂件中的信息

   • @Bean 将⽅法返回对象加⼊ SpringIoC 容器

2. IoC

   xml形式	对应的注解形式
   标签	@Component("accountDao")，注解加在类上 bean的id属性内容直接配置在注解后⾯如果不配置，默认定义个这个bean的id为类 的类名⾸字⺟⼩写；另外，针对分层代码开发提供了@Componenet的三种别名@Controller、 @Service、@Repository分别⽤于控制层类、服务层类、dao层类的bean定义，这 四个注解的⽤法完全⼀样，只是为了更清晰的区分⽽已
   scope属性	@Scope("prototype")，默认单例，注解加在类上
   标签的 init-method 属性	@PostConstruct，注解加在⽅法上，该⽅法就是初始化后调⽤的⽅法
   destory-method 属性	@PreDestory，注解加在⽅法上，该⽅法就是销毁前调⽤的⽅法

3. DI

   • J2EE 提供，@Resource 在 Jdk 11中已经移除，使用需导入包 javax.annotation.Resource

   • 注入规则：

   • 如果同时指定了 name 和 type，则从Spring上下⽂中找到唯⼀匹配的bean进⾏装配，找不到则抛出异常。

   • 如果指定了 name，则从上下⽂中查找名称（id）匹配的bean进⾏装配，找不到则抛出异常。

   • 如果指定了 type，则从上下⽂中找到类似匹配的唯⼀bean进⾏装配，找不到或是找到多个， 都会抛出异常。

   • 如果既没有指定name，⼜没有指定type，则⾃动按照byName⽅式进⾏装配；

   • 「按类型注入，如果有多个 bean 值，需配合 @Qualifier(name="") 使用」

   • @Autowired

   • @Resource

Spring IoC 常用特性

lazy-Init 延迟加载

• 关闭延迟加载(默认状态) ：ApplicationContext 容器的默认⾏为是在启动服务器时将所有 singleton bean 提前进⾏实例化

• 开启延迟加载：bean 将不会在 ApplicationContext 启动时提前被实例化，⽽是第⼀次向容器通过 getBean 索取 bean 时实例化的。

  1. 在设置 lazy-init="true"，控制单个 bean

  2. 在设置 default-lazy-init="true" ，控制该容器下所有 bean

作用：

1. 开启延迟加载⼀定程度提⾼容器启动和运转性能

2. 对于不常使⽤的 Bean 设置延迟加载，这样偶尔使⽤的时候再加载，不必要从⼀开始该 Bean 就占⽤资源

FactoryBean 和 BeanFactory

• BeanFactory接口：容器顶级接口，定义容器的一些基础行为

• FactoryBean接口：借助他自定义Bean，作用类似于 Bean 创建方式的静态方法和实例化方法

  「使用方法」

  1. 创建 Bean 对应的 Factory 类，实现 FactoryBean 接口，重写 getObject() 、getObjectType() 和 isSingleton()

  2. 在 xml 中配置该 Factory 类

  3. 容器初始化过程中 会自动实例化 Factory 对象并调用其 getObject() 并管理

     「注：如果需要 Factory 对象，可获取容器中的 &${id} 对象」

后置处理器

Spring 提供两种后置处理 bean 的扩展接口

• 「BeanPostProcessor：Bean 对象实例化且装配后调用」

  该接口提供两个方法：

  1. postProcessBeforeInitialization：Bean 初始化方法前

  2. postProcessAfterInitialization：Bean 初始化方法后

• 「BeanFactoryPostProcessor：BeanFactory 初始化后（bean 还未实例化，此时 bean 刚被解析成 BeanDefinition对象）调用」

  此接口提供了⼀个⽅法，⽅法参数为ConfigurableListableBeanFactory，该参数类型定义了⼀些⽅法其中有个⽅法名为getBeanDefinition的⽅法，我们可以根据此⽅法，找到我们定义bean 的 BeanDefinition对象。然后我们可以对定义的属性进⾏修改。

  **BeanDefinition对象：**我们在 XML 中定义的 bean标签，Spring 解析 bean 标签成为⼀个 JavaBean， 这个JavaBean 就是 BeanDefinition

Spring IoC 源码剖析

Spring IoC 容器继承体系


Bean 生命周期关键时机点

「Bean对象创建的⼏个关键时机点代码层级的调⽤都在 AbstractApplicationContext 类 的 refresh ⽅法中」

关键点	触发代码
构造器	refresh#finishBeanFactoryInitialization(beanFactory)(beanFactory)
BeanFactoryPostProcessor 初始化	refresh#invokeBeanFactoryPostProcessors(beanFactory)
BeanFactoryPostProcessor ⽅法调⽤	refresh#invokeBeanFactoryPostProcessors(beanFactory)
BeanPostProcessor 初始化	registerBeanPostProcessors(beanFactory)
BeanPostProcessor ⽅法调⽤	refresh#finishBeanFactoryInitialization(beanFactory)

源码如下：

public void refresh() throws BeansException, IllegalStateException {
 // 对象锁加锁
 synchronized (this.startupShutdownMonitor) {
  /*
   Prepare this context for refreshing.
   刷新前的预处理
   表示在真正做refresh操作之前需要准备做的事情：
    设置Spring容器的启动时间，
    开启活跃状态，撤销关闭状态
    验证环境信息里一些必须存在的属性等
  */
  prepareRefresh();

  /*
   Tell the subclass to refresh the internal bean factory.
   获取BeanFactory；默认实现是DefaultListableBeanFactory
   加载BeanDefition 并注册到 BeanDefitionRegistry
  */
  ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

  /*
   Prepare the bean factory for use in this context.
   BeanFactory的预准备工作（BeanFactory进行一些设置，比如context的类加载器等）
  */
  prepareBeanFactory(beanFactory);

  try {
            /*
             Allows post-processing of the bean factory in context subclasses.
             BeanFactory准备工作完成后进行的后置处理工作
            */
            postProcessBeanFactory(beanFactory);

            /*
             Invoke factory processors registered as beans in the context.
             实例化实现了BeanFactoryPostProcessor接口的Bean，并调用接口方法
            */
            invokeBeanFactoryPostProcessors(beanFactory);

            /*
             Register bean processors that intercept bean creation.
             注册BeanPostProcessor（Bean的后置处理器），在创建bean的前后等执行
            */
            registerBeanPostProcessors(beanFactory);
            
            /*
             Initialize message source for this context.
             初始化MessageSource组件（做国际化功能；消息绑定，消息解析）；
            */
            initMessageSource();

            /*
             Initialize event multicaster for this context.
             初始化事件派发器
            */
            initApplicationEventMulticaster();

            /*
             Initialize other special beans in specific context subclasses.
             子类重写这个方法，在容器刷新的时候可以自定义逻辑；如创建Tomcat，Jetty等WEB服务器
            */
            onRefresh();

            /*
             Check for listener beans and register them.
             注册应用的监听器。就是注册实现了ApplicationListener接口的监听器bean
            */
            registerListeners();

            /*
             Instantiate all remaining (non-lazy-init) singletons.
             初始化所有剩下的非懒加载的单例bean
             初始化创建非懒加载方式的单例Bean实例（未设置属性）
             填充属性
             初始化方法调用（比如调用afterPropertiesSet方法、init-method方法）
             调用BeanPostProcessor（后置处理器）对实例bean进行后置处理
            */
            finishBeanFactoryInitialization(beanFactory);

            /*
             Last step: publish corresponding event.
             完成context的刷新。主要是调用LifecycleProcessor的onRefresh()方法，并且发布事件（ContextRefreshedEvent）
            */
            finishRefresh();
  }catch (BeansException ex) {
            if (logger.isWarnEnabled()) {
                logger.warn("Exception encountered during context initialization - " +
       "cancelling refresh attempt: " + ex);}
            
    // Destroy already created singletons to avoid dangling resources.
    destroyBeans();

    // Reset 'active' flag.
    cancelRefresh(ex);

    // Propagate exception to caller.
    throw ex;
   }finally {
    // Reset common introspection caches in Spring's core, since we
    // might not ever need metadata for singleton beans anymore...
    resetCommonCaches();
   }
  }

BeanFactory 创建流程

获取 BeanFactory 子流程

img

BeanDefinition加载解析及注册⼦流程

1. Resource 定位：把 XML 文件封装成 Resource 对象的过程

2. BeanDefinition 载入：把⽤户定义好的Javabean表示为IoC容器内部的数据结构，这个容器内部的数 据结构就是BeanDefinition。

3. 注册BeanDefinition到 IoC 容器

img

Bean 创建流程

「注：参考IoC 循环依赖时序图」

lazy-inti 延迟加载机制原理

public void preInstantiateSingletons() throws BeansException {
    if (logger.isTraceEnabled()) {
        logger.trace("Pre-instantiating singletons in " + this);
    }

 // Iterate over a copy to allow for init methods which in turn register new bean definitions.
    // While this may not be part of the regular factory bootstrap, it does otherwise work fine.
    // 所有bean的名字
    List beanNames = new ArrayList<>(this.beanDefinitionNames);

    // Trigger initialization of all non-lazy singleton beans...
    // 触发所有非延迟加载单例bean的初始化，主要步骤为getBean
    for (String beanName : beanNames) {
        // 合并父BeanDefinition对象
        // map.get(beanName)
        RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
        
        if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
            if (isFactoryBean(beanName)) {
                Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
                // 如果是FactoryBean则加&
                if (bean instanceof FactoryBean) {
                    final FactoryBean factory = (FactoryBean) bean;
                    boolean isEagerInit;
                    if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
                        isEagerInit = AccessController
                            .doPrivileged((PrivilegedAction)((SmartFactoryBean) factory)::isEagerInit, getAccessControlContext());
                    }else {
                        isEagerInit = (factory instanceof SmartFactoryBean 
                                       && ((SmartFactoryBean) factory).isEagerInit());
                    }
                    if (isEagerInit) {
                        getBean(beanName);
                    }
                }
            }else {
                // 实例化当前bean
                getBean(beanName);
            }
        }
    }

    // Trigger post-initialization callback for all applicable beans...
    for (String beanName : beanNames) {
        Object singletonInstance = getSingleton(beanName);
        if (singletonInstance instanceof SmartInitializingSingleton) {
            final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
            if (System.getSecurityManager() != null) {
                AccessController.doPrivileged((PrivilegedAction