1. AOP

1.1 AOP 简介【理解】

15 分钟

1.1.1「AOP 简介」核心问题&答案

AOP 的作用是什么？

点击查看作用

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

• OOP(Object Oriented Programming)面向对象编程----定义类，定义方法，开发功能

• 作用：在不惊动原始设计的基础上为其进行功能增强。 简单的说就是在不改变方法源代码的基础上对方法进行功能增强。

• Spring 理念：无入侵式/无侵入式增强

AOP 核心概念有哪些？

点击查看核心概念

• 连接点（JoinPoint）：正在执行的方法，例如：update()、delete()、select()等都是连接点。
• 切入点（Pointcut）：进行功能增强了的方法，例如:update()、delete()方法，select()方法没有被增强所以不是切入点，但是是连接点。
  • 在 SpringAOP 中，一个切入点可以只描述一个具体方法，也可以匹配多个方法
    • 一个具体方法：com.itheima.dao 包下的 BookDao 接口中的无形参无返回值的 save 方法
    • 匹配多个方法：所有的 save 方法，所有的 get 开头的方法，所有以 Dao 结尾的接口中的任意方法，所有带有一个参数的方法
• 通知（Advice）：在切入点前后执行的操作，也就是增强的共性功能
  • 在 SpringAOP 中，功能最终以方法的形式呈现
• 通知类：通知方法所在的类叫做通知类
• **切面（Aspect）：**描述通知(共性功能)与切入点（需要增强的方法）的对应关系，也就是哪些通知方法对应哪些切入点方法。

提问：查看下列图片，回答问题

点击查看图片

• 下列哪个是目标对象，哪个是代理对象？

  

  image-20220513203556476

1.2 AOP 入门案例【重点】

12 分钟

1.2.1 「入门案例」核心问题&答案

问题

1. 在通知方法中如何定义切入点表达式？
2. 如何配置切面？
3. 在配置类上如何开启 AOP 注解功能？

1.2.2 AOP 入门案例思路分析

点击查看思路分析

• 案例设定：测定接口执行效率
• 简化设定：在接口执行前输出当前系统时间
• 开发模式：XML or 注解
• 思路分析：
  1. 导入坐标（pom.xml）
  2. 制作连接点方法（原始操作，dao 接口与实现类）
  3. 制作共性功能（通知类与通知）
  4. 定义切入点
  5. 绑定切入点与通知关系（切面）

1.2.3 AOP 入门案例实现

步鄹

【第一步】导入 Aop 相关坐标

【第二步】定义 dao 接口与实现类

【第三步】定义通知类，制作通知方法

【第四步】定义切入点表达式、配置切面(绑定切入点与通知关系)

【第五步】在配置类中进行 Spring 注解包扫描和开启 AOP 功能

【第一步】导入 Aop 相关坐标

<dependencies>
    <!--spring核心依赖，会将spring-aop传递进来-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.2.10.RELEASE</version>
    </dependency>
    <!--切入点表达式依赖，目的是找到切入点方法，也就是找到要增强的方法-->
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.9.4</version>
    </dependency>
</dependencies>

【第二步】定义 dao 接口与实现类

// 定义接口
public interface BookDao {
    public void save();
    public void update();
}

// 定义实现类,添加注解@Repository(持久层)
@Repository
public class BookDaoImpl implements BookDao {

    public void save() {
        System.out.println(System.currentTimeMillis());
        System.out.println("book dao save ...");
    }
    public void update(){
        System.out.println("book dao update ...");
    }
}

【第三步】定义通知类，制作通知方法

建立 aop 包，在包中定义 MyAdvice 通知类

//通知类必须配置成Spring管理的bean
@Component
public class MyAdvice {
    public void method(){
        System.out.println(System.currentTimeMillis());
    }
}

【第四步】定义切入点表达式、配置切面(绑定切入点与通知关系)

//通知类必须配置成Spring管理的bean
@Component
//设置当前类为切面类类
@Aspect
public class MyAdvice {
    //设置切入点，@Pointcut注解要求配置在方法上方
    @Pointcut("execution(void com.itheima.dao.BookDao.update())")
    private void pt(){}

    //设置在切入点pt()的前面运行当前操作(前置通知)
    @Before("pt()")
    public void method(){
        System.out.println(System.currentTimeMillis());
    }
}

