Spring AOP与事务

目录

1.AOP简介

1.1什么是AOP

1.2AOP作用

1.3AOP核心概念

2.AOP入门案例

2.1需求分析

2.2思路分析

2.3环境准备

2.4AOP实现步骤

3.AOP工作流程

3.1AOP工作流程

流程1:Spring容器启动

流程2:读取所有切面配置中的切入点

流程3:初始化bean

流程4:获取bean执行方法

3.2AOP核心概念

4.AOP配置管理

4.1AOP切入点表达式

4.1.1语法格式

4.1.2通配符

 4.1.3书写技巧

4.2AOP通知类型

4.2.1类型介绍

4.3业务层接口执行效率

4.3.1需求分析

4.3.2环境准备

4.3.3功能开发

4.4AOP通知获取数据

4.4.1获取参数

4.4.2获取返回值

 4.4.3获取异常

5.AOP总结

5.1 AOP的核心概念

5.2 切入点表达式

5.3 五种通知类型

5.4 通知中获取参数

6.AOP事务管理

6.1Spring事务简介

6.1.1相关概念介绍

6.1.3转账案例-环境搭建

6.1.4事务管理

6.2 Spring事务角色

6.3 Spring事务属性

1.AOP简介

1.1什么是AOP

AOP(Aspect Oriented Programming) 面向切面编程，一种编程范式，指导开发者如何组织程

序结构。 AOP 是一种编程思想，编程思想主要的内容就是指导程序员该 如何编写程序。

1.2AOP作用

作用 : 在不惊动原始设计的基础上为其进行功能增强，前面咱们有技术就可以实现这样的功能即代

理模式。

1.3AOP核心概念

为了能更好的理解 AOP 的相关概念，我们准备了一个环境，整个环境的内容我们暂时可以不用关

注，最主要的类为 : BookDaoImpl

 
@Repository
public class BookDaoImpl implements BookDao {
 
    public void save() {
        //记录程序当前执行执行（开始时间）
        Long startTime = System.currentTimeMillis();
        //业务执行万次
        for (int i = 0;i<10000;i++) {
            System.out.println("book dao save ...");
        }
        //记录程序当前执行时间（结束时间）
        Long endTime = System.currentTimeMillis();
        //计算时间差
        Long totalTime = endTime-startTime;
        //输出信息
        System.out.println("执行万次消耗时间：" + totalTime + "ms");
    }
 
    public void update(){
        System.out.println("book dao update ...");
    }
 
    public void delete(){
        System.out.println("book dao delete ...");
    }
 
    public void select(){
        System.out.println("book dao select ...");
    }
}

当在 App 类中从容器中获取 bookDao 对象后，分别执行其 save , delete , update 和 select 方法后会

有如下的打印结果 :

对于计算万次执行消耗的时间只有 save 方法有，为什么 delete 和 update 方法也会有呢 ?

delete 和 update 方法有，那什么 select 方法为什么又没有呢 ?

这个案例中其实就使用了 Spring 的 AOP ，在不惊动 ( 改动 ) 原有设计 ( 代码 ) 的前提下，想给谁添

加功 能 就给谁添加。这个也就是 Spring 的理念：

AOP实现原理图：

2.3环境准备

创建一个Maven项目

pom.xml添加Spring依赖

    <dependencies>
        <dependency>
            <groupId>org.springframeworkgroupId>
            <artifactId>spring-contextartifactId>
            <version>5.2.10.RELEASEversion>
        dependency>
    dependencies>

package com.itheima.dao;
 
public interface BookDao {
 
    public void save();
    public void update();
}

package com.itheima.dao.impl;
 
import com.itheima.dao.BookDao;
import org.springframework.stereotype.Repository;
 
@Repository
public class BookDaoImpl implements BookDao {
    @Override
    public void save() {
        System.out.println(System.currentTimeMillis());
        System.out.println("book dao save ...");
    }
 
    @Override
    public void update() {
        System.out.println(System.currentTimeMillis());
        System.out.println("book dao update ...");
    }
}

package com.itheima.config;
 
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
 
@Configuration
@ComponentScan("com.itheima")
public class SpringConfig {
}

编写 App 运行类

package com.itheima;
 
import com.itheima.config.SpringConfig;
import com.itheima.dao.BookDao;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
 
public class App {
    public static void main(String[] args) {
        ApplicationContext applicationContext = new AnnotationConfigApplicationContext(SpringConfig.class);
        BookDao bookDao = applicationContext.getBean(BookDao.class);
        bookDao.save();
    }
}

最终创建好的项目结构如下 :

2.4AOP实现步骤

    <dependency>
      <groupId>org.aspectjgroupId>
      <artifactId>aspectjweaverartifactId>
      <version>1.9.4version>
    dependency>

因为spring-context中已经导入了spring-aop ,所以不需要再单独导入spring-aop

