Spring源码剖析

方便解藕，简化开发
1. 通过Spring提供的IoC容器，可以将对象间的依赖关系交由Spring进行控制，避免硬编码所造成的过度程序耦合。用户也不必再为单例模式类、属性文件解析等这些很底层的需求编写代码，可以更专注于上层的应用。
AOP编程支持
1. 通过Spring的AOP功能，方便进行面向切面的编程，许多不容易用传统OOP实现的功能可以通过AOP轻松应付。
声明式事务
1. @Transactional
2. 可以将我们从单调烦闷的事务管理代码中解脱出来，通过声明式方式灵活的进行事务的管理，提高开发效率和质量。
方便单元测试
1. 可以用非容器依赖的编程方式进行几乎所有的测试工作，测试不再是昂贵的操作，而是随手可做的事情。
方便集成各种优秀框架
1. Spring可以降低各种框架的使用难度，提供了对各种优秀框架(Struts、Hibernate、Hessian、Quartz等)的直接支持。
降低Java API的使用难度
1. Spring对JavaEE API(如JDBC、JavaMail、远程调用等)进行了薄薄的封装层，使这些API的使用难度大为降低。
源码是经典的java学习范例
1. Spring的源代码设计精妙、结构清晰、匠心独用，处处体现着大师对Java设计模式灵活运用以及对Java技术的高深造诣。它的源代码无意是Java技术的最佳实践的范例。

3、核心结构

Spring核心容器(Core Container) ：容器是Spring框架最核心的部分，它管理着Spring应用中bean的创建、配置和管理。在该模块中，包括了Spring bean工厂，它为Spring提供了DI的功能。基于bean工厂，我们还会发现有多种Spring应用上下文的实现。所有的Spring模块都构建于核心容器之上。
面向切面编程(AOP)/Aspects：Spring对面向切面编程提供了丰富的支持。这个模块是Spring应用系统中开发切面的基础，与DI一样，AOP可以帮助应用对象解耦。
数据访问与集成(Data Access/Integration)：Spring的JDBC和DAO模块封装了大量样板代码，这样可以使得数据库代码变得简洁，也可以更专注于我们的业务，还可以避免数据库资源释放失败而引起的问题。另外，Spring AOP为数据访问提供了事务管理服务，同时Spring还对ORM进行了集成，如Hibernate、MyBatis等。该模块由JDBC、Transactions、ORM、OXM 和 JMS 等模块组成。
Web：该模块提供了SpringMVC框架给Web应用，还提供了多种构建和其它应用交互的远程调用方案。 SpringMVC框架在Web层提升了应用的松耦合水平。
Test：为了使得开发者能够很方便的进行测试，Spring提供了测试模块以致力于Spring应用的测试。通过该模块，Spring为使用Servlet、JNDI等编写单元测试提供了一系列的mock对象实现。

二、核心思想

IOC和AOP不是spring提出的，在spring之前就已经存在，只不过更偏向于理论化，spring在技术层面把这两个思想做了非常好的实现。

1、IOC

1.1、什么是IOC

IoC（Inversion of Control：控制反转/反转控制），注意它是一个技术思想，不是一个技术。

实现描述的事情：Java开发领域对象的创建、管理的问题。

传统开发方式：比如类A依赖于类B，往往会在类A中new一个B的对象。

IoC思想下开发方式：我们不用自己去new对象了，而是由IoC容器（Spring框架）去帮助我们实例化对象并且管理它，我们需要使用哪个对象，去问IoC容器要即可。

我们丧失了一个权利（创建、管理对象的权利），得到了一个福利（不用考虑对象的创建、管理等一系列事情）。

为什么叫做控制反转？

控制：指的是对象创建（实例化、管理）的权利。

反转：控制权交给外部环境了（spring框架、IoC容器）。

1.2、IOC解决了什么问题

IOC解决了对象之间耦合的问题。

传统的方式，UserDao userDao = new UserDaoImpl()，在service层使用UserDao时，使用到的类就需要在类中通过new的方式来创建类对象，并且使用的实现类（UserDaoImpl）是固定的。这个时候如果我重新实现了接口UserDao实现类为UserDaoImplNew，那么我在将该实现类使用于各个类时就需要手动修改UserDao userDao = new UserDaoImpl()这部分编码，而通过spring ioc那么我只需要在使用的地方注入接口对象（UserDao）即可，至于注入哪个实现类通过配置的方式即可完成。

1.3、IOC和DI的区别

DI：Dependancy Injection(依赖注入)

怎么理解：IOC和DI描述的是同一件事情，只不过⻆度不一样罢了。

2、AOP

2.1、什么是AOP

AOP：Aspect oriented Programming面向切面编程/面向方面编程，AOP是OOP的延续，OOP三大特征：封装、继承和多态，OOP是一种垂直继承体系。

OOP编程思想可以解决大多数的代码重复问题，但是有一些情况是处理不了的，比如下面的在顶级父类Animal中的多个方法中相同位置出现了重复代码，OOP就解决不了：

横切逻辑代码

横切逻辑代码存在什么问题：

横切代码重复问题
横切逻辑代码和业务代码混杂在一起，代码臃肿，维护不方便

AOP出场，AOP独辟蹊径提出横向抽取机制，将横切逻辑代码和业务逻辑代码分析：

代码拆分容易，那么如何在不改变原有业务逻辑的情况下，悄无声息的把横切逻辑代码应用到原有的业务逻辑中，达到和原来一样的效果，这个是比较难的。