【第五步】在配置类中进行 Spring 注解包扫描和开启 AOP 功能

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

测试类和运行结果

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

1.3 AOP 入门案例 练习 ✏️

10 分钟

1.3.0「AOP 入门案例 」目的

熟悉接入点、切入点、切面描述、通知方法、通知类的定义和使用

1.3.1「AOP 入门案例 」需求&效果

测定接口执行效率

1.3.2「AOP 入门案例 」步鄹

• 在飞秋中下载 spring_18_aop_quickstarttest 压缩包，放到你的工程中
• 导入到项目中
• 完成通知类中的代码
• 注意：导工程后，一定要做的三个步鄹
  1. 检查 Maven 仓库
  2. 检查 jdk-1.8
  3. 检查编译器版本-1.8

1.4 AOP 工作流程 🍐

7 分钟

1.4.1 「AOP 工作流程」核心问题&答案

问题

1. 什么是目标对象？什么是代理对象？

点击查看

• 目标对象（Target） ：被代理的对象，也叫原始对象，该对象中的方法没有任何功能增强。
• 代理对象（Proxy） ：代理后生成的对象，由 Spring 帮我们创建代理对象。

1.4.2 AOP 工作流程

点击查看代码

1. Spring 容器启动
2. 读取所有切面配置中的切入点
3. 初始化 bean，判定 bean 对应的类中的方法是否匹配到任意切入点
   • 匹配失败，创建原始对象
   • 匹配成功，创建原始对象（目标对象）的代理对象
4. 获取 bean 执行方法
   • 获取的 bean 是原始对象时，调用方法并执行，完成操作
   • 获取的 bean 是代理对象时，根据代理对象的运行模式运行原始方法与增强的内容，完成操作

1.4.3 在测试类中验证代理对象

点击查看代码

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.getClass());
    }
}

提问：查看下列图片，加深代理对象和目标对象的理解

点击查看图片

1.5 AOP 切入点表达式 🍐

19 分钟

1.5.1 「AOP 切入点表达式」核心问题&答案

问题

1. 在切入点表达式中如何简化包名和参数类型书写？

点击查看代码

• 使用通配符

1.5.2 语法格式

• 切入点：要进行增强的方法

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

点击查看描述方式

• 描述方式一：执行 com.itheima.dao 包下的 BookDao 接口中的无参数 update 方法

execution(void com.itheima.dao.BookDao.update())

• 描述方式二：执行 com.itheima.dao.impl 包下的 BookDaoImpl 类中的无参数 update 方法

execution(void com.itheima.dao.impl.BookDaoImpl.update())

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

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

• 动作关键字：描述切入点的行为动作，例如 execution 表示执行到指定切入点
• 访问修饰符：public，private 等，可以省略
• 返回值：写返回值类型
• 包名：多级包使用点连接
• 类/接口名：
• 方法名：
• 参数：直接写参数的类型，多个类型用逗号隔开
• 异常名：方法定义中抛出指定异常，可以省略

1.5.3 通配符

目的：可以使用通配符描述切入点，快速描述。

点击查看描述方式

• *单个独立的任意符号，可以独立出现，也可以作为前缀或者后缀的匹配符出现

匹配 com.itheima 包下的任意包中的 UserService 类或接口中所有 find 开头的带有一个参数的方法

execution（public * com.itheima.*.UserService.find*(*))

• .. ：多个连续的任意符号，可以独立出现，常用于简化包名与参数的书写

匹配 com 包下的任意包中的 UserService 类或接口中所有名称为 findById 的方法

execution（public User com..UserService.findById(..))

• +：专用于匹配子类类型

execution(* *..*Service+.*(..))

1.5.4 书写技巧

点击查看书写技巧

不要死记，不要死记，慢慢体会，慢慢体会

• 技巧说明：

• 从方法到返回值

• 以后在开发过程中，命名一定要规范，方便写切入点表达式子

  1. 如查询：以 find 开头或者 query 开头 ，如 queryxxx()
  2. 如获得单个，getxxx
  3. 如保存：saveXXX
  4. 如更新：updateXXX
  5. 如删除：deleteXXX

提问：查看下列图片，回答问题

点击查看图片

1.6 AOP 通知类型

19 分钟

1.6.1 「通知类型」核心问题&答案

问题

1. 通知类型中哪种通知最重要,能实现其他类型的通知

点击查看