public class MyAdvice {
    public void method(){
        System.out.println(System.currentTimeMillis());
    }
}

public class MyAdvice {
    //设置切入点，要求配置在方法上方
    @Pointcut("execution(void com.itheima.dao.BookDao.update())")
    private void pt(){}
 
    public void method(){
        System.out.println(System.currentTimeMillis());
    }
}

public class MyAdvice {
    //设置切入点，要求配置在方法上方
    @Pointcut("execution(void com.itheima.dao.BookDao.update())")
    private void pt(){}
 
    //设置在切入点pt()的前面运行当前操作（前置通知）
    // @Before("pt()")
    public void method(){
        System.out.println(System.currentTimeMillis());
    }
}

@Component
//设置当前类为切面类类
@Aspect
public class MyAdvice {
    //设置切入点，要求配置在方法上方
    @Pointcut("execution(void com.itheima.dao.BookDao.update())")
    private void pt(){}
 
    //设置在切入点pt()的前面运行当前操作（前置通知）
    // @Before("pt()")
    public void method(){
        System.out.println(System.currentTimeMillis());
    }
}

步骤 7: 开启注解格式 AOP 功能

@Configuration
@ComponentScan("com.itheima")
//开启注解开发AOP功能
@EnableAspectJAutoProxy
public class SpringConfig {
}

步骤 8: 运行程序

public class App {
    public static void main(String[] args) {
        ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
        BookDao bookDao = ctx.getBean(BookDao.class);
        bookDao.update();
    }
}

看到在执行 update 方法之前打印了系统时间戳，说明对原始方法进行了增强， AOP 编程成功。

3.AOP工作流程

知识点 : AOP 工作流程 和 AOP 核心概念 。

3.1AOP工作流程

由于 AOP 是基于 Spring 容器管理的 bean 做的增强，所以整个工作过程需要从 Spring 加载 bean 说起 :

流程1:Spring容器启动

容器启动就需要去加载 bean, 哪些类需要被加载呢 ?

需要被增强的类，如 :BookServiceImpl

通知类，如 :MyAdvice

注意此时 bean 对象还没有创建成功

流程2:读取所有切面配置中的切入点

 上面这个例子中有两个切入点的配置，但是第一个ptx()并没有被使用，所以不会被读取。

流程3:初始化bean

判定bean对应的类中的方法是否匹配到任意切入点

注意第 1 步在容器启动的时候， bean 对象还没有被创建成功。

要被实例化 bean 对象的类中的方法和切入点进行匹配

匹配失败，创建原始对象,如UserDao

匹配失败说明不需要增强，直接调用原始对象的方法即可。

匹配成功，创建原始对象（目标对象）的代理对象,如: BookDao

匹配成功说明需要对其进行增强

对哪个类做增强，这个类对应的对象就叫做目标对象

因为要对目标对象进行功能增强，而采用的技术是动态代理，所以会为其创建一个代理对象

最终运行的是代理对象的方法，在该方法中会对原始方法进行功能增强

流程4:获取bean执行方法

获取的 bean 是原始对象时，调用方法并执行，完成操作

获取的 bean 是代理对象时，根据代理对象的运行模式运行原始方法与增强的内容，完成操作

验证容器中是否为代理对象

为了验证 IOC 容器中创建的对象和我们刚才所说的结论是否一致，首先先把结论理出来 :

如果目标对象中的方法会被增强，那么容器中将存入的是目标对象的代理对象

如果目标对象中的方法不被增强，那么容器中将存入的是目标对象本身。

验证思路

1. 要执行的方法，不被定义的切入点包含，即不要增强，打印当前类的 getClass() 方法

2. 要执行的方法，被定义的切入点包含，即要增强，打印出当前类的 getClass() 方法

3. 观察两次打印的结果

 步骤1:修改App类,获取类的类型

public class App {
    public static void main(String[] args) {
        ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
        BookDao bookDao = ctx.getBean(BookDao.class);
//        bookDao.update();
        System.out.println(bookDao);
        System.out.println(bookDao.getClass());
    }
}

@Component
//设置当前类为切面类类
@Aspect
public class MyAdvice {
    //设置切入点，要求配置在方法上方
    @Pointcut("execution(void com.itheima.dao.BookDao.update1())")
    private void pt(){}
 
    //设置在切入点pt()的前面运行当前操作（前置通知）
    // @Before("pt()")
    public void method(){
        System.out.println(System.currentTimeMillis());
    }

步骤 3: 运行程序

步骤 4: 修改 MyAdvice 类，增强

因为定义的切入点中，被修改成 update , 所以 BookDao 中的 update 方法在执行的时候，就会被增

强，所以容器中的对象应该是目标对象的代理对象

@Component
//设置当前类为切面类类
@Aspect
public class MyAdvice {
    //设置切入点，要求配置在方法上方
    @Pointcut("execution(void com.itheima.dao.BookDao.update())")
    private void pt(){}
 