2.2、AOP在解决什么问题

在不改变原有业务逻辑情况下，增强横切逻辑代码，根本上解耦合，避免横切逻辑代码重复。

2.3、为什么叫做面向切面编程

「切」：指的是横切逻辑，原有业务逻辑代码我们不能动，只能操作横切逻辑代码，所以面向横切逻辑；

「面」：横切逻辑代码往往要影响的是很多个方法，每一个方法都如同一个点，多个点构成面，有一个面的概念在里面。

三、Spring IOC应用

1、BeanFactory与ApplicationContext区别

BeanFactory是Spring框架中IoC容器的顶层接口，它只是用来定义一些基础功能，定义一些基础规范，而ApplicationContext是它的一个子接口，所以ApplicationContext是具备BeanFactory提供的全部功能的。

通常，我们称BeanFactory为SpringIOC的基础容器，ApplicationContext是容器的高级接口，比BeanFactory要拥有更多的功能，比如说国际化支持和资源访问(xml，java配置类)等等。

启动容器的方式：

Java环境下启动IoC容器
1. ClassPathXmlApplicationContext：从类的根路径下加载配置文件（推荐使用）
2. FileSystemXmlApplicationContext：从磁盘路径上加载配置文件
3. AnnotationConfigApplicationContext：纯注解模式下启动Spring容器

Web环境下启动IoC容器

从xml启动

<!DOCTYPE web-app PUBLIC
 "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 "http://java.sun.com/dtd/web-app_2_3.dtd" >
<web-app>
  <display-name>Archetype Created Web Application</display-name>
	<!--配置Spring ioc容器的配置文件--> 
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:applicationContext.xml</param-value> 
  </context-param>
	<!--使用监听器启动Spring的IOC容器-->
	<listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>
</web-app>

从配置类启动

<!DOCTYPE web-app PUBLIC
 "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 "http://java.sun.com/dtd/web-app_2_3.dtd" >
<web-app>
  <display-name>Archetype Created Web Application</display-name>
	<!--告诉ContextloaderListener知道我们使用注解的方式启动ioc容器--> 
  <context-param>
    <param-name>contextClass</param-name>
    <param-value>org.springframework.web.context.support.AnnotationConfigWebApplicationContext</param-value>
	</context-param>
 	<!--配置启动类的全限定类名--> 
  <context-param>
    <param-name>contextConfigLocation</param-name>
		<param-value>com.lagou.edu.SpringConfig</param-value> 
  </context-param>
	<!--使用监听器启动Spring的IOC容器-->
	<listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>
</web-app>

2、纯xml方式

（1）头文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">

（2）实例化bean的三种方式

a、使用无参构造函数

在默认情况下，它会通过反射调用无参构造函数来创建对象。如果类中没有无参构造函数，将创建失败。

<!--配置service对象-->
<bean id="userService" class="com.lagou.service.impl.TransferServiceImpl"></bean>

b、使用静态方法创建

在实际开发中，我们使用的对象有些时候并不是直接通过构造函数就可以创建出来的，它可能在创建的过程中会做很多额外的操作。此时会提供一个创建对象的方法，恰好这个方法是static修饰的方法，即是此种情况。

<!--使用静态方法创建对象的配置方式-->
<bean id="userService" class="com.lagou.factory.BeanFactory" 
  factory-method="getTransferService"></bean>

调用工厂类BeanFactory的getTransferService方法来创建对象userService。

c、使用实例化方法创建

此种方式和上面静态方法创建其实类似，区别是用于获取对象的方法不再是static修饰的了，而是类中的一个普通方法。此种方式比静态方法创建的使用几率要高一些。

<!--使用实例方法创建对象的配置方式-->
<bean id="beanFactory" class="com.lagou.factory.instancemethod.BeanFactory"></bean> 
<bean id="transferService" factory-bean="beanFactory" 
      factory- method="getTransferService"></bean>

首先创建BeanFactory的实例对象beanFactory，然后在调用该实例对象beanFactory的getTransferService方法来创建对象transferService

（3）bean的作用范围和生命周期

作用范围

在spring框架管理Bean对象的创建时，Bean对象默认都是单例的，但是它支持配置的方式改变作用范围。作用范围官方提供的说明如下图：

我们在实际开发中经常用到到就是singleton（单例）和prototype（原型，又称为多例）模式，配置方式如下：

<!--配置service对象-->
<bean id="transferService" class="com.lagou.service.impl.TransferServiceImpl" 
      scope="singleton"></bean>

生命周期

单例模式：singleton
1. 对象出生：当创建容器时，对象就被创建了。
2. 对象活着：只要容器在，对象一直活着。
3. 对象死亡：当销毁容器时，对象就被销毁了。
4. 一句话总结：单例模式的bean对象生命周期与容器相同。
多例模式：prototype
1. 对象出生：当使用对象时，创建新的对象实例。
2. 对象活着：只要对象在使用中，就一直活着。
3. 对象死亡：当对象⻓时间不用时，被java的垃圾回收器回收了。
4. 一句话总结：多例模式的bean对象，spring框架只负责创建，不负责销毁。

（4）bean标签属性

在基于xml的IoC配置中，bean标签是最基础的标签。它表示了IoC容器中的一个对象。换句话说，如果一个对象想让spring管理，在XML的配置中都需要使用此标签配置，Bean标签的属性如下：