• 环绕通知(重点)： 手动调用切入点方法并对其进行增强的通知方式。

1.6.2 AOP 通知分类

点击查看通知分类

• AOP 通知描述了抽取的共性功能，根据共性功能抽取的位置不同，最终运行代码时要将其加入到合理的位置
• AOP 通知共分为 5 种类型
  • 前置通知：在切入点方法执行之前执行
  • 后置通知：在切入点方法执行之后执行，无论切入点方法内部是否出现异常，后置通知都会执行。
  • **环绕通知(重点)：**手动调用切入点方法并对其进行增强的通知方式。 👈
  • 返回后通知(了解)：在切入点方法执行之后执行，如果切入点方法内部出现异常将不会执行。
  • 抛出异常后通知(了解)：在切入点方法执行之后执行，只有当切入点方法内部出现异常之后才执行。

1.6.3 AOP 通知详解

1️⃣ 前置通知 🚀

• 名称：@Before （了解）
• 类型：方法注解
• 位置：通知方法定义上方
• 作用：设置当前通知方法与切入点之间的绑定关系，当前通知方法在原始切入点方法前运行
• 范例：

@Before("pt()")
public void before() {
    System.out.println("before advice ...");
}

2️⃣ 后置通知 🚀

• 名称：@After （了解）
• 类型：方法注解
• 位置：通知方法定义上方
• 作用：设置当前通知方法与切入点之间的绑定关系，当前通知方法在原始切入点方法后运行
• 范例：

@After("pt()")
public void after() {
    System.out.println("after advice ...");
}

3️⃣ 返回后通知 🚀

• 名称：@AfterReturning（了解）
• 类型：方法注解
• 位置：通知方法定义上方
• 作用：设置当前通知方法与切入点之间的绑定关系，当前通知方法在原始切入点方法正常执行完毕后运行
• 范例：

@AfterReturning("pt()")
public void afterReturning() {
    System.out.println("afterReturning advice ...");
}

4️⃣ 抛出异常后通知 🚀

• 名称：@AfterThrowing（了解）
• 类型：方法注解
• 位置：通知方法定义上方
• 作用：设置当前通知方法与切入点之间的绑定关系，当前通知方法在原始切入点方法运行抛出异常后执行
• 范例：

@AfterThrowing("pt()")
public void afterThrowing() {
    System.out.println("afterThrowing advice ...");
}

5️⃣ 环绕通知【重点】 ❤️ 👈

• 名称：@Around（重点，常用）
• 类型：方法注解
• 位置：通知方法定义上方
• 作用：设置当前通知方法与切入点之间的绑定关系，当前通知方法在原始切入点方法前后运行
• 范例：：

@Around("pt()")
public Object around(ProceedingJoinPoint pjp) throws Throwable {
    System.out.println("around before advice ...");
    Object ret = pjp.proceed();
    System.out.println("around after advice ...");
    return ret;
}

环绕通知注意事项

1. 环绕通知方法形参必须是 ProceedingJoinPoint，表示正在执行的连接点，使用该对象的 proceed()方法表示对原始对象方法进行调用，返回值为原始对象方法的返回值。 👈
2. 环绕通知方法的返回值建议写成 Object 类型，用于将原始对象方法的返回值进行返回，哪里使用代理对象就返回到哪里。

2. AOP 案例

2.1 案例-测量业务层接口万次执行效率

16 分钟

2.1.1 需求和分析

提示

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

• 分析：

  1️⃣ 业务功能：业务层接口执行前后分别记录时间，求差值得到执行效率 👈

  2️⃣ 通知类型选择前后均可以增强的类型——环绕通知 👈

2.1.2 代码实现

相关信息

【前置工作】环境准备

【第一步】编写通知类

【第二步】在 SpringConfig 配置类上开启 AOP 注解功能

【第三步】运行测试类，查看结果

【前置工作】环境准备

1. Spring 整合 mybatis 对 spring_db 数据库中的 Account 进行 CRUD 操作
2. Spring 整合 Junit 测试 CRUD 是否 OK。

@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<Account> all = accountService.findAll();
    }
}

3. 在 pom.xml 中添加 aspectjweaver 切入点表达式依赖【不可重复导入】

<!--切入点表达式依赖，目的是找到切入点方法，也就是找到要增强的方法-->
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.4</version>
</dependency>

【第一步】编写通知类