    //设置在切入点pt()的前面运行当前操作（前置通知）
    // @Before("pt()")
    public void method(){
        System.out.println(System.currentTimeMillis());
    }

步骤 5: 运行程序

至此对于刚才的结论，我们就得到了验证，这块大家需要注意的是 :

不能直接打印对象，从上面两次结果中可以看出，直接打印对象走的是对象的toString方法，不管

是不是代理对象打印的结果都是一样的，原因是内部对toString方法进行了重写。

3.2AOP核心概念

目标对象(Target) ：原始功能去掉共性功能对应的类产生的对象，这种对象是无法直接完成最终

工作的

代理(Proxy) ：目标对象无法直接完成工作，需要对其进行功能回填，通过原始对象的代理对象实

现

上面这两个概念比较抽象，简单来说，

目标对象就是要增强的类 [ 如 :BookServiceImpl 类 ] 对应的对象，也叫原始对象，不能说它不能运

行，只能说它在运行的过程中对于要增强的内容是缺失的。

SpringAOP 是在不改变原有设计 ( 代码 ) 的前提下对其进行增强的，它的底层采用的是代理模式实现

的，所以要对原始对象进行增强，就需要对原始对象创建代理对象，在代理对象中的方法把通知

[ 如 :MyAdvice 中的 method 方法 ] 内容加进去，就实现了增强 , 这就是我们所说的代理 (Proxy) 。

AOP 的核心概念

目标对象、连接点、切入点

通知类、通知

切面

代理

SpringAOP 的本质或者可以说底层实现是通过代理模式。

4.AOP配置管理

4.1AOP切入点表达式

是 语法格式 、 通配符 和 书写技巧 。

4.1.1语法格式

切入点 : 要进行增强的方法

切入点表达式 : 要进行增强的方法的描述方式

对于切入点的描述，我们其实是有两中方式的，先来看下前面的例子

对于切入点表达式的语法为:

切入点表达式标准格式：动作关键字(访问修饰符 返回值 包名.类/接口名.方法名(参数) 异常

名）

execution(public User com.itheima.service.UserService.findById(int))

execution ：动作关键字，描述切入点的行为动作，例如 execution 表示执行到指定切入点

public: 访问修饰符 , 还可以是 public ， private 等，可以省略

User ：返回值，写返回值类型

com.itheima.service ：包名，多级包使用点连接

UserService: 类 / 接口名称

findById ：方法名

int: 参数，直接写参数的类型，多个类型用逗号隔开

异常名：方法定义中抛出指定异常，可以省略

4.1.2通配符

 4.1.3书写技巧

所有代码按照标准规范开发，否则以下技巧全部失效

描述切入点通 常描述接口 ，而不描述实现类 , 如果描述到实现类，就出现紧耦合了

访问控制修饰符针对接口开发均采用 public 描述（ 可省略访问控制修饰符描述 ）

返回值类型对于增删改类使用精准类型加速匹配，对于查询类使用 * 通配快速描述

包名 书写 尽量不使用 .. 匹配 ，效率过低，常用 * 做单个包描述匹配，或精准匹配

接口名 / 类名 书写名称与模块相关的 采用 * 匹配 ，例如 UserService 书写成 *Service ，绑定业务

层接口名

方法名 书写以 动词 进行 精准匹配 ，名词采用 匹配，例如 getById 书写成 getBy ,selectAll 书写成

selectAll

参数规则较为复杂，根据业务方法灵活调整

通常 不使用异常 作为 匹配 规则

4.2AOP通知类型

4.2.1类型介绍

共提供了 5 种通知类型 :

前置通知

后置通知

环绕通知 ( 重点 )

返回后通知 ( 了解 )

抛出异常后通知 ( 了解 )

 知识点3：@AfterThrowing

 知识点4：@Around

环绕通知注意事项

1. 环绕通知必须依赖形参 ProceedingJoinPoint 才能实现对原始方法的调用，进而实现原始方法

调用前后同时添加通知

2. 通知中如果未使用 ProceedingJoinPoint 对原始方法进行调用将跳过原始方法的执行

3. 对原始方 法的调用可以不接收返回值，通知方法设置成 void 即可，如果接收返回值，最好

设定为 Object 类型

4. 原始方法的返回值如果是 void 类型，通知方法的返回值类型可以设置成 void, 也可以设置成

Object

5. 由于无法预知原始方法运行后是否会抛出异常，因此环绕通知方法必须要处理 Throwable 异常

4.3业务层接口执行效率

4.3.1需求分析

需求 : 任意业务层接口执行均可显示其执行效率（执行时长）

具体实现的思路 :

(1) 开始执行方法之前记录一个时间

(2) 执行方法

(3) 执行完方法之后记录一个时间

(4) 用后一个时间减去前一个时间的差值，就是我们需要的结果

4.3.2环境准备

  <dependencies>
    <dependency>
      <groupId>org.springframeworkgroupId>
      <artifactId>spring-contextartifactId>
      <version>5.2.10.RELEASEversion>
    dependency>
 
    <dependency>
      <groupId>org.springframeworkgroupId>
      <artifactId>spring-jdbcartifactId>
      <version>5.2.10.RELEASEversion>
    dependency>
 
    <dependency>
      <groupId>org.springframeworkgroupId>
      <artifactId>spring-testartifactId>
      <version>5.2.10.RELEASEversion>
    dependency>
 
    <dependency>
      <groupId>org.aspectjgroupId>
      <artifactId>aspectjweaverartifactId>
      <version>1.9.4version>
    dependency>
 
    <dependency>
      <groupId>mysqlgroupId>
      <artifactId>mysql-connector-javaartifactId>
      <version>5.1.47version>
    dependency>
 
    <dependency>
      <groupId>com.alibabagroupId>
      <artifactId>druidartifactId>
      <version>1.1.16version>
    dependency>
 
    <dependency>
      <groupId>org.mybatisgroupId>
      <artifactId>mybatisartifactId>
      <version>3.5.6version>
    dependency>
 
    <dependency>
      <groupId>org.mybatisgroupId>
      <artifactId>mybatis-springartifactId>
      <version>1.3.0version>
    dependency>
 
    <dependency>
      <groupId>junitgroupId>
      <artifactId>junitartifactId>
      <version>4.12version>
      <scope>testscope>
    dependency>
  dependencies>

添加 AccountService 、 AccountServiceImpl 、 AccountDao 与 Account 类

package com.itheima.service;
 
import com.itheima.domain.Account;
 
import java.util.List;
 
public interface AccountService {
 
    void save(Account account);
 
    void delete(Integer id);
 
    void update(Account account);
 
    List findAll();
 
    Account findById(Integer id);
 
}
 
package com.itheima.service.impl;
 
import com.itheima.dao.AccountDao;
import com.itheima.domain.Account;
import com.itheima.service.AccountService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
 
import java.util.List;
@Service
public class AccountServiceImpl implements AccountService {
 
    @Autowired
    private AccountDao accountDao;
 
    public void save(Account account) {
        accountDao.save(account);
    }
 
    public void update(Account account){
        accountDao.update(account);
    }
 
    public void delete(Integer id) {
        accountDao.delete(id);
    }
 
    public Account findById(Integer id) {
        return accountDao.findById(id);
    }
 
    public List findAll() {
        return accountDao.findAll();
    }
}
 
package com.itheima.domain;
 
import java.io.Serializable;
 
public class Account implements Serializable {
 
    private Integer id;
    private String name;
    private Double money;
 
    public Integer getId() {
        return id;
    }
 
    public void setId(Integer id) {
        this.id = id;
    }
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public Double getMoney() {
        return money;
    }
 
    public void setMoney(Double money) {
        this.money = money;
    }
 
    @Override
    public String toString() {
        return "Account{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", money=" + money +
                '}';
    }
}
 
package com.itheima.dao;
 
import com.itheima.domain.Account;
import org.apache.ibatis.annotations.Delete;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.annotations.Update;
 
import java.util.List;
 
public interface AccountDao {
 
    @Insert("insert into tbl_account(name,money)values(#{name},#{money})")
    void save(Account account);
 
    @Delete("delete from tbl_account where id = #{id} ")
    void delete(Integer id);
 
    @Update("update tbl_account set name = #{name} , money = #{money} where id = #{id} ")
    void update(Account account);
 
    @Select("select * from tbl_account")
    List findAll();
 
    @Select("select * from tbl_account where id = #{id} ")
    Account findById(Integer id);
}

resources 下提供一个 jdbc.properties

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/spring_db?useSSL=false
jdbc.username=root
jdbc.password=root

创建相关配置类

package com.itheima.config;
 
import org.springframework.context.annotation.*;
 
@Configuration
@ComponentScan("com.itheima")
@PropertySource("classpath:jdbc.properties")
@Import({JdbcConfig.class,MybatisConfig.class})
public class SpringConfig {
}
 
 
package com.itheima.config;
 
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.mapper.MapperScannerConfigurer;
import org.springframework.context.annotation.Bean;
 
import javax.sql.DataSource;
 
public class MybatisConfig {
 
    @Bean
    public SqlSessionFactoryBean sqlSessionFactory(DataSource dataSource){
        SqlSessionFactoryBean ssfb = new SqlSessionFactoryBean();
        ssfb.setTypeAliasesPackage("com.itheima.domain");
        ssfb.setDataSource(dataSource);
        return ssfb;
    }
 
    @Bean
    public MapperScannerConfigurer mapperScannerConfigurer(){
        MapperScannerConfigurer msc = new MapperScannerConfigurer();
        msc.setBasePackage("com.itheima.dao");
        return msc;
    }
}
 
 
package com.itheima.config;
 
import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
 
import javax.sql.DataSource;
 
 
public class JdbcConfig {
    @Value("${jdbc.driver}")
    private String driver;
    @Value("${jdbc.url}")
    private String url;
    @Value("${jdbc.username}")
    private String userName;
    @Value("${jdbc.password}")
    private String password;
 
    @Bean
    public DataSource dataSource(){
        DruidDataSource ds = new DruidDataSource();
        ds.setDriverClassName(driver);
        ds.setUrl(url);
        ds.setUsername(userName);
        ds.setPassword(password);
        return ds;
    }
}

编写 Spring 整合 Junit 的测试类

package com.itheima.service;
 
import com.itheima.config.SpringConfig;
import com.itheima.domain.Account;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
 
import java.util.List;
 
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfig.class)
public class AccountServiceTestCase {
    @Autowired
    private AccountService accountService;
 