id属性：用于给bean提供一个唯一标识。在一个标签内部，标识必须唯一。
class属性：用于指定创建Bean对象的全限定类名。
name属性：用于给bean提供一个或多个名称，多个名称用空格分隔。
factory-bean属性：用于指定创建当前bean对象的工厂bean的唯一标识。当指定了此属性之后，class属性失效。
factory-method属性：用于指定创建当前bean对象的工厂方法，如配合factory-bean属性使用，则class属性失效。如配合class属性使用，则方法必须是static的。
scope属性：用于指定bean对象的作用范围。通常情况下就是singleton。当要用到多例模式时，可以配置为prototype。
init-method属性：用于指定bean对象的初始化方法，此方法会在bean对象装配后调用。必须是一个无参方法。
destory-method属性：用于指定bean对象的销毁方法，此方法会在bean对象销毁前执行。它只能为scope是singleton时起作用。

（5）DI依赖注入的xml配置

依赖注入分类
1. 按照注入的方式分
  1. 构造函数注入：顾名思义，就是利用带参构造函数实现对类成员的数据赋值。
  2. set方法注入：它是通过类成员的set方法实现数据的注入。（使用最多的）
2. 按照注入的数据类型分
  1. 基本类型和String注入的数据类型是基本类型或者是字符串类型的数据。
  2. 其他Bean类型注入的数据类型是对象类型，称为其他Bean的原因是，这个对象是要求出现在IoC容器中的。那么针对当前Bean来说，就是其他Bean了。
3. 复杂类型(集合类型)
  1. 注入的数据类型是Aarry，List，Set，Map，Properties中的一种类型。
依赖注入的配置实现之构造函数注入
1. 顾名思义，就是利用构造函数实现对类成员的赋值。它的使用要求是，类中提供的构造函数参数个数必须和配置的参数个数一致，且数据类型匹配。同时需要注意的是，当没有无参构造时，则必须提供构造函数参数的注入，否则Spring框架会报错。
3. 在使用构造函数注入时，涉及的标签是“constructor-arg”，该标签有如下属性：
  1. name：用于给构造函数中指定名称的参数赋值
  2. index：用于给构造函数中指定索引位置的参数赋值
  3. value：用于指定基本类型或者String类型的数据
  4. ref：用于指定其他Bean类型的数据。写的是其他bean的唯一标识
依赖注入的配置实现之set方法注入
1. 顾名思义，就是利用字段的set方法实现赋值的注入方式。此种方式在实际开发中是使用最多的注入方式。
3. 在使用set方法注入时，需要使用 property 标签，该标签属性如下：
  1. name：指定注入时调用的set方法名称。（注：不包含set这三个字母，druid连接池指定属性名称）
  2. value：指定注入的数据。它支持基本类型和String类型。
  3. ref：指定注入的数据。它支持其他bean类型。写的是其他bean的唯一标识。

（6）复杂数据类型注入

它指的是集合类型数据。

集合分为两类，一类是List结构(数组结构)，一类是Map接口(键值对) 。

3、xml与注解相结合

注意:

实际企业开发中，纯xml模式使用已经很少了
引入注解功能，不需要引入额外的jar
xml+注解结合模式，xml文件依然存在，所以，spring IOC容器的启动仍然从加载xml开始
哪些bean的定义写在xml中，哪些bean的定义使用注解？
1. 第三方jar中的bean定义在xml，比如Druid数据库连接池，自己开发的bean定义使用注解

（1）xml中标签与注解的对应（IoC）

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

（2）DI 依赖注入的注解实现方式

@Autowired（推荐使用）

@Autowired为Spring提供的注解，需要导入包org.springframework.beans.factory.annotation.Autowired

@Autowired采取的策略为按照类型注入

public class TransferServiceImpl {
    @Autowired
    private AccountDao accountDao;
}

如上代码所示，这样装配回去spring容器中找到类型为AccountDao的类，然后将其注入进来。这样会产生一个问题，当一个类型有多个bean值的时候，会造成无法选择具体注入哪一个的情况，这个时候我们需要配合着@Qualifier使用。

@Qualifier告诉Spring具体去装配哪个对象

public class TransferServiceImpl {
    @Autowired
    @Qualifier(name="jdbcAccountDaoImpl")
    private AccountDao accountDao;
}

这个时候我们就可以通过类型和名称定位到我们想注入的对象。
@Resource
@Resource注解由J2EE提供，需要导入包 javax.annotation.Resource
@Resource 默认按照 ByName自动注入

public class TransferService {
    @Resource
    private AccountDao accountDao;
    @Resource(name="studentDao")
    private StudentDao studentDao;
    @Resource(type="TeacherDao")
    private TeacherDao teacherDao;
    @Resource(name="manDao",type="ManDao")
    private ManDao manDao;
}

如果同时指定了 name 和 type，则从Spring上下文中找到唯一匹配的bean进行装配，找不到则抛出异常。
如果指定了 name，则从上下文中查找名称（id）匹配的bean进行装配，找不到则抛出异常。
如果指定了 type，则从上下文中找到类似匹配的唯一bean进行装配，找不到或是找到多个，都会抛出异常。
如果既没有指定name，又没有指定type，则自动按照byName方式进行装配。

注意:

@Resource 在jdk11中已经移除，如果要使用，需要单独引入jar包

<dependency>
    <groupId>javax.annotation</groupId>
  	<artifactId>javax.annotation-api</artifactId>
    <version>1.3.2</version>
</dependency>

4、纯注解模式

改造xml+注解模式，将xml中遗留的内容全部以注解的形式迁移出去，最终删除xml，从Java配置类启动对应注解：