//通知类必须配置成Spring管理的bean
@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");
    }
}

【第二步】在 SpringConfig 配置类上开启 AOP 注解功能

@Configuration
@ComponentScan("com.itheima")
@PropertySource("classpath:jdbc.properties")
@Import({JdbcConfig.class,MybatisConfig.class})
@EnableAspectJAutoProxy //开启AOP注解功能
public class SpringConfig {
}

【第三步】运行测试类，查看结果

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfig.class)
public class AccountServiceTestCase {
    @Autowired
    private AccountService accountService;
    @Test
    public void testFindById(){
        Account account = accountService.findById(2);
    }
    @Test
    public void testFindAll(){
        List<Account> list = accountService.findAll();
    }
}

2.2 测量业务层接口万次执行效率 ✏️

10 分钟

2.2.0「测量业务层接口万次执行效率 」目的

熟悉环绕通知

2.2.1「测量业务层接口万次执行效率」需求&效果

2.2.2「测量业务层接口万次执行效率」步鄹

说明

• 在飞秋中下载 spring_21_case_interface_run_speedtest 压缩包，放到你的工程中
• 导入到项目中
• 完成通知类中的代码
• 启动类为 AccountServiceTestCase，类中有详细说明
• 注意：导工程后，一定要做的三个步鄹
  1. 检查 Maven 仓库
  2. 检查 jdk-1.8
  3. 检查编译器版本-1.8

点击查看练习步鄹说明

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

• 练习目标：主要练习环绕通知形参调用（pjp.proceed()) 以及拦截的类和方法名的获取

  1. 执行 testFindById 方法，测试执行 1 次耗时多少
  2. 执行 testFindAll 方法，测试执行 10000 次耗时多少

• 步鄹：

  1. 导入项目，检查 pom 依赖和 maven 仓库

  2. 修改数据库密码和数据库名字

  3. 检查数据库中是否有对应的表格和数据量

  4. 配置类 SpringConfig 中检查是否有开启 AOP 注解开发 @EnableAspectJAutoProxy

  5. 在 AOP 类中 ProjectAdvice 中检查 通知方法和环绕通知注解 @Around

  6. 检查切入点表达式是否匹配 测试类中执行的方法

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

• 需求 2：在上一个需求上，完成打印输入参数

  • 如：accountService.findById(2);这里查询了 id 为 2 的参数，在增强的方法中，输入参数 2
  • 格式：执行：com.itheima.service.AccountService.findById 参数：[2]---->465ms

• 练习目标：主要练习环绕通知形参调用,获得原有方法输入的参数

  • Object[] args = pjp.getArgs();

• 如果你完成了上述第一个需求，恭喜你，你掌握了重点内容（3 分之一）环绕通知

• 如果你完成了上述的第二个需求，恭喜你，你准备掌握了重点内容（3 分之一）环绕通知获得参数

2.3 AOP 切入点数据获取

15 分钟

2.3.1 「切入点数据获取」核心问题&答案

问题

1. 在环绕通知中可以获取到哪些数据？

点击查看代码

• 获取参数
• 获取返回值
• 获取异常

2.1 获取参数

说明：在前置通知和环绕通知中都可以获取到连接点方法的参数们

• JoinPoint 对象描述了连接点方法的运行状态，可以获取到原始方法的调用参数

@Before("pt()")
public void before(JoinPoint jp) {
    Object[] args = jp.getArgs(); //获取连接点方法的参数们
    System.out.println(Arrays.toString(args));
}

• ProccedJointPoint 是 JoinPoint 的子类 👈

@Around("pt()")
public Object around(ProceedingJoinPoint pjp) throws Throwable {
    Object[] args = pjp.getArgs(); //获取连接点方法的参数们
    System.out.println(Arrays.toString(args));
    Object ret = pjp.proceed();
    return ret;
}

2.2 获取返回值 ❤️

说明：在返回后通知和环绕通知中都可以获取到连接点方法的返回值

• 抛出异常后通知可以获取切入点方法中出现的异常信息，使用形参可以接收对应的异常对象

@AfterReturning(value = "pt()",returning = "ret")
public void afterReturning(String ret) { //变量名要和returning="ret"的属性值一致
    System.out.println("afterReturning advice ..."+ret);
}

• 环绕通知中可以手工书写对原始方法的调用，得到的结果即为原始方法的返回值 👈

