spring学习笔记（三）（AOP应用以及源码解析）

spring学习笔记（AOP应用以及源码解析）

1-3.aop相关

相关术语：

连接点：⽅法开始时、结束时、正常运⾏完毕时、⽅法异常时等这些特殊的时机点，我们称之为连接点，项⽬中每个⽅法 都有连接点，连接点是⼀种候选点
切⼊点：指定AOP思想想要影响的具体⽅法是哪些，描述感兴趣的⽅法
Advice增强：
第⼀个层次：指的是横切逻辑
第⼆个层次：⽅位点（在某⼀些连接点上加⼊横切逻辑，那么这些连接点就叫做⽅位点，描述的是具体的特殊时机）
Aspect切⾯：切⾯概念是对上述概念的⼀个综合
Aspect切⾯= 切⼊点+增强= 切⼊点（锁定⽅法） + ⽅位点（锁定⽅法中的特殊时机）+ 横切逻辑

AOP的代理选择

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

AOP的配置⽅式以及实现

​ 需求：横切逻辑代码是打印⽇志，希望把打印⽇志的逻辑织⼊到⽬标⽅法的特定位置(service层transfer⽅法)

XML 模式

坐标：

<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>

核⼼配置

<!--
 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配置切⾯
 第四步：使⽤对应的标签配置通知的类型
 ⼊⻔案例采⽤前置通知，标签为aop:before
-->
<!--把通知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>

关于切⼊点表达式

​ 上述配置实现了对 TransferServiceImpl 的 updateAccountByCardNo ⽅法进⾏增强，在其执⾏之前，输出了记录⽇志的语句。 我们接触了⼀个⽐较陌⽣的名称：切⼊点表达式

​ 概念及作⽤
​ 切⼊点表达式，也称之为AspectJ切⼊点表达式，指的是遵循特定语法结构的字符串，其作⽤是⽤于对符合语法格式的连接点进⾏增强。它是AspectJ表达式的⼀部分。

​ 关于AspectJ
​ AspectJ是⼀个基于Java语⾔的AOP框架，Spring框架从2.0版本之后集成了AspectJ框架中切⼊点表达式的部分，开始⽀持AspectJ切⼊点表达式。切⼊点表达式使⽤示例

全限定⽅法名 访问修饰符 返回值 包名.包名.包名.类名.⽅法名(参数列表)
 全匹配⽅式：
 public void com.lagou.service.impl.TransferServiceImpl.updateAccountByCardNo(com.lagou.pojo.Account)
 访问修饰符可以省略
  void  com.lagou.service.impl.TransferServiceImpl.updateAccountByCardNo(com.lagou.pojo.Account)
 返回值可以使⽤*，表示任意返回值
 *
com.lagou.service.impl.TransferServiceImpl.updateAccountByCardNo(com.lagou.pojo.Account)
包名可以使⽤.表示任意包，但是有⼏级包，必须写⼏个
 *....TransferServiceImpl.updateAccountByCardNo(com.lagou.pojo.Account)
 包名可以使⽤..表示当前包及其⼦包
 *..TransferServiceImpl.updateAccountByCardNo(com.lagou.pojo.Account)
 类名和⽅法名，都可以使⽤.表示任意类，任意⽅法
 * ...(com.lagou.pojo.Account)
 参数列表，可以使⽤具体类型
 基本类型直接写类型名称 ： int
 引⽤类型必须写全限定类名：java.lang.String
 参数列表可以使⽤*，表示任意参数类型，但是必须有参数
 * *..*.*(*)
 参数列表可以使⽤..，表示有⽆参数均可。有参数可以是任意类型
 * *..*.*(..)
 全通配⽅式：
 * *..*.*(..)

改变代理⽅式的配置

​ Spring在选择创建代理对象时，会根据被代理对象的实际情况来选择。被代理对象实现了接⼝，则采⽤基于接⼝的动态代理。当被代理对象没有实现任何接⼝的时候，Spring会⾃动切换到基于⼦类的动态代理⽅式。
​ 但是⽆论被代理对象是否实现接⼝，只要不是final修饰的类都可以采⽤cglib提供的⽅式创建代理对象。所以Spring也考虑到了这个情况，提供了配置的⽅式实现强制使⽤基于⼦类的动态代理（即cglib的⽅式），配置的⽅式有两种

1.使⽤aop:config标签配置

<aop:config proxy-target-class="true">

2.使⽤aop:aspectj-autoproxy标签配置