    @Test
    public void testFindById(){
        Account ac = accountService.findById(2);
    }
 
    @Test
    public void testFindAll(){
        List all = accountService.findAll();
    }
 
}

最终创建好的项目结构如下 :

4.3.3功能开发

步骤 1: 开启 SpringAOP 的注解功能

在 Spring 的主配置文件 SpringConfig 类中添加注解

@EnableAspectJAutoProxy

步骤 2: 创建 AOP 的通知类

该类要被 Spring 管理，需要添加 @Component

要标识该类是一个 AOP 的切面类，需要添加 @Aspect

配置切入点表达式，需要添加一个方法，并添加 @Pointcut

@Component
@Aspect
public class ProjectAdvice {
    //匹配业务层的所有方法
    @Pointcut("execution(* com.itheima.service.*Service.*(..))")
    private void servicePt(){}
    
    public void runSpeed(){
    }
}

步骤 3: 添加环绕通知

在 runSpeed() 方法上添加 @Around

@Component
@Aspect
public class ProjectAdvice {
    //匹配业务层的所有方法
    @Pointcut("execution(* com.itheima.service.*Service.*(..))")
    private void servicePt(){}
    //@Around("ProjectAdvice.servicePt()") 可以简写为下面的方式
    @Around("servicePt()")
    public void runSpeed(){
    }
}

@Component
@Aspect
public class ProjectAdvice {
    //匹配业务层的所有方法
    @Pointcut("execution(* com.itheima.service.*Service.*(..))")
    private void servicePt(){}
    //@Around("ProjectAdvice.servicePt()") 可以简写为下面的方式
    @Around("servicePt()")
    public void runSpeed(ProceedingJoinPoint pjp){
        long start = System.currentTimeMillis();
        for(int i = 0; i < 100; i++){
            pjp.proceed();
         }
        long end = System.currentTimeMillis();
        System.out.println("业务层接口万次执行时间: "+(end-start)+"ms");
    }
}