@Around("pt()")
public Object around(ProceedingJoinPoint pjp) throws Throwable {
    // 手动调用连接点方法，返回值就是连接点方法的返回值
    Object ret = pjp.proceed();
    return ret;
}

2.3 获取异常 🚀

说明：在抛出异常后通知和环绕通知中都可以获取到连接点方法中出现的异常

• 抛出异常后通知可以获取切入点方法中出现的异常信息，使用形参可以接收对应的异常对象

@AfterThrowing(value = "pt()",throwing = "t")
public void afterThrowing(Throwable t) {//变量名要和throwing = "t"的属性值一致
    System.out.println("afterThrowing advice ..."+ t);
}

• 抛出异常后通知可以获取切入点方法运行的异常信息，使用形参可以接收运行时抛出的异常对象

@Around("pt()")
public Object around(ProceedingJoinPoint pjp)  {
    Object ret = null;
    //此处需要try...catch处理，catch中捕获到的异常就是连接点方法中抛出的异常
    try {
        ret = pjp.proceed();
    } catch (Throwable t) {
        t.printStackTrace();
    }
    return ret;
}

2.4 案例-百度网盘密码数据兼容处理

11 分钟

2.4.1 需求和分析

需求和分析

• 需求：对百度网盘分享链接输入密码时尾部多输入的空格做兼容处理

链接：https://pan.baidu.com/s/12tMJaOlabADUXhu8VgwMzw?pwd=hztj
提取码：hztj
复制这段内容后打开百度网盘手机 App，操作更方便哦

• 分析：

①：在业务方法执行之前对所有的输入参数进行格式处理——trim()

②：使用处理后的参数调用原始方法——环绕通知中存在对原始方法的调用

2.4.2 代码实现

【前置工作】环境准备

//-------------service层代码-----------------------
public interface ResourcesService {
    public boolean openURL(String url ,String password);
}
@Service
public class ResourcesServiceImpl implements ResourcesService {
    @Autowired
    private ResourcesDao resourcesDao;

    public boolean openURL(String url, String password) {
        return resourcesDao.readResources(url,password);
    }
}

//-------------dao层代码-----------------------
public interface ResourcesDao {
    boolean readResources(String url, String password);
}
@Repository
public class ResourcesDaoImpl implements ResourcesDao {
    public boolean readResources(String url, String password) {
        System.out.println(password.length());
        //模拟校验
        return password.equals("root");
    }
}

【第一步】编写通知类

@Component
@Aspect
public class DataAdvice {

    @Pointcut("execution(boolean com.itheima.service.*Service.*(*,*))")
    private void servicePt(){}

    @Around("DataAdvice.servicePt()")
    public Object trimStr(ProceedingJoinPoint pjp) throws Throwable {
        Object[] args = pjp.getArgs();
        for (int i = 0; i < args.length; i++) {
            //判断参数是不是字符串
            if(args[i].getClass().equals(String.class)){
                args[i] = args[i].toString().trim();
            }
        }
        Object ret = pjp.proceed(args);
        return ret;
    }
}

【第二步】在 SpringConfig 配置类上开启 AOP 注解功能

@Configuration
@ComponentScan("com.itheima")
@EnableAspectJAutoProxy
public class SpringConfig {
}

【第三步】运行测试类，查看结果

public class App {
    public static void main(String[] args) {
        ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
        ResourcesService resourcesService = ctx.getBean(ResourcesService.class);
        boolean flag = resourcesService.openURL("http://pan.baidu.com/haha", "root ");
        System.out.println(flag);
    }
}

2.5 AOP 开发总结

7 分钟

2.5.1 AOP 的核心概念 🍐

提示

• 概念：AOP(Aspect Oriented Programming)面向切面编程，一种编程范式
• 作用：在不惊动原始设计的基础上为方法进行功能增强
• 核心概念
  • 代理（Proxy）：SpringAOP 的核心本质是采用代理模式实现的 ❤️
  • 连接点（JoinPoint）： 在 SpringAOP 中，理解为任意方法的执行
  • 切入点（Pointcut）：匹配连接点的式子，也是具有共性功能的方法描述
  • 通知（Advice）：若干个方法的共性功能，在切入点处执行，最终体现为一个方法
  • 切面（Aspect）：描述通知与切入点的对应关系 ❤️
  • 目标对象（Target）：被代理的原始对象成为目标对象 ❤️