@Configuration 注解，表名当前类是一个配置类
@ComponentScan 注解，替代 context:component-scan
@PropertySource，引入外部属性配置文件
@Import 引入其他配置类
@Value 对变量赋值，可以直接赋值，也可以使用 ${} 读取资源配置文件中的信息
@Bean 将方法返回对象加入 SpringIOC 容器

四、Spring IOC高级特性

1、延迟加载

Bean的延迟加载（延迟创建）。

ApplicationContext容器的默认行为是在启动服务器时将所有 singleton bean 提前进行实例化。提前实例化意味着作为初始化过程的一部分，ApplicationContext 实例会创建并配置所有的singleton bean。

<bean id="testBean" class="cn.lagou.LazyBean" />
<!-- 该bean默认的设置为:立即加载 -->
<bean id="testBean" calss="cn.lagou.LazyBean" lazy-init="false" />

lazy-init="false"，立即加载，表示在spring启动时，立刻进行实例化。

如果不想让一个singleton bean在ApplicationContext实现初始化时被提前实例化，那么可以将bean设置为延迟实例化。

<bean id="testBean" calss="cn.lagou.LazyBean" lazy-init="true" />

设置 lazy-init 为 true 的 bean 将不会在 ApplicationContext 启动时提前被实例化，而是第一次向容器通过 getBean 索取 bean 时实例化的。

如果一个设置了立即加载的 bean1，引用了一个延迟加载的 bean2 ，那么 bean1 在容器启动时被实例化，而 bean2 由于被 bean1 引用，所以也被实例化，这种情况也符合延时加载的 bean 在第一次调用时才被实例化的规则。

<beans default-lazy-init="true">
    <!-- no beans will be eagerly pre-instantiated... -->
</beans>

如果一个 bean 的 scope 属性为 scope="pototype" 时，即使设置了 lazy-init="false"，容器启动时也不会实例化bean，而是调用 getBean 方法实例化的。

应用场景

（1）开启延迟加载一定程度提高容器启动和运转性能。

（2）对于不常使用的Bean设置延迟加载，这样偶尔使用的时候再加载，不必要从一开始就创建该Bean占用资源。

2、FactoryBean 和 BeanFactory

BeanFactory接口是容器的顶级接口，定义了容器的一些基础行为，负责生产和管理Bean的一个工厂，具体使用它下面的子接口类型，比如ApplicationContext。此处我们重点分析FactoryBean，Spring中Bean有两种，一种是普通Bean，一种是工厂Bean（FactoryBean）。FactoryBean可以生成某一个类型的Bean实例（返回给我们），也就是说我们可以借助于它自定义Bean的创建过程。Bean创建的三种方式中的静态方法和实例化方法和FactoryBean作用类似，FactoryBean使用较多，尤其在Spring框架一些组件中会使用，还有其他框架和Spring框架整合时使用。

// 可以让我们自定义Bean的创建过程(完成复杂Bean的定义) 
public interface FactoryBean<T> {
	@Nullable
	// 返回FactoryBean创建的Bean实例，如果isSingleton返回true，
    // 则该实例会放到Spring容器的单例对象缓存池中Map
  	T getObject() throws Exception;
    @Nullable
    // 返回FactoryBean创建的Bean类型 Class<?> getObjectType();
    // 返回作用域是否单例
    default boolean isSingleton() {
    	return true;
  	}
}

3、后置处理器

Spring提供了两种后处理bean的扩展接口，分别为 BeanPostProcessor 和 BeanFactoryPostProcessor，两者在使用上是有所区别的。

工厂初始化（BeanFactory）—> Bean对象

在BeanFactory初始化之后可以使用BeanFactoryPostProcessor进行后置处理做一些事情。

在Bean对象实例化（并不是Bean的整个生命周期完成）之后可以用BeanPostProcessor进行后置处理做一些事情。

（1）BeanPostProcessor

BeanPostProcessor是针对Bean级别的处理，可以针对某个具体的Bean。

该接口提供了两个方法，分别在Bean的初始化方法前和初始化方法后执行，具体这个初始化方法指的是什么方法，类似我们在定义bean时，定义了init-method所指定的方法。定义一个类实现了BeanPostProcessor，默认是会对整个Spring容器中所有的bean进行处理。如果要对具体的某个bean处理，可以通过方法参数判断，两个类型参数分别为Object和String，第一个参数是每个bean的实例，第二个参数是每个bean的name或者id属性的值。所以我们可以通过第二个参数，来判断我们将要处理的具体的bean。

注意：处理是发生在Spring容器的实例化和依赖注入之后。

（2）BeanFactoryPostProcessor

BeanFactory级别的处理，是针对整个Bean的工厂进行处理，

典型应用：PropertyPlaceholderConfigurer

此接口只提供了一个方法，方法参数为ConfigurableListableBeanFactory，该参数类型定义了一些方法。

其中有个方法名为getBeanDefinition的方法，我们可以根据此方法，找到我们定义bean的BeanDefinition对象。然后我们可以对定义的属性进行修改，以下是BeanDefinition中的方法

方法名字类似我们bean标签的属性，setBeanClassName对应bean标签中的class属性，所以当我们拿到BeanDefinition对象时，我们可以手动修改bean标签中所定义的属性值。

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

注意：调用BeanFactoryPostProcessor方法时，这时候bean还没有实例化，此时bean刚被解析成BeanDefinition对象。

五、Spring AOP应用

AOP本质上是在不改变原有业务逻辑的情况下增强横切逻辑（这部分在使用上是有限的）。