 步骤6:程序优化

@Component
@Aspect
public class ProjectAdvice {
    //匹配业务层的所有方法
    @Pointcut("execution(* com.itheima.service.*Service.*(..))")
    private void servicePt(){}
 
    //设置环绕通知，在原始操作的运行前后记录执行时间
    @Around("ProjectAdvice.servicePt()")
    public void runSpeed(ProceedingJoinPoint pjp) throws Throwable {
        //获取执行的签名对象
        Signature signature = pjp.getSignature();
        String className = signature.getDeclaringTypeName();
        String methodName = signature.getName();
 
        long start = System.currentTimeMillis();
        for (int i = 0; i < 10000; i++) {
           pjp.proceed();
        }
        long end = System.currentTimeMillis();
        System.out.println("万次执行："+ className+"."+methodName+"---->" +(end-start) + "ms");
    }
 
}

4.4AOP通知获取数据

4.4.1获取参数

@Component
@Aspect
public class MyAdvice {
    @Pointcut("execution(* com.itheima.dao.BookDao.findName(..))")
    private void pt(){}
 
    //JoinPoint：用于描述切入点的对象，必须配置成通知方法中的第一个参数，可用于获取原始方法调用的参数
//    @Before("pt()")
    public void before(JoinPoint jp) {
        Object[] args = jp.getArgs();
        System.out.println(Arrays.toString(args));
        System.out.println("before advice ..." );
    }
 
//    @After("pt()")
    public void after(JoinPoint jp) {
        Object[] args = jp.getArgs();
        System.out.println(Arrays.toString(args));
        System.out.println("after advice ...");
    }
 
    //ProceedingJoinPoint：专用于环绕通知，是JoinPoint子类，可以实现对原始方法的调用
//    @Around("pt()")
    public Object around(ProceedingJoinPoint pjp) {
        Object[] args = pjp.getArgs();
        System.out.println(Arrays.toString(args));
        args[0] = 666;
        Object ret = null;
        try {
            ret = pjp.proceed(args);
        } catch (Throwable t) {
            t.printStackTrace();
        }
        return ret;
    }
 