2.5.2 切入点表达式语法

点击查看切入点表达式语法

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

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

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

  • 作用：用于快速描述，范围描述
  • *：匹配任意符号（常用）
  • .. ：匹配多个连续的任意符号（常用）
  • +：匹配子类类型

• 切入点表达式书写技巧

  1. 按标准规范开发
  2. 查询操作的返回值建议使用*匹配
  3. 减少使用..的形式描述包
  4. 对接口进行描述，使用*表示模块名，例如 UserService 的匹配描述为*Service
  5. 方法名书写保留动词，例如 get，使用*表示名词，例如 getById 匹配描述为 getBy*
  6. 参数根据实际情况灵活调整

1.表达式：读的方式从后往前读取，在路径上不要使用.. ❤️

@Pointcut("execution(* com.itheima.dao.BookDao.findName(..))")
 private void pt(){}

@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.3 五种通知类型

点击查看五种通知类型

• 前置通知
• 后置通知
• 环绕通知 👈 ❤️
  • 环绕通知依赖形参 ProceedingJoinPoint 才能实现对原始方法的调用
  • 环绕通知可以隔离原始方法的调用执行
  • 环绕通知返回值设置为 Object 类型
  • 环绕通知中可以对原始方法调用过程中出现的异常进行处理
• 返回后通知
• 抛出异常后通知

注意

Aop 建议在岗位级别比较高的时候使用，如果只是公司的小工程师，建议先咨询主管。

3.Spring 事务管理

3.1 Spring 事务简介【重点】

13 分钟

3.1.1 「 Spring 事务简介」核心问题&答案

问题

1. Spring 提供的事务管理是数据层的事务还是业务层的事务?

点击查看

• 事务作用：在数据层保障一系列的数据库操作同成功同失败
• Spring 事务作用：在数据层或**业务层**保障一系列的数据库操作同成功同失败

3.1.2 需求和分析

提示

• 需求：实现任意两个账户间转账操作

• 需求微缩：A 账户减钱，B 账户加钱

• 分析：

  ①：数据层提供基础操作，指定账户减钱（outMoney），指定账户加钱（inMoney）

  ②：业务层提供转账操作（transfer），调用减钱与加钱的操作

  ③：提供 2 个账号和操作金额执行转账操作

  ④：基于 Spring 整合 MyBatis 环境搭建上述操作

• 结果分析：

  ①：程序正常执行时，账户金额 A 减 B 加，没有问题

  ②：程序出现异常后，转账失败，但是异常之前操作成功，异常之后操作失败，整体业务失败

3.1.3 代码实现

【前置工作】环境准备

Spring 整合 Mybatis 相关代码(依赖、JdbcConfig、MybatisConfig、SpringConfig)省略。

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);
        int i = 1/0;
        accountDao.inMoney(in,money);
    }
}

【第一步】在业务层接口上添加 Spring 事务管理

public interface AccountService {
    //配置当前接口方法具有事务
    @Transactional
    public void transfer(String out,String in ,Double money) ;
}

• 注意事项

  1. Spring 注解式事务通常添加在业务层接口中而不会添加到业务层实现类中，降低耦合
  2. 注解式事务可以添加到业务方法上表示当前方法开启事务，也可以添加到接口上表示当前接口所有方法开启事务

【第二步】设置事务管理器(将事务管理器添加到 IOC 容器中)

说明：可以在 JdbcConfig 中配置事务管理器

//配置事务管理器，mybatis使用的是jdbc事务
@Bean
public PlatformTransactionManager transactionManager(DataSource dataSource){
    DataSourceTransactionManager dtm = new DataSourceTransactionManager();
    transactionManager.setDataSource(dataSource);
    return transactionManager;
}

• 注意事项

  1. 事务管理器要根据实现技术进行选择
  2. MyBatis 框架使用的是 JDBC 事务 ❤️

【第三步】开启注解式事务驱动

@Configuration
@ComponentScan("com.itheima")
@PropertySource("classpath:jdbc.properties")
@Import({JdbcConfig.class,MybatisConfig.class})
//开启注解式事务驱动
@EnableTransactionManagement
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);
}
}

3.2 Spring 事务角色【理解】

5 分钟

3.2.1 「Spring 事务角色」核心问题&答案

问题

1. 什么是事务管理员，什么是事务协调员？

点击查看