<!--此标签是基于XML和注解组合配置AOP时的必备标签，表示Spring开启注解配置AOP的⽀持-->
<aop:aspectj-autoproxy proxy-target-class="true"></aop:aspectjautoproxy>

五种通知类型

前置通知

执⾏时机 前置通知永远都会在切⼊点⽅法（业务核⼼⽅法）执⾏之前执⾏。
细节 前置通知可以获取切⼊点⽅法的参数，并对其进⾏增强。

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

正常执⾏时通知

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

异常通知

执⾏时机 在切⼊点⽅法（业务核⼼⽅法）执⾏产⽣异常之后，如果切⼊点⽅法执⾏没产⽣异常，异常通知不会执⾏。
细节 异常通知不仅可以获取切⼊点⽅法执⾏的参数，也可以获取切⼊点⽅法执⾏产⽣的异常信息。

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

最终通知

执⾏时机 是在切⼊点⽅法（业务核⼼⽅法）执⾏完成之后，切⼊点⽅法返回之前执⾏。换句话说，⽆论切⼊点⽅法执⾏是否产⽣异常，它都会在返回之前执⾏。
细节 最终通知执⾏时，可以获取到通知⽅法的参数。同时它可以做⼀些清理操作

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

环绕通知

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

特别说明

环绕通知，它是有别于前⾯四种通知类型外的特殊通知。前⾯四种通知（前置，后置，异常和最终）
它们都是指定何时增强的通知类型。⽽环绕通知，它是Spring框架为我们提供的⼀种可以通过编码的
⽅式，控制增强代码何时执⾏的通知类型。它⾥⾯借助的ProceedingJoinPoint接⼝及其实现类，
实现⼿动触发切⼊点⽅法的调⽤。

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;
     }
}

注解模式

注解替换掉配置⽂件中的下⾯这⾏配置：

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

配置类中使⽤如下注解进⾏替换上述配置

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

4-6.Spring声明式事务

编程式事务：在业务代码中添加事务控制代码，这样的事务控制机制就叫做编程式事务
声明式事务：通过xml或者注解配置的⽅式达到事务控制的⽬的，叫做声明式事务

关于事务

事务的概念

​ 事务指逻辑上的⼀组操作，组成这组操作的各个单元，要么全部成功，要么全部不成功。从⽽确保了数据的准确与安全

四⼤特性

原⼦性（Atomicity） 原⼦性是指事务是⼀个不可分割的⼯作单位，事务中的操作要么都发⽣，要么都不发⽣。从操作的 ⻆度来描述，事务中的各个操作要么都成功要么都失败
⼀致性（Consistency） 事务必须使数据库从⼀个⼀致性状态变换到另外⼀个⼀致性状态。例如转账前A有1000，B有 1000。转账后A+B也得是2000。⼀致性是从数据的⻆度来说的，（1000，1000） （900，1100），不应该出现 （900，1000）
隔离性（Isolation） 事务的隔离性是多个⽤户并发访问数据库时，数据库为每⼀个⽤户开启的事务，每个事务不能被其 他事务的操作数据所⼲扰，多个并发事务之间要相互隔离。
⽐如：事务1给员⼯涨⼯资2000，但是事务1尚未被提交，员⼯发起事务2查询⼯资，发现⼯资涨了2000块钱，读到了事 务1尚未提交的数据（脏读）
持久性（Durability）
持久性是指⼀个事务⼀旦被提交，它对数据库中数据的改变就是永久性的，接下来即使数据库发⽣故障也不应该对其有任何影响。

事务的隔离级别

不考虑隔离级别，会出现以下情况：（以下情况全是错误的），也即为隔离级别在解决事务并发问题
**脏读：**⼀个线程中的事务读到了另外⼀个线程中未提交的数据。
不可重复读：⼀个线程中的事务读到了另外⼀个线程中已经提交的update的数据（前后内容不⼀样）
场景：
员⼯A发起事务1，查询⼯资，⼯资为1w，此时事务1尚未关闭
财务⼈员发起了事务2，给员⼯A张了2000块钱，并且提交了事务
员⼯A通过事务1再次发起查询请求，发现⼯资为1.2w，原来读出来1w读不到了，叫做不可重复读
**虚读（幻读）：**⼀个线程中的事务读到了另外⼀个线程中已经提交的insert或者delete的数据（前后条数不⼀样

场景： 事务1查询所有⼯资为1w的员⼯的总数，查询出来了10个⼈，此时事务尚未关闭
事务2财务⼈员发起，新来员⼯，⼯资1w，向表中插⼊了2条数据，并且提交了事务
事务1再次查询⼯资为1w的员⼯个数，发现有12个⼈