    //设置返回后通知获取原始方法的返回值，要求returning属性值必须与方法形参名相同
    @AfterReturning(value = "pt()",returning = "ret")
    public void afterReturning(JoinPoint jp,String ret) {
        System.out.println("afterReturning advice ..."+ret);
    }
 
    //设置抛出异常后通知获取原始方法运行时抛出的异常对象，要求throwing属性值必须与方法形参名相同
    @AfterThrowing(value = "pt()",throwing = "t")
    public void afterThrowing(Throwable t) {
        System.out.println("afterThrowing advice ..."+t);
    }
}

public class App {
    public static void main(String[] args) {
        ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
        BookDao bookDao = ctx.getBean(BookDao.class);
        String name = bookDao.findName(100,"itheima");
        System.out.println(name);
    }
}

 运行App类，可以获取如下内容，说明参数100已经被获取

 使用JoinPoint的方式获取参数适用于前置、后置、返回后、抛出异常后通知。

环绕通知获取方式

注意 :

pjp.proceed() 方法是有两个构造方法，分别是 :

调用无参数的 proceed ，当原始方法有参数，会在调用的过程中自动传入参数

所以调用这两个方法的任意一个都可以完成功能

但是当需要修改原始方法的参数时，就只能采用带有参数的方法 , 如下 :

//    ProceedingJoinPoint：专用于环绕通知，是JoinPoint子类，可以实现对原始方法的调用
    @Around("pt()")
    public Object around(ProceedingJoinPoint pjp) {
        Object[] args = pjp.getArgs();
        System.out.println(Arrays.toString(args));
        args[0] = 666;
        Object ret = null;
        try {
            ret = pjp.proceed(args);
        } catch (Throwable t) {
            t.printStackTrace();
        }
        return ret;
    }

4.4.2获取返回值

对于返回值，只有返回后AfterReturing和环绕Around 这两个通知类型可以获取，具体如何获取 ?

对于@Around使用pjp.proceed()可以获得原始方法的返回值，并且我们可以进行修改

对于@AfterReturning，需要在注解处进行声明，retuning="ret",目标方法参数为ret。

注意 :

(1) 参数名的问题

(2)afterReturning 方法参数类型的问题

参数类型可以写成 String ，但是为了能匹配更多的参数类型，建议写成 Object 类型

(3)afterReturning 方法参数的顺序问题

 4.4.3获取异常

在AOP中的 catch 方法中就可以获取到异常，至于获取到异常以后该如何处理，这个就和你的业务

需求有关 了。

注意:

在原始方法中抛出异常，在目标方法中注解使用throwing="t"，对异常进行接收

运行 App 后，查看控制台，就能看的异常信息被打印到控制台

5.AOP总结

5.1 AOP的核心概念

概念： AOP(Aspect Oriented Programming) 面向切面编程，一种编程范式

作用：在不惊动原始设计的基础上为方法进行功能 增强

核心概念

代理（ Proxy ）： SpringAOP 的核心本质是采用代理模式实现的

连接点（ JoinPoint ）：在 SpringAOP 中，理解为任意方法的执行

切入点（ Pointcut ）：匹配连接点的式子，也是具有共性功能的方法描述

通知（ Advice ）：若干个方法的共性功能，在切入点处执行，最终体现为一个方法

切面（ Aspect ）：描述通知与切入点的对应关系

目标对象（ Target ）：被代理的原始对象成为目标对象

5.2 切入点表达式

切入点表达式标准格式：动作关键字 ( 访问修饰符 返回值 包名 . 类 / 接口名 . 方法名（参数）异常

名) execution(* com.itheima.service.*Service.*(..))

切入点表达式描述通配符：

作用：用于快速描述，范围描述

* ：匹配任意符号（常用）

.. ：匹配多个连续的任意符号（常用）

+ ：匹配子类类型

切入点表达式书写技巧

1. 按 标准规范 开发 2. 查询操作的返回值建议使用 * 匹配 3. 减少使用 .. 的形式描述包 4. 对接口

进行描述 ，使用 * 表示模块名，例如 UserService 的匹配描述为 *Service 5. 方法名书写保留动

词，例如 get ，使用 * 表示名词，例如 getById 匹配描述为 getBy* 6. 参数根据实际情况灵活调整

5.3 五种通知类型

前置通知

后置通知

环绕通知（重点）

        环绕通知依赖形参ProceedingJoinPoint 才能实现对原始方法的调用

        环绕通知可以隔离原始方法的调用执行

        环绕通知返回值设置为Object 类型

        环绕通知中可以对原始方法调用过程中出现的异常进行处理

返回后通知

抛出异常后通知

5.4 通知中获取参数

获取切入点方法的参数，所有的通知类型都可以获取参数

        JoinPoint：适用于前置、后置、返回后、抛出异常后通知

        