• 事务管理员：发起事务方，在 Spring 中通常指代业务层开启事务的方法
• 事务协调员：加入事务方，在 Spring 中通常指代数据层方法，也可以是业务层方法

3.3 Spring 事务相关配置

19 分钟

3.3.1 「Spring 事务相关配置」核心问题&答案

问题

1. 什么样的异常，Spring 事务默认是不进行回滚的？

点击查看

说明：对于 RuntimeException 类型异常或者 Error 错误，Spring 事务能够进行回滚操作。但是对于编译器异常，Spring 事务是不进行回滚的 ，所以需要使用 rollbackFor 来设置要回滚的异常。相当于打个补丁，不影响原有异常的回滚操作.

3.3.1 案例：转账业务追加日志

点击查看图示

需求和分析

点击查看

• 需求：实现任意两个账户间转账操作，并对每次转账操作在数据库进行留痕

• 需求微缩：A 账户减钱，B 账户加钱，数据库记录日志

• 分析：

  ①：基于转账操作案例添加日志模块，实现数据库中记录日志

  ②：业务层转账操作（transfer），调用减钱、加钱与记录日志功能

• 实现效果预期： 无论转账操作是否成功，均进行转账操作的日志留痕

• 存在的问题： 日志的记录与转账操作隶属同一个事务，同成功同失败

• 实现效果预期改进： 无论转账操作是否成功，日志必须保留

• 事务传播行为：事务协调员对事务管理员所携带事务的处理态度

代码实现

步鄹

• 【准备工作】环境整备
• 【第一步】在 AccountServiceImpl 中调用 logService 中添加日志的方法
• 【第二步】在 LogService 的 log()方法上设置事务的传播行为
• 【第三步】运行测试类，查看结果

【准备工作】环境整备

USE spring_db;
CREATE TABLE tbl_log(
id INT PRIMARY KEY AUTO_INCREMENT,
info VARCHAR(255),
createDate DATE
);

public interface LogService {
    //propagation设置事务属性：传播行为设置为当前操作需要新事务
    @Transactional
    void log(String out, String in, Double money);
}

@Service
public class LogServiceImpl implements LogService {

    @Autowired
    private LogDao logDao;
    public void log(String out,String in,Double money ) {
        logDao.log("转账操作由"+out+"到"+in+",金额："+money);
    }
}

public interface LogDao {
    @Insert("insert into tbl_log (info,createDate) values(#{info},now())")
    void log(String info);
}

【第一步】在 AccountServiceImpl 中调用 logService 中添加日志的方法

@Service
public class AccountServiceImpl implements AccountService {
    @Autowired
    private AccountDao accountDao;

    @Autowired
    private LogService logService;

    public void transfer(String out,String in ,Double money) {
        try{
            accountDao.outMoney(out,money);
            int i = 1/0;
            accountDao.inMoney(in,money);
        }finally {
            logService.log(out,in,money);
        }
    }
}

【第二步】在 LogService 的 log()方法上设置事务的传播行为

public interface LogService {
    //propagation设置事务属性：传播行为设置为当前操作需要新事务
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    void log(String out, String in, Double money);
}

【第三步】运行测试类，查看结果

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfig.class)
public class AccountServiceTest {
    @Autowired
    private AccountService accountService;

    @Test
    public void testTransfer() throws IOException {
        accountService.transfer("Tom","Jerry",50D);
    }
}

3.3.2 事务传播行为

事务传播行为：事务协调员对事务管理员所携带事务的处理态度

点击查看

3.4 事务传播行为练习 ✏️

10 分钟

3.4.0「事务传播行为 」目的

事务传播行为中的 REQUIRES_NEW 开启一个新的事物

3.4.1「事务传播行为」需求&效果

转账过程中出现了异常，日志也进行了记录

3.4.2「事务传播行为」步鄹

• 在飞秋中下载 spring_25_case_transfer_logtest 压缩包，放到你的工程中
• 导入到项目中
• 启动类为 AccountServiceTest，类中有详细说明
• 思考 AccountService 和 LogService 添加什么注解配置事物，并且思考要配置何种传播属性
• 注意：导工程后，一定要做的三个步鄹
  1. 检查 Maven 仓库
  2. 检查 jdk-1.8
  3. 检查编译器版本-1.8

记忆小技巧

• Spring 容器和 bean 的注解 ：ccip abs

• aop 的注解：CAPA E