数据库共定义了四种隔离级别：
Serializable（串⾏化）：可避免脏读、不可重复读、虚读情况的发⽣。（串⾏化） 最⾼
Repeatable read（可重复读）：可避免脏读、不可重复读情况的发⽣。(幻读有可能发⽣) 第⼆

​ 该机制下会对要update的 ⾏进⾏加锁
Read committed（读已提交）：可避免脏读情况发⽣。不可重复读和幻读⼀定会发⽣。 第三
Read uncommitted（读未提交）：最低级别，以上情况均⽆法保证。(读未提交) 最低

注意：级别依次升⾼，效率依次降低
MySQL的默认隔离级别是：REPEATABLE READ
查询当前使⽤的隔离级别： select @@tx_isolation;
设置MySQL事务的隔离级别： set session transaction isolation level xxx; （设置的是当前mysql连接会话的，并不是永久改变的）

事务的传播⾏为

​ 事务往往在service层进⾏控制，如果出现service层⽅法A调⽤了另外⼀个service层⽅法B，A和B⽅法本身都已经被添加了事务控制，那么A调⽤B的时候，就需要进⾏事务的⼀些协商，这就叫做事务的传播⾏为。

Spring中事务的API

mybatis: sqlSession.commit();
hibernate: session.commit();

PlatformTransactionManager

public interface PlatformTransactionManager {
 /*** 获取事务状态信息
 */
 TransactionStatus getTransaction(@Nullable TransactionDefinition definition)
throws TransactionException;
 /**
 * 提交事务
 */
 void commit(TransactionStatus status) throws TransactionException;
 /**
 * 回滚事务
 */
 void rollback(TransactionStatus status) throws TransactionException;
}

作⽤
此接⼝是Spring的事务管理器核⼼接⼝。Spring本身并不⽀持事务实现，只是负责提供标准，应⽤底层⽀持什么样的事务，需要提供具体实现类。此处也是策略模式的具体应⽤。在Spring框架中，也为我们内置了⼀些具体策略，例如：DataSourceTransactionManager , HibernateTransactionManager 等等。（ 和 HibernateTransactionManager 事务管理器在 spring-orm-5.1.12.RELEASE.jar 中）
Spring JdbcTemplate（数据库操作⼯具）、Mybatis（mybatis-spring.jar）————>DataSourceTransactionManager
Hibernate框架 ——————> HibernateTransactionManager
DataSourceTransactionManager 归根结底是横切逻辑代码，声明式事务要做的就是使⽤Aop（动态代理）来将事务控制逻辑织⼊到业务代码

Spring 声明式事务配置

纯xml模式

pom依赖:

<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>

xml 配置

<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>

基于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)

基于纯注解

​ Spring基于注解驱动开发的事务控制配置，只需要把 xml 配置部分改为注解实现。只是需要⼀个注解替换掉xml配置⽂件中的 <tx:annotation-driven transactionmanager=“transactionManager”/> 配置。在 Spring 的配置类上添加 @EnableTransactionManagement 注解即可

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

7-8.源码解析

代理对象创建

AOP基础⽤例

Bean定义

@Component
public class LagouBean {
     public void tech(){
     	System.out.println("java learning......");
     }
}

Aspect定义

package com.lagou;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;
@Component
@Aspect
public class LagouAspect {
     @Pointcut("execution(* com.lagou.*.*(..))")
     public void pointcut(){
     }
     @Before("pointcut()")
     public void before() {
     	System.out.println("before method ......");
     }
 }

测试⽤例

/**
* 测试⽤例：Aop 代理对象创建
*/
@Test
public void testAopProxyBuild(){
 ApplicationContext applicationContext = new  AnnotationConfigApplicationContext(SpringConfig.class);
 LagouBean lagouBean = applicationContext.getBean(LagouBean.class);
 lagouBean.tech();
}

时机点分析

​ 在 getBean 之前，LagouBean对象已经产⽣（即在第⼀⾏初始化代码中完成），⽽且该对象是⼀个代理对象（Cglib代理对象），我们断定，容器初始化过程中⽬标Ban已经完成了代理，返回了代理对象。

代理对象创建流程

Spring声明式事务控制

@EnableTransactionManagement

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(TransactionManagementConfigurationSelector.class)
public @interface EnableTransactionManagement {}

@EnableTransactionManagement 注解使⽤ @Import 标签引⼊了
TransactionManagementConfigurationSelector类，这个类⼜向容器中导⼊了两个重要的组件

@Transactional