        ProceedingJoinPoint：适用于环绕通知

获取切入点方法返回值，前置和抛出异常后通知是没有返回值，后置通知可有可无，所以不做研究

        返回后通知

        环绕通知

获取切入点方法运行异常信息，前置和返回后通知是不会有，后置通知可有可无，所以不做研究

        抛出异常后通知

        

        环绕通知

6.AOP事务管理

6.1Spring事务简介

6.1.1相关概念介绍

Spring 为了管理事务，提供了一个平台事务管理器 PlatformTransactionManager

commit 是用来提交事务， rollback 是用来回滚事务。

PlatformTransactionManager 只是一个接口， Spring 还为其提供了一个具体的实现 :

从名称上可以看出，我们只需要给它一个 DataSource 对象，它就可以帮你去在业务层管理事

务。

其内部采用的是 JDBC 的事务。所以说如果你持久层采用的是 JDBC 相关的技术，就可以采用

这个 事务管理 器来管理你的事务。而 Mybatis 内部采用的就是 JDBC 的事务，所以后期我们

Spring 整合 Mybatis 就 采用的这个 DataSourceTransactionManager 事务管理器。

6.1.3转账案例-环境搭建

步骤2:创建项目导入jar包

  <dependencies>
    <dependency>
      <groupId>org.springframeworkgroupId>
      <artifactId>spring-contextartifactId>
      <version>5.2.10.RELEASEversion>
    dependency>
    <dependency>
      <groupId>com.alibabagroupId>
      <artifactId>druidartifactId>
      <version>1.1.16version>
    dependency>
 
    <dependency>
      <groupId>org.mybatisgroupId>
      <artifactId>mybatisartifactId>
      <version>3.5.6version>
    dependency>
 
    <dependency>
      <groupId>mysqlgroupId>
      <artifactId>mysql-connector-javaartifactId>
      <version>5.1.47version>
    dependency>
 
    <dependency>
      <groupId>org.springframeworkgroupId>
      <artifactId>spring-jdbcartifactId>
      <version>5.2.10.RELEASEversion>
    dependency>
 
    <dependency>
      <groupId>org.mybatisgroupId>
      <artifactId>mybatis-springartifactId>
      <version>1.3.0version>
    dependency>
 
    <dependency>
      <groupId>junitgroupId>
      <artifactId>junitartifactId>
      <version>4.12version>
      <scope>testscope>
    dependency>
 
    <dependency>
      <groupId>org.springframeworkgroupId>
      <artifactId>spring-testartifactId>
      <version>5.2.10.RELEASEversion>
    dependency>
 
  dependencies>

import java.io.Serializable;
 
public class Account implements Serializable {
 
    private Integer id;
    private String name;
    private Double money;
 
    public Integer getId() {
        return id;
    }
 
    public void setId(Integer id) {
        this.id = id;
    }
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public Double getMoney() {
        return money;
    }
 
    public void setMoney(Double money) {
        this.money = money;
    }
 
    @Override
    public String toString() {
        return "Account{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", money=" + money +
                '}';
    }
}

public interface AccountDao {
 
    @Update("update tbl_account set money = money + #{money} where name = #{name}")
    void inMoney(@Param("name") String name, @Param("money") Double money);
 
    @Update("update tbl_account set money = money - #{money} where name = #{name}")
    void outMoney(@Param("name") String name, @Param("money") Double money);
}

public interface AccountService {
    /**
     * 转账操作
     * @param out 传出方
     * @param in 转入方
     * @param money 金额
     */
    public void transfer(String out,String in ,Double money) ;
}

@Service
public class AccountServiceImpl implements AccountService {
 
    @Autowired
    private AccountDao accountDao;
 
    public void transfer(String out,String in ,Double money) {
        accountDao.outMoney(out,money);
        accountDao.inMoney(in,money);
    }
 
}

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/spring_db?useSSL=false
jdbc.username=root
jdbc.password=root

public class JdbcConfig {
    @Value("${jdbc.driver}")
    private String driver;
    @Value("${jdbc.url}")
    private String url;
    @Value("${jdbc.username}")
    private String userName;
    @Value("${jdbc.password}")
    private String password;
 
    @Bean
    public DataSource dataSource(){
        DruidDataSource ds = new DruidDataSource();
        ds.setDriverClassName(driver);
        ds.setUrl(url);
        ds.setUsername(userName);
        ds.setPassword(password);
        return ds;
    }
}

public class MybatisConfig {
 
    @Bean
    public SqlSessionFactoryBean sqlSessionFactory(DataSource dataSource){
        SqlSessionFactoryBean ssfb = new SqlSessionFactoryBean();
        ssfb.setTypeAliasesPackage("com.itheima.domain");
        ssfb.setDataSource(dataSource);
        return ssfb;
    }
 
