SpringBoot AOP 和 事务

server/2025/1/31 22:26:36/

SpringBoot 整合 AOP

动态代理技术

JDK 动态代理

  • JDK 动态代理是 Java 自带的一种代理方式。它要求目标类必须有接口，基于这个接口，JDK 在运行时会动态生成一个代理对象。这个代理对象和目标对象就像 “拜把子” 的兄弟，因为它们都实现了相同的接口，能以相同的方式被调用，只是代理对象在调用真正的方法前后可以添加额外的逻辑。
    .

CGLIB 动态代理

  • CGLIB 动态代理是另一种代理技术。它的厉害之处在于不需要目标类有接口，通过让代理类继承目标类来实现代理，就好比代理类 “认” 目标类为 “干爹”。这样，代理类就能在目标类方法调用的前后插入自己的逻辑，从而对目标类的行为进行增强。

Spring AoP

AoP 概述

在这里插入图片描述

AOP 核心概念

  • 切入点：实际被 AOP 控制的方法，需要被增强的方法
  • 通知：封装共享功能的方法就是通知

在这里插入图片描述

AoP 通知类型

环绕就是一部分在目标方法之前，一部分在之后

  • 它的返回值代表的是原始方法执行完毕的返回值

java">try {前置通知 @Before目标方法执行返回后通知 @AfterReturning
} catch() {异常后通知 @AfterThrowing
} finally {后置通知 @After
}

AoP 通知顺序

在这里插入图片描述

AoP 切点表达式 @execution

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

AoP 切点表达式重用

第一种：创建存储切点的类维护

创建一个存储切点的类
单独维护切点表达式
execution 使用：类全限定符.方法名()

  • 切点维护类
java">@Component
public class MyPointCut {@Pointcut("execution(* com.atguigu.service.impl.*.*(..))")public void pc(){}
  • 重用类演示类
java">    @Before("com.atguigu.pointcut.MyPointCut.pc()")public void start() {System.out.println("方法开始了");}@After("com.atguigu.pointcut.MyPointCut.pc()")public void after() {System.out.println("方法结束了");}@AfterThrowing("com.atguigu.pointcut.MyPointCut.pc()")public void error() {System.out.println("方法报错了");}
第二种：当前类中提取表达式

定义一个空方法
注解 @Pointcut()
增强注解中引用切点 直接调用方法名

java">@Aspect
@Component
public class UserServiceAspect {// 定义一个空方法，使用@Pointcut注解来定义切点表达式，这里表示匹配UserService接口下的所有方法@Pointcut("execution(* com.example.demo.service.UserService.*(..))")public void userServicePointcut() {}// 在前置通知中复用上面定义的切点表达式，直接写切点方法名即可@Before("userServicePointcut()")public void beforeAddUser() {System.out.println("在执行UserService的方法前执行的逻辑");}

AoP 基本使用

底层技术组成

在这里插入图片描述

动态代理（InvocationHandler）：

  • JDK原生 的实现方式，需要被代理的目标类必须实现接口。因为这个技术要求代理对象和目标对象实现同样的接口（兄弟两个拜把子模式）。
  • cglib：通过继承被代理的目标类（认干爹模式）实现代理，所以不需要目标类实现接口。
  • AspectJ：SpringAOP借用了AspectJ中的AOP注解。也就是说 @Before 等注解都来自 AspectJ
默认代理方式演示（JDK原生）

在这里插入图片描述

第一步：导入依赖
 <dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-aop</artifactId>
</dependency>
第二步：准备接口和实现类
java">public interface Calculator {int add(int i, int j);
}

java">@Component
public class CalculatorPureImpl implements Calculator {@Overridepublic int add(int i, int j) {int result = i + j;return result;}
}
第三步：声明切面类 @Aspect

切面类要加入 IoC 容器
并且要使用 @Aspect 声明为切面类

java">@Aspect
@Component
public class LogAdvice {@Pointcut("execution(* com.mangfu.Calculator.*(..))")public void Mypointcut(){}@Before("Mypointcut()")public void testBefore() {System.out.println("before");}@AfterReturning("Mypointcut()")public void testAfterReturning() {System.out.println("afterReturning");}@AfterThrowing("Mypointcut()")public void testAfterThrowing() {System.out.println("afterThrowing");}@After("Mypointcut()")public void testAfter() {System.out.println("after");}
}
环绕通知

就相当于直接进入切面类执行

  • 接口和实现类
java">public interface Calculator {int add(int i, int j);
}

java">@Component
public class CalculatorPureImpl implements Calculator {@Overridepublic int add(int i, int j) {int result = i + j;return result;}
}
  • 配置类开启 AspectJ