横切逻辑代码往往是：权限校验代码、日志代码、事务控制代码、性能监控代码。

1、相关业务术语

Joinpoint(连接点)	它指的是那些可以用于把增强代码加入到业务主线中的点，那么由上图中我们可以看出，这些点指的就是方法。在方法执行的前后通过动态代理技术加入增强的代码。在Spring框架AOP思想的技术实现中，也只支持方法类型的连接点。
Pointcut(切入点)	它指的是那些已经把增强代码加入到业务主线进来之后的连接点。由上图中，我们看出表现层 transfer 方法就只是连接点，因为判断访问权限的功能并没有对其增强。
Advice(通知/增强)	它指的是切面类中用于提供增强功能的方法。并且不同的方法增强的时机是不一样的。比如，开启事务肯定要在业务方法执行之前执行，提交事务要在业务方法正常执行之后执行，而回滚事务要在业务方法执行产生异常之后执行等等。那么这些就是通知的类型。其分类有：前置通知、后置通知、异常通知、最终通知、环绕通知。
Target(目标对象)	它指的是代理的目标对象。即被代理对象。
Proxy(代理)	它指的是一个类被AOP织入增强后，产生的代理类。即代理对象。
Weaving(织入)	它指的是把增强应用到目标对象来创建新的代理对象的过程。spring采用动态代理织入，而AspectJ采用编译期织入和类装载期织入。
Aspect(切面)	它指定是增强的代码所关注的方面，把这些相关的增强代码定义到一个类中，这个类就是切面类。例如，事务切面，它里面定义的方法就是和事务相关的，像开启事务，提交事务，回滚事务等等，不会定义其他与事务无关的方法。我们前面的案例中 TrasnactionManager 就是一个切面。

2、AOP代理方式的选择

Spring实现AOP思想使用的是动态代理技术。默认情况下，Spring会根据被代理对象是否实现接口来选择使用JDK还是CGLIB。当被代理对象没有实现任何接口时，Spring会选择CGLIB。当被代理对象实现了接口，Spring会选择JDK官方的代理技术，不过我们可以通过配置的方式，让Spring强制使用CGLIB。

3、AOP的配置方式

在Spring的AOP配置中，也和IoC配置一样，支持3类配置方式。

第一类：使用XML配置

第二类：使用XML+注解组合配置

第三类：使用纯注解配置

4、AOP的实现

（1）xml模式

a、坐标

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aop</artifactId>
    <version>5.1.12.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.4</version>
</dependency>

b、aop核心配置

<!-- Spring基于XML的AOP配置前期准备:在spring的配置文件中加入aop的约束 
	xmlns:aop="http://www.springframework.org/schema/aop"
  http://www.springframework.org/schema/aop
	https://www.springframework.org/schema/aop/spring-aop.xsd
	Spring基于XML的AOP配置步骤:
	第一步:把通知Bean交给Spring管理 
	第二步:使用aop:config开始aop的配置 
	第三步:使用aop:aspect配置切面 
	第四步:使用对应的标签配置通知的类型
<!--把通知bean交给spring来管理-->
<bean id="logUtil" class="com.lagou.utils.LogUtil"></bean>
<!--开始aop的配置--> 
<aop:config>
  <!--配置切面-->
  <aop:aspect id="logAdvice" ref="logUtil">
		<!--配置前置通知-->
		<aop:before method="printLog" pointcut="execution(public *
com.lagou.service.impl.TransferServiceImpl.updateAccountByCardNo(com.lagou
.pojo.Account))">
   	</aop:before>
  </aop:aspect>
</aop:config>

c、五种通知类型

I、前置通知

<!-- 
作用:用于配置前置通知。
出现位置: 它只能出现在aop:aspect标签内部
属性:method:用于指定前置通知的方法名称 pointcut:用于指定切入点表达式 pointcut-ref:用于指定切入点表达式的引用
-->
<aop:before method="printLog" pointcut-ref="pointcut1"></aop:before>

执行时机：前置通知永远都会在切入点方法（业务核心方法）执行之前执行。

细节：前置通知可以获取切入点方法的参数，并对其进行增强。

II、后置通知

<!--
作用:用于配置正常执行时通知
出现位置: 它只能出现在aop:aspect标签内部
属性:
	method:用于指定后置通知的方法名称 
	pointcut:用于指定切入点表达式 
	pointcut-ref:用于指定切入点表达式的引用
-->
<aop:after-returning method="afterReturningPrintLog" pointcut-ref="pt1">
</aop:after-returning>

III、异常通知

<!--
作用:用于配置异常通知。
出现位置:它只能出现在aop:aspect标签内部
属性:
	method:用于指定异常通知的方法名称
	pointcut:用于指定切入点表达式 
	pointcut-ref:用于指定切入点表达式的引用
-->
<aop:after-throwing method="afterThrowingPrintLog" pointcut-ref="pt1">
</aop:after-throwing>

执行时机：异常通知的执行时机是在切入点方法（业务核心方法）执行产生异常之后，异常通知执行。如果切入点方法执行没有产生异常，则异常通知不会执行。

细节：异常通知不仅可以获取切入点方法执行的参数，也可以获取切入点方法执行产生的异常信息。

IV、最终通知

<!--
作用:用于指定最终通知。
出现位置: 它只能出现在aop:aspect标签内部 
属性:
	method:用于指定最终通知的方法名称
	pointcut:用于指定切入点表达式 
	pointcut-ref:用于指定切入点表达式的引用