    @Bean
    public MapperScannerConfigurer mapperScannerConfigurer(){
        MapperScannerConfigurer msc = new MapperScannerConfigurer();
        msc.setBasePackage("com.itheima.dao");
        return msc;
    }
}
 

@Configuration
@ComponentScan("com.itheima")
@PropertySource("classpath:jdbc.properties")
@Import({JdbcConfig.class,MybatisConfig.class})
public class SpringConfig {
}

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfig.class)
public class AccountServiceTest {
 
    @Autowired
    private AccountService accountService;
 
    @Test
    public void testTransfer() throws IOException {
        accountService.transfer("Tom","Jerry",100D);
    }
 
}

public interface AccountService {
    /**
     * 转账操作
     * @param out 传出方
     * @param in 转入方
     * @param money 金额
     */
    //配置当前接口方法具有事务
    @Transactional
    public void transfer(String out,String in ,Double money) ;
}

public class JdbcConfig {
    @Value("${jdbc.driver}")
    private String driver;
    @Value("${jdbc.url}")
    private String url;
    @Value("${jdbc.username}")
    private String userName;
    @Value("${jdbc.password}")
    private String password;
 
    @Bean
    public DataSource dataSource(){
        DruidDataSource ds = new DruidDataSource();
        ds.setDriverClassName(driver);
        ds.setUrl(url);
        ds.setUsername(userName);
        ds.setPassword(password);
        return ds;
    }
 
    //配置事务管理器，mybatis使用的是jdbc事务
    @Bean
    public PlatformTransactionManager transactionManager(DataSource dataSource){
        DataSourceTransactionManager transactionManager = new DataSourceTransactionManager();
        transactionManager.setDataSource(dataSource);
        return transactionManager;
    }
 
 
}

步骤 3 ：开启事务注解

在 SpringConfig 的配置类中开启

@Configuration
@ComponentScan("com.itheima")
@PropertySource("classpath:jdbc.properties")
@Import({JdbcConfig.class,MybatisConfig.class})
//开启注解式事务驱动
@EnableTransactionManagement
public class SpringConfig {
}

步骤 4: 运行测试类

会发现在转换的业务出现错误后，事务就可以控制回顾，保证数据的正确性。

6.2 Spring事务角色

这节中我们重点要理解两个概念，分别是 事务管理员 和 事务协调员 。

1. 未开启 Spring 事务之前 :

 

AccountDao 的 outMoney 因为是修改操作，会开启一个事务 T1

AccountDao 的 inMoney 因为是修改操作，会开启一个事务 T2

AccountService 的 transfer 没有事务，

        运行过程中如果没有抛出异常，则T1 和 T2 都正常提交，数据正确

        如果在两个方法中间抛出异常，T1 因为执行成功提交事务， T2 因为抛异常不会被执行

        就会导致数据出现错误

2. 开启Spring的事务管理后

transfer 上添加了 @Transactional 注解，在该方法上就会有一个事务 T

AccountDao 的 outMoney 方法的事务 T1 加入到 transfer 的事务 T 中

AccountDao 的 inMoney 方法的事务 T2 加入到 transfer 的事务 T 中

这样就保证他们在同一个事务中，当业务层中出现异常，整个事务就会回滚，保证数据的准

确性。

事务管理员：发起事务方，在Spring中通常指代业务层开启事务的方法

6.3 Spring事务属性

上面这些属性都可以在 @Transactional 注解的参数上进行设置。

readOnly： true 只读事务， false 读写事务，增删改要设为 false, 查询设为 true 。

timeout: 设置超时时间单位秒，在多长时间之内事务没有提交成功就自动回滚， -1 表示不设

置超 时时间。

rollbackFor: 当出现指定异常进行事务回滚

noRollbackFor: 当出现指定异常不进行事务回滚

思考:出现异常事务会自动回滚，这个是我们之前就已经知道的

noRollbackFor 是设定对于指定的异常不回滚，这个好理解

rollbackFor 是指定回滚异常，对于异常事务不应该都回滚么，为什么还要指定 ?

这块需要更正一个知识点，并不是所有的异常都会回滚事务，比如下面的代码就不会回滚(比

如IOException)

出现这个问题的原因是， Spring 的事务只会对 Error 异常 和 RuntimeException 异常 及

其子类进行事务回顾，其他的异常类型是不会回滚的，对应 IOException 不符合上述条

件所以不回滚

此时就可以使用 rollbackFor 属性来设置出现 IOException 异常不回滚

rollbackForClassName等同于rollbackFor,只不过属性为异常的类全名字符串

noRollbackForClassName 等同于 noRollbackFor ，只不过属性为异常的类全名字符串

isolation设置事务的隔离级别

DEFAULT : 默认隔离级别 , 会采用数据库的隔离级别

READ_UNCOMMITTED : 读未提交

READ_COMMITTED : 读已提交

REPEATABLE_READ : 重复读取

SERIALIZABLE: 串行化