java">@Configuration
@ComponentScan("com.mangfu")
@EnableAspectJAutoProxy
public class MyConfig {
}
  • 切面类
  • ProceedingJoinPoint joinPoint：目标方法对象
  • jointPoint.getArgs(): 获取目标方法运行的参数
  • joinPoint.proceed(args): 执行目标方法
java">@Aspect
@Component
public class LogAdvice {@Around("execution(* com.mangfu.Calculator.*(..))")public Object around(ProceedingJoinPoint joinPoint) {Object[] args = joinPoint.getArgs(); //获取目标方法运行的参数Object result = null; //用于接收目标参数的返回值try {System.out.println("Before");result = joinPoint.proceed(args); //调用目标方法System.out.println("AfterReturning");} catch (Throwable e) {System.out.println("Afterthrowing");throw new RuntimeException(e);} finally {System.out.println("After");}return result;}
}
  • 测试类
java">@SpringJUnitConfig(MyConfig.class)
public class MyTest {@Autowiredprivate Calculator calculator;@Testpublic void test() {System.out.println(calculator.add(1, 2));}
}
JoinPoint 详解

在这里插入图片描述
在这里插入图片描述

CGLib 动态代理生效情况

在目标类没有实现任何接口的情况下，Spring会自动使用cglib技术实现代理。

  • 如果目标类有接口, 选择使用 jdk 动态代理：实现目标接口
  • 如果目标类没有接口, 选择 cglib 动态代理：继承目标对象
  • 如果有接口, 就用接口接值
  • 如果没有接口, 就用类进行接值
  • 没实现接口的实体类和切面类
java">@Component
public class Calculator {public int add(int i, int j) {int result = i + j;return result;}
}

java">@Aspect
@Component
public class testBefore {@Before("execution(* com.mangfu2.Calculator.add(..))" )public void before(){System.out.println("test sucessful");}
}
  • 测试类
java">@SpringJUnitConfig(MyConfig.class)
public class MyTest {//建议用接口取。防止后期取不到代理类对象//正常：aop - aop底层选择代理 - 选择jdk代理 - 根据接口生成代理类 - 代理对象和目标对象 是拜把子 兄弟关系。不是同一个//这里实现类没有实现接口所以用 CGLib 动态代理//aop - ioc 容器中真正存储的是代理对象不是目标对象@Autowiredprivate Calculator calculator;@Testpublic void test(){calculator.add(1,2);}}

Spring AoP 对获取 Bean 的影响

JDK 原生代理

声明一个接口，其仅有一个实现类，同时创建切面类对该接口的实现类应用通知：

  • 按接口类型获取 bean 可正常获取。
  • 按类获取 bean 则无法获取，原因在于应用切面后，实际存放在 IOC 容器中的是代理类对象，目标类本身并未放入 IOC 容器，所以依据目标类类型无法从 IOC 容器中找到相应对象

在这里插入图片描述
在这里插入图片描述

CGLib 代理

声明一个类，创建一个切面类，对上面的类应用通知

  • 根据类获取 bean，能获取到

在这里插入图片描述
在这里插入图片描述

Spring TX 声明式事务

声明式事务概念

  • 定义：通过注解或 XML 配置的方式控制事务的提交和回滚，具体事务实现由第三方框架负责，开发者只需添加相应配置，无需直接进行事务操作。
  • 优点：可将事务控制和业务逻辑分离，提升代码的可读性与可维护性。

请添加图片描述
在这里插入图片描述

  • spring-tx: 包含声明式事务实现的基本规范（事务管理器规范接口和事务增强等等）
  • spring-jdbc: 包含DataSource方式事务管理器实现类DataSourceTransactionManager
  • spring-orm: 包含其他持久层框架的事务管理器实现类例如：Hibernate/Jpa等
    .
    spring-tx 就是 Spring 官方提供的事务接口，各大持久层框架需要自己实现这个接口，而 spring-jdbc 就是 jdbc, jdbcTemplate, mybatis 的实现类 DataSourceTranscationManager。spring-orm 就是 Hibernate/Jpa 等持久层框架的实现类

声明式事务基本使用

SpringBoot 项目会自动配置一个 DataSourceTransactionManager，所以我们只需在方法（或者类）加上 @Transactional 注解，就自动纳入 Spring 的事务管理了

第一步：加入依赖

  • jdbc, jdbcTemplate, mybatis 这三个持久层框架情况
<!-- 第三方实现 spring 事务接口的类的依赖-->
<!-- spring-jdbc --><dependency><groupId>org.springframework</groupId><artifactId>spring-jdbc</artifactId><version>6.0.6</version></dependency>
  • 如果是 Hibernate 等其他持久层框架就用 spring-jdbc 换成 spring-orm 依赖

第二步：给需要事务的地方加上 @Transactional 注解

@Treanscational 加在类上就是类里所有方法开启事务。加在方法上就单独那个方法有事务