-->
<aop:after method="afterPrintLog" pointcut-ref="pt1"></aop:after>

执行时机：最终通知的执行时机是在切入点方法（业务核心方法）执行完成之后，切入点方法返回之前执行。换句话说，无论切入点方法执行是否产生异常，它都会在返回之前执行。

细节：最终通知执行时，可以获取到通知方法的参数。同时它可以做一些清理操作。

V、环绕通知

<!--
作用:用于配置环绕通知。
出现位置: 它只能出现在aop:aspect标签的内部
属性:
	method:用于指定环绕通知的方法名称
	pointcut:用于指定切入点表达式 
	pointcut-ref:用于指定切入点表达式的引用
-->
<aop:around method="aroundPrintLog" pointcut-ref="pt1"></aop:around>

**特别说明**

环绕通知，它是有别于前面四种通知类型外的特殊通知。前面四种通知（前置，后置，异常和最终）它们都是指定何时增强的通知类型。而环绕通知，它是Spring框架为我们提供的一种可以通过编码的方式，控制增强代码何时执行的通知类型。它里面借助的ProceedingJoinPoint接口及其实现类，实现手动触发切入点方法的调用。

（2）xml+注解模式

XML中开启Spring对注解AOP的支持：

<!--开启spring对注解aop的支持--> 
<aop:aspectj-autoproxy/>

示例：


/**
 * 模拟记录日志 * @author 应癫
 */
@Component
@Aspect
public class LogUtil {
    /**
     * 我们在xml中已经使用了通用切入点表达式，供多个切面使用，那么在注解中如何使用呢?
     * 第一步:编写一个方法
     * 第二步:在方法使用@Pointcut注解
     * 第三步:给注解的value属性提供切入点表达式
     * 细节:
     * 1.在引用切入点表达式时，必须是方法名+()，例如"pointcut()"。
     * 2.在当前切面中使用，可以直接写方法名。在其他切面中使用必须是全限定方法名。
     */
    @Pointcut("execution(* com.lagou.service.impl.*.*(..))")
    public void pointcut() {
    }

    @Before("pointcut()")
    public void beforePrintLog(JoinPoint jp) {
        Object[] args = jp.getArgs();
        System.out.println("前置通知:beforePrintLog，参数是:" + Arrays.toString(args));
    }

    @AfterReturning(value = "pointcut()", returning = "rtValue")
    public void afterReturningPrintLog(Object rtValue) {
        System.out.println("后置通知:afterReturningPrintLog，返回值 是:" + rtValue);
    }

    @AfterThrowing(value = "pointcut()", throwing = "e")
    public void afterThrowingPrintLog(Throwable e) {
        System.out.println("异常通知:afterThrowingPrintLog，异常是:" + e);
    }

    @After("pointcut()")
    public void afterPrintLog() {
        System.out.println("最终通知:afterPrintLog");
    }

    /**
     * 环绕通知
     *
     * @param pjp * @return
     */
    @Around("pointcut()")
    public Object aroundPrintLog(ProceedingJoinPoint pjp) {
        //定义返回值
        Object rtValue = null;
        try {
            //前置通知 System.out.println("前置通知");
            //1.获取参数
            Object[] args = pjp.getArgs();
            //2.执行切入点方法
            rtValue = pjp.proceed(args);
            //后置通知
            System.out.println("后置通知");
        } catch (Throwable t) {
            //异常通知 System.out.println("异常通知"); 
            t.printStackTrace();
        } finally { //最终通知
            System.out.println("最终通知");
        }
        return rtValue;
    }
}

（3）注解模式

在使用注解驱动开发aop时，我们要明确的就是，是注解替换掉配置文件中的下面这行配置：

<!--开启spring对注解aop的支持--> 
<aop:aspectj-autoproxy/>

在配置类中使用如下注解进行替换上述配置

@Configuration
@ComponentScan("com.lagou") 
@EnableAspectJAutoProxy 
//开启spring对注解AOP的支持 
public class SpringConfiguration {
}

5、声明式事务

（1）xml模式

坐标

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.1.12.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.4</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.1.12.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-tx</artifactId>
    <version>5.1.12.RELEASE</version>
</dependency>

配置

<tx:advice id="txAdvice" transaction-manager="transactionManager"> 
	<!--定制事务细节，传播行为、隔离级别等-->
	<tx:attributes>
		<!--一般性配置-->
  	<tx:method name="*" read-only="false"propagation="REQUIRED" 
             isolation="DEFAULT" timeout="-1"/>
		<!--针对查询的覆盖性配置-->
    <tx:method name="query*" read-only="true" propagation="SUPPORTS"/>
  </tx:attributes>
</tx:advice>
<aop:config>
	<!--advice-ref指向增强=横切逻辑+方位-->
  <aop:advisor advice-ref="txAdvice" pointcut="execution(*com.lagou.edu.service.impl.TransferServiceImpl.*(..))"/>
</aop:config>

（2）xml+注解

配置

<!--配置事务管理器-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManage r">
    <property name="dataSource" ref="dataSource"></property>
</bean>
<!--开启spring对注解事务的支持-->
<tx:annotation-driven transaction-manager="transactionManager"/>

在接口、类或者方法上添加@Transactional注解

@Transactional(readOnly = true,propagation = Propagation.SUPPORTS)

（3）注解模式

Spring基于注解驱动开发的事务控制配置，只需要把 xml 配置部分改为注解实现。

只是需要一个注解替换掉xml配置文件中的