  • Dao层
java">@Repository
public class StudentDao {@Autowiredprivate JdbcTemplate jdbcTemplate;public void updateNameById(String name,Integer id){String sql = "update students set name = ? where id = ? ;";int rows = jdbcTemplate.update(sql, name, id);}public void updateAgeById(Integer age,Integer id){String sql = "update students set age = ? where id = ? ;";jdbcTemplate.update(sql,age,id);}
}
  • Service 层
java">@Service
public class StudentService {@Autowiredprivate StudentDao studentDao;/*** 添加事务:*      @Transctional*      位置: 方法 | 类上*      方法: 当前方法有事务*      类上: 泪下所有方法都有事务*///这里有自动事务了。所以可以报错可以自动回滚@Transactionalpublic void changeInfo(){studentDao.updateAgeById(88,1);int i = 1/0;System.out.println("-----------");studentDao.updateNameById("test1",1);}
}
  • 测试类
java">@SpringJUnitConfig(JavaConfig.class)
public class TxTest {@Autowired                               private StudentService studentService;@Testpublic void  testTx(){studentService.changeInfo();}
}

事务的属性

事务属性：只读

只读模式可以提升查询事务的效率！，一般情况都是通过类添加注解添加事务，类下的所有方法都有事务，而查询方法一般不用添加事务。这个时候可以再次添加事务注解，设置为只读，提高效率查询效率

  • @Transactional(readOnly = ...)
java">@Transactional
@Service
public class StudentService {@Autowiredprivate StudentDao studentDao;//查询 没有必要添加事务。这里设置为只读提高效率@Transactional(readOnly = true)public void getStudentInfo() {//获取学生信息 查询数据库 不修改}}

事务属性：超时

事务在执行过程中，有可能因为遇到某些问题，导致程序卡住，从而长时间占用数据库资源。而长时间占用资源，大概率是因为程序运行出现了问题（可能是Java程序或MySQL数据库或网络连接等等）。此时这个很可能出问题的程序应该被回滚，撤销它已做的操作，事务结束，把资源让出来，让其他正常程序可以执行。概括来说就是一句话：超时回滚，释放资源。

  • @Transactional(timeout = ...)
java">@Transactional(timeout = 3)
@Service
public class StudentService {@Autowiredprivate StudentDao studentDao;public void changeInfo() {studentDao.updateAgeById(88,1);System.out.println("-----------");try {Thread.sleep(4000);} catch (InterruptedException e) {throw new RuntimeException(e);}studentDao.updateNameById("test2",1);}//因为这个注解会覆盖掉类上注解。所以要再设置一遍@Transactional(readOnly = true, timeout = 3)public void getStudentInfo() {}}

事务属性：回滚

默认情况下，发生运行时 (RuntimeException) 异常事务才回滚，所以我们可以指定 Exception 异常来控制所有异常都回滚

  • roollbackFor = 回滚的异常范围：设置的异常都回滚
  • noRollbackFor = 不回滚的异常范围：控制某个异常不回滚
java">//所有异常都回滚，除了 FileNotFoundException 
@Transactional(rollbackFor = Exception.class, noRollbackFor = FileNotFoundException.class)public void changeInfo() throws FileNotFoundException {studentDao.updateAgeById(99,1);new FileInputStream("xxxx");studentDao.updateNameById("test2",1);}

事务属性：事务隔离级别

事务并发可能引发的问题

  • 脏读：一个事务读取另一个事务未提交的数据
  • 不可重复读：一个事务就是读取了另一个事务提交的修改数据
  • 幻读: 一个事务读取了另一个事务提交的插入数据

事务隔离级别

  • 读未提交（Read Uncommitted）：事务可以读取未被提交的数据，容易产生脏读、不可重复读和幻读等问题。实现简单但不太安全，一般不用。
  • 读已提交（Read Committed）：事务只能读取已经提交的数据，可以避免脏读问题，但可能引发不可重复读和幻读。
  • 可重复读（Repeatable Read）：在一个事务中，相同的查询将返回相同的结果集，不管其他事务对数据做了什么修改。可以避免脏读和不可重复读，但仍有幻读的问题。
  • 串行化（Serializable）：最高的隔离级别，完全禁止了并发，只允许一个事务执行完毕之后才能执行另一个事务。可以避免以上所有问题，但效率较低，不适用于高并发场景。
    .

不同的隔离级别适用于不同的场景，需要根据实际业务需求进行选择和调整。

建议设置第二个隔离级别

isolation = Isolation.事务的隔离级别

  • READ_UNCOMMITTED 读未提交
  • READ_COMMITTED 读已提交
  • REPEATABLE_READ 可重复读
  • SERIALIZABLE 串行化
java">//设置事务隔离级别为可串行化 
@Transactional(isolation = Isolation.SERIALIZABLE)public void changeInfo() throws FileNotFoundException {studentDao.updateAgeById(99,1);new FileInputStream("xxxx");studentDao.updateNameById("test2",1);}

事务属性：事务传播行为

  • propagation = 传播规则【默认是 Propagation.REQUIRED】
    我们一般使用默认就行
名称【传播规则】含义
REQUIRED如果父方法有事务，就加入，如果没有就新建自己独立！父方法有事务报错，子方法会回滚
REQUIRES_NEW不管父方法是否有事务，我都新建事务，都是独立的！即使父方法有有事务报错。两个子方法也不会回滚

在这里插入图片描述

就是用父方法 topService() 调用 子方法changeAge() 和 changeName()。这两个子方法是否会进行回滚


http://www.ppmy.cn/server/163894.html

相关文章

MySQL--》深度解析InnoDB引擎的存储与事务机制

MySQL--》深度解析InnoDB引擎的存储与事务机制

目录 InnoDB架构 事务原理 MVCC InnoDB架构 从MySQL5.5版本开始默认使用InnoDB存储引擎&#xff0c;它擅长进行事务处理&#xff0c;具有崩溃恢复的特性&#xff0c;在日常开发中使用非常广泛&#xff0c;其逻辑存储结构图如下所示&#xff0c; 下面是InnoDB架构图&#xf…
阅读更多...
毕业设计--具有车流量检测功能的智能交通灯设计

毕业设计--具有车流量检测功能的智能交通灯设计

摘要&#xff1a; 随着21世纪机动车保有量的持续增加&#xff0c;城市交通拥堵已成为一个日益严重的问题。传统的固定绿灯时长方案导致了大量的时间浪费和交通拥堵。为解决这一问题&#xff0c;本文设计了一款智能交通灯系统&#xff0c;利用车流量检测功能和先进的算法实现了…
阅读更多...
小白爬虫冒险之反“反爬”：无限debugger、禁用开发者工具、干扰控制台...（持续更新）

小白爬虫冒险之反“反爬”：无限debugger、禁用开发者工具、干扰控制台...（持续更新）

背景浅谈 小白踏足JS逆向领域也有一年了&#xff0c;对于逆向这个需求呢主要要求就是让我们去破解**“反爬机制”**&#xff0c;即反“反爬”&#xff0c;脚本处理层面一般都是decipher网站对request设置的cipher&#xff0c;比如破解一个DES/AES加密拿到key。这篇文章先不去谈…
阅读更多...
linux 管道符、重定向与环境变量

linux 管道符、重定向与环境变量

1. 输入输出重定向 在linux工作必须掌握的命令一文中&#xff0c;我们已经掌握了几乎所有基础常用的Linux命令&#xff0c;那么接下来的任务就是把多个命令适当的组合到一起&#xff0c;使其协同工作&#xff0c;会更高效的处理数据&#xff0c;做到这一点就必须搞清楚命令的输…
阅读更多...
【云安全】云原生-K8S-简介

【云安全】云原生-K8S-简介

K8S简介 Kubernetes&#xff08;简称K8S&#xff09;是一种开源的容器编排平台&#xff0c;用于管理容器化应用的部署、扩展和运维。它由Google于2014年开源并交给CNCF&#xff08;Cloud Native Computing Foundation&#xff09;维护。K8S通过提供自动化、灵活的功能&#xf…
阅读更多...
二叉树介绍

二叉树介绍

一.树的概念 树的图&#xff1a; 1.结点的度&#xff1a;一个结点含有子树的个数称为该结点的度&#xff1b; 如上图&#xff1a;A的度为6 2.树的度&#xff1a;一棵树中&#xff0c;所有结点度的最大值称为树的度&#xff1b; 如上图&#xff1a;树的度为6 3.叶子结点或终…
阅读更多...
MySQL 二进制安装（正式篇）

MySQL 二进制安装（正式篇）

Author&#xff1a;Arsen Date&#xff1a;2025/01/24 官方参考文档&#xff1a;点击链接跳转 目录 规划下载安装管理FAQ 规划 OSMySQL Server Version备注CentOS 7.9 or Linux - Generic8.0.33(GNU libc) 2.17 下载 二进制包下载地址&#xff1a;https://downloads.mysql.…
阅读更多...
OpenFGA

OpenFGA

1.什么是OpenFGA Fine-Grained Authorization 细粒度关系型授权 2.什么是细粒度授权 细粒度授权 (FGA) 意味着能够授予特定用户在特定资源中执行特定操作的权限。 精心设计的 FGA 系统允许您管理数百万个对象和用户的权限。随着系统不断添加对象并更新用户的访问权限&#…
阅读更多...
最新文章

Copyright @ 2022~2023