<tx:annotation-driven transaction- manager="transactionManager"/> 配置。

在 Spring 的配置类上添加 @EnableTransactionManagement 注解即可。

@EnableTransactionManagement
//开启spring注解事务的支持 
public class SpringConfiguration {
}

六、Spring IOC源码剖析

1、Spring IOC初始化的主体流程

1.1、IOC的容器体系

IoC容器是Spring的核心模块，是抽象了对象管理、依赖关系管理的框架解决方案。Spring提供了很多的容器，其中BeanFactory是顶层容器(根容器)，不能被实例化，它定义了所有 IoC容器必须遵从的一套原则，具体的容器实现可以增加额外的功能，比如我们常用到的ApplicationContext，其下更具体的实现如ClassPathXmlApplicationContext包含了解析xml等一系列的内容，AnnotationConfigApplicationContext则是包含了注解解析等一系列的内容。Spring IoC容器继承体系非常聪明，需要使用哪个层次用哪个层次即可，不必使用功能大而全的。

BeanFactory顶级方法栈如下：

1.2、Bean生命周期的关键时间点

模拟思路：创建一个TestBean，让其实现几个特殊的接口，并分别在构造器、接口方法中打断点，观察调用栈，分析出Bean对象创建和管理关键点的时机。
TestBean

public class TestBean implements InitializingBean {
    public TestBean(){
        System.out.println("构造TestBean");
    }
    public void afterPropertiesSet() throws Exception {
        System.out.println("TestBean afterPropertiesSet ...");
    }
}

BeanPostProcessor接口实现类

public class MyBeanPostProcessor implements BeanPostProcessor {
    public MyBeanPostProcessor(){
        System.out.println("构造MyBeanPostProcessor");
    }
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        if("testBean".equals(beanName)) {
            System.out.println("BeanPostProcessor 实现类 postProcessBeforeInitialization 方法被调用中......");
        }
        return bean;
    }
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if("testBean".equals(beanName)) {
            System.out.println("BeanPostProcessor 实现类 postProcessAfterInitialization 方法被调用中......");
        }
        return bean;
    }
}

BeanFactoryPostProcessor接口实现类

public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
    public MyBeanFactoryPostProcessor(){
        System.out.println("构造 MyBeanFactoryPostProcessor ");
    }
    public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
        System.out.println("BeanFactoryPostProcessor的实现方法 postProcessBeanFactory 调用中......");
    }
}

applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="testBean" class="com.spring.test.bean.TestBean"/>
    <bean id="myBeanPostProcessor" class="com.spring.test.bean.MyBeanPostProcessor"/>
    <bean id="myBeanFactoryPostProcessor" class="com.spring.test.bean.MyBeanFactoryPostProcessor"/>
</beans>

IoC容器源码分析用例

public class TestIoc {
    public static void main(String[] args) {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
        TestBean testBean = applicationContext.getBean(TestBean.class);
        System.out.println(testBean);
    }
}

（1）分析Bean的创建是在容器初始化时还是在getBean时

通过断点可以看出，在未设置延迟加载的情况下，Bean的创建是在容器初始化过程中完成的。

（2）分析构造函数调用情况

在TestBean的构造函数处打断点，

可以看到构造函数的调用时机是在AbstractApplicationContext类的refresh()方法的

finishBeanFactoryInitialization(beanFactory)处。

（3）分析InitializingBean之afterPropertiesSet初始化方法的调用

在TestBean的afterPropertiesSet()方法打断点，可以看到afterPropertiesSet()方法的调用时机也是在AbstractApplicationContext类的refresh()方法的finishBeanFactoryInitialization(beanFactory)处。

（4）分析BeanFactoryPostProcessor初始化和调用情况

在构造函数和postProcessBeanFactory()方法处打断点，发现初始化和方法调用均是在AbstractApplicationContext类refresh方法的invokeBeanFactoryPostProcessors(beanFactory)。

（5）分析BeanPostProcessor初始化和调用情况

分别在构造函数、postProcessBeforeInitialization()、postProcessAfterInitialization()处打断点，观察调用栈，发现

BeanPostProcessor：初始化在AbstractApplicationContext类refresh方法的registerBeanPostProcessors(beanFactory)；

postProcessBeforeInitialization：调用在AbstractApplicationContext类refresh方法的finishBeanFactoryInitialization(beanFactory)；

postProcessAfterInitialization：调用在AbstractApplicationContext类refresh方法的finishBeanFactoryInitialization(beanFactory)；

（6）总结

经调试我们发现Bean对象创建的几个关键点时机都在调用AbstractApplicationContext类的refresh()方法中，可见这个方法对spring ioc容器的初始化来说非常重要。

关键点	触发代码
bean对象构造器	AbstractApplicationContext refresh finishBeanFactoryInitialization(beanFactory)
BeanFactoryPostProcessor初始化	AbstractApplicationContext refresh invokeBeanFactoryPostProcessors(beanFactory)
BeanFactoryPostProcessor方法调用	AbstractApplicationContext refresh invokeBeanFactoryPostProcessors(beanFactory)
BeanPostProcessor初始化	AbstractApplicationContext refresh registerBeanPostProcessors(beanFactory)
BeanPostProcessor方法调用	AbstractApplicationContext refresh finishBeanFactoryInitialization(beanFactory)

1.3、Spring IOC初始化主流程

我们可以看出spring ioc初始化的关键环节就在AbstractApplicationContext的refresh()方法中

public void refresh() throws BeansException, IllegalStateException {
		synchronized (this.startupShutdownMonitor) {
			// Prepare this context for refreshing.
            // 第一步：刷新前的预处理
			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.
                // 第九步：子类重写这个方法，在容器刷新的时候可以自定义逻辑
				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();
			}
		}
	}

2、BeanFactory创建流程

2.1、BeanFactory子流程

org.springframework.context.support.AbstractApplicationContext
	|--> refresh()
		|--> obtainFreshBeanFactory()
			|--> refreshBeanFactory()
org.springframework.context.support.AbstractRefreshableApplicationContext
	|--> refreshBeanFactory()
		|--> loadBeanDefinitions() 多次进入该方法的调用
org.springframework.beans.factory.groovy.GroovyBeanDefinitionReader
	|--> loadBeanDefinitions() 
org.springframework.beans.factory.xml.XmlBeanDefinitionReader
	|--> loadBeanDefinitions()
		|--> doLoadBeanDefinitions() 真正“干活”的类（spring通常do开头为正真开始处理的方法）
			// 将资源文件的流对象封装成Document对象
			Document doc = doLoadDocument(inputSource, resource);
			// 注册bean对象
			int count = registerBeanDefinitions(doc, resource);
			if (logger.isDebugEnabled()) {
				logger.debug("Loaded " + count + " bean definitions from " + resource);
			}
			return count;

2.2、BeanDefinition加载解析及注册子流程

（1）涉及到如下几个关系步骤

Resource定位：指对BeanDefinition对资源定位过程。通俗讲就是找到定义javabean信息的xml文件，并将其封装成Resource对象。

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

注册BeanDefinition到IoC容器。

（2）过程分析

step1

子流程入口在org.springframework.context.support.AbstractRefreshableApplicationContext#

refreshBeanFactory()

protected final void refreshBeanFactory() throws BeansException {
    // 判断是否已有 bean factory
    if (hasBeanFactory()) {
        // 销毁 beans
        destroyBeans();
        // 关闭 bean factory
        closeBeanFactory();
    }
    try {
        // 实例化 DefaultListableBeanFactory
        DefaultListableBeanFactory beanFactory = createBeanFactory();
        // 设置序列化id
        beanFactory.setSerializationId(getId());
        // 自定义bean工厂的一些属性（是否覆盖、是否允许循环依赖）
        customizeBeanFactory(beanFactory);
        /**
         * 加载应用中的BeanDefinitions
         */
        loadBeanDefinitions(beanFactory);
        synchronized (this.beanFactoryMonitor) {
            // 赋值当前的 bean factory
            this.beanFactory = beanFactory;
        }
    }
    catch (IOException ex) {
        throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
    }
}

step2

依次调用多个类的loadBeanDefinitions方法

org.springframework.context.support.AbstractXmlApplicationContext

org.springframework.beans.factory.support.AbstractBeanDefinitionReader

org.springframework.beans.factory.groovy.GroovyBeanDefinitionReader

org.springframework.beans.factory.xml.XmlBeanDefinitionReader#

doLoadBeanDefinitions()

protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
    throws BeanDefinitionStoreException {
    try {
        // 读取xml信息，将xml中信息保存为Document对象
        Document doc = doLoadDocument(inputSource, resource);
        // 解析document对象，封装BeanDifinition对象并进行注册
        int count = registerBeanDefinitions(doc, resource);
        if (logger.isDebugEnabled()) {
            logger.debug("Loaded " + count + " bean definitions from " + resource);
        }
        return count;
    }
}

step3

重点关注

org.springframework.beans.factory.xml.XmlBeanDefinitionReader

|-> doLoadBeanDefinitions()

|-> registerBeanDefinitions()

public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
    BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
    int countBefore = getRegistry().getBeanDefinitionCount();
    /**
     *	关注 registerBeanDefinitions 和 createReaderContext 方法
     */
    documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
    return getRegistry().getBeanDefinitionCount() - countBefore;
}

先看：

org.springframework.beans.factory.xml.XmlBeanDefinitionReader

|-> createReaderContext()

	/**
	 * Create the {@link XmlReaderContext} to pass over to the document reader.
	 */
	public XmlReaderContext createReaderContext(Resource resource) {
		return new XmlReaderContext(resource, this.problemReporter, this.eventListener,
				this.sourceExtractor, this, getNamespaceHandlerResolver());
	}

	/**
	 * Lazily create a default NamespaceHandlerResolver, if not set before.
	 * @see #createDefaultNamespaceHandlerResolver()
	 */
	public NamespaceHandlerResolver getNamespaceHandlerResolver() {
		if (this.namespaceHandlerResolver == null) {
			this.namespaceHandlerResolver = createDefaultNamespaceHandlerResolver();
		}
		return this.namespaceHandlerResolver;
	}

	/**
	 * Create the default implementation of {@link NamespaceHandlerResolver} used if none is specified.
	 * <p>The default implementation returns an instance of {@link DefaultNamespaceHandlerResolver}.
	 * @see DefaultNamespaceHandlerResolver#DefaultNamespaceHandlerResolver(ClassLoader)
	 */
	protected NamespaceHandlerResolver createDefaultNamespaceHandlerResolver() {
		ClassLoader cl = (getResourceLoader() != null ? getResourceLoader().getClassLoader() : getBeanClassLoader());
		return new DefaultNamespaceHandlerResolver(cl);
	}

可以看到此处，spring首先完成了NamespaceHandlerResolver的初始化。

再看：