事务&AOP

于 2023-05-17 09:55:27 发布
阅读量325 收藏
点赞数
文章标签： spring java mybatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_47070121/article/details/130719243
版权

事务&AOP

事务管理

在数据库中我们已经学过事务了。

事务是一组操作的集合，它是不可再分的工作单位。事务会把所有的操作作为一个整体，一起向数据库提交或者撤销操作请求。所以这组操作要么是同时成功，要么同时失败。

事务的操作主要有三步：

  1. 开启事务（一组操作开始前，开启事务）：start transaction / begin;
  2. 提交事务（这组操作全部成功后，提交事务）：commit；
  3. 回滚事务（中间任何一个操作出现异常，回滚事务）：rollback；

Spring事务管理

事务管理案例：解散部门

需求：部门解散不仅需要把部门信息删除，还需要把该部门下的员工数据进行删除

步骤：

  • 根据id删除部门数据
  • 根据部门id删除该部门下的员工

代码实现：

DeptServiceImpl

@Slf4j
@Service
public class DeptServiceImpl implements DeptService {
	@Autowired
	private DeptMapper deptMapper;
	@Autowired
	private EmpMapper empMapper;
	//根据部门id，删除部门信息及部门下的所有员工
	@Override
	public void delete(Integer id){
		//根据部门id删除部门信息
		deptMapper.deleteById(id);
		//删除部门下的所有员工信息
		empMapper.deleteByDeptId(id); 
 	}
}

2、DeptMapper

@Mapper
public interface DeptMapper {
	/**
	* 根据id删除部门信息
	* @param id 部门id
	*/
	@Delete("delete from dept where id = #{id}")
	void deleteById(Integer id);
}

EmpMapper

@Mapper
public interface EmpMapper {
	//根据部门id删除部门下所有员工
	@Delete("delete from emp where dept_id=#{deptId}")
	public int deleteByDeptId(Integer deptId);
}

代码正常情况下，dept和Emp中的数据已经删除

如果修改DeptServiceImpl类中代码，添加可能出现异常的代码：

@Slf4j
@Service
public class DeptServiceImpl implements DeptService {
	@Autowired
	private DeptMapper deptMapper;
	@Autowired
	private EmpMapper empMapper;
    //根据部门id，删除部门信息及部门下的所有员工
	@Override
	public void delete(Integer id){
		//根据部门id删除部门信息
		deptMapper.deleteById(id);
		//模拟：异常发生
		int i = 1/0;
		//删除部门下的所有员工信息
		empMapper.deleteByDeptId(id); 
     }
}

此时：删除了2号部门，但是2号部门下的员工数据没有删除

以上程序出现的问题：即时程序运行出了异常部门依然删除了，但是部门下的员工却没有删除，造成了数据的不一致

原因分析

原因：

  • 先执行根据id删除部门的操作，这步执行完毕，数据库表dept中的数据就已经删除了
  • 执行I/O操作，执行异常
  • 抛出异常之前，下面所有代码不会执行，根据部门id删除该部门下的员工，这个操作也不会执行。

此时就会出现问题，部门下的员工还在，部门删除了，业务操作前后数据不一致

如果想要保证操作前后，数据的一致性，那就可以通过事务来实现，因为一个事务中的多个业务操作，要么全部成功，要么全部失败

在方法运行之前，开启事务，如果方法成功执行，就提交事务，如果方法执行过程中出现了异常，就回滚事务

在spring框架中已经把事务控制的代码封装好了，并不需要手动实现，只需要通过@Transaction注解。

Transactional注解

@Transactional作用：就是当前这个方法执行开始之前来开启事务，方法执行完毕之后，提交事务。如果这个方法执行的过程中出现了异常，就会出现事务回滚操作。

@Transactional注解：一般在业务层当中控制事务，因为在业务层当中，一个业务功能可能包含多个数据访问的操作，在业务层来控制事务，可以将多个数据访问操作控制在一个事务范围内。

@Transactional注解书写位置：

  • 方法
    • 当前方法交给spring进行事务管理
  • 类
    • 当前类中所有方法都交由spring进行事务管理
  • 接口
    • 接口下所有的实现类当中所有的方法都交给spring进行事务管理

进阶

@Transactional注解当中的两个常见的注解：

  1. 异常回滚的属性：rollbackFor
  2. 事务传播行为：propagation
rollbackFor
@Transactional
public void delete(Integer id){
	//根据部门id删除部门信息
	deptMapper.deleteById(id);
	//模拟：异常发生
	int i = 1/0;
	//删除部门下的所有员工信息
	empMapper.deleteByDeptId(id); 
}

以上业务功能delete()方法在运行时，会引发除0的算数运算异常（运行时异常），出现异常之后，由于使用了注解@Transactional注解进行事务管理，所以发生异常会执行rollbackFor回滚操作，从而保证事务操作前后数据是一致的。

注意：

  • 在spring的事务管理中，默认只有运行时异常RuntimeException才会回滚
  • 如果还需要回滚指定类型的异常，可以通过rollbackFor属性来指定
propagation

这个属性是用来配置事务的传播行为的

介绍

什么是事务的传播行为？

  • 就是当一个事务方法被另一个事务方法调用时，这个事务方法应该如何进行事务控制。

如果想要控制事务的传播行为，在@Transactional注解的后面指定一个属性propagation，通过propagation属性来指定传播行为。

常见的事务传播行为

属性值含义
REQUIRED【默认值】需要事务，有则加入，无则创建新事务
REQUIRES_NEW需要新事务，无论有无，总是创建新事务
SUPPORTS支持事务，有则加入，无则在无事务状态中运行
NOT_SUPPORTED不支持事务，在无事务状态下运行，如果当前存在已有事务，则挂起当前事务
MANDATORY必须有事务，否则抛异常
NEVER必须没事务，否则抛异常
…

对于这些事务传播行为，只需要关注以下两个：

  • REQUIRED（默认值）
  • REQUIRES_NEW
案例

需求：解散部门时需要记录操作日志

​ 由于解散部门是一个非常重要而且非常危险的部门，所以在业务当中要求每一次执行解散部门的操作都需要留下痕迹，就是要记录操作日志。而且还要求无论是执行成功了还是执行失败了都需要留下痕迹

步骤：

  1. 执行解散部门的业务：先删除部门，再删除部门下的员工
  2. 记录解散部门的日志，到日志表

准备工作

创建数据库表 dept_log日志表

create table dept_log(
	id int auto_increment comment '主键ID' primary key,
 	create_time datetime null comment '操作时间',
 	description varchar(300) null comment '操作描述'
)comment '部门操作日志表';

引入资料中提供的实体类：DeptLog

@Data
@NoArgsConstructor
@AllArgsConstructor
public class DeptLog {
	private Integer id;
	private LocalDateTime createTime;
	private String description;
}

引入资料中提供的Mapper接口：DeptLogMapper

@Mapper
public interface DeptLogMapper {
	@Insert("insert into 				dept_log(create_time,description) values(#{createTime},#{description})")
	void insert(DeptLog log);
}

引入业务接口：DeptLogService

public interface DeptLogService {
	void insert(DeptLog deptLog);
}

DeptLogServiceImpl

@Service
public class DeptLogServiceImpl implements DeptLogService {
	@Autowired
	private DeptLogMapper deptLogMapper;
	@Transactional //事务传播行为：有事务就加入、没有事务就新建事务
	@Override
	public void insert(DeptLog deptLog) {
		deptLogMapper.insert(deptLog);
 	}
}

代码实现：

业务实现类：DeptServiceImpl

@Slf4j
@Service
//@Transactional //当前业务实现类中的所有的方法，都添加了spring事务管理机制
public class DeptServiceImpl implements DeptService {
	@Autowired
	private DeptMapper deptMapper;
	@Autowired
	private EmpMapper empMapper;
    @Autowired
	private DeptLogService deptLogService;
	//根据部门id，删除部门信息及部门下的所有员工
	@Override
	@Log
	@Transactional(rollbackFor = Exception.class)
	public void delete(Integer id) throws Exception {
		try {
		//根据部门id删除部门信息
		deptMapper.deleteById(id);
		//模拟：异常
		if(true){
			throw new Exception("出现异常了~~~");
		}
		//删除部门下的所有员工信息
        empMapper.deleteByDeptId(id);
 		}finally {
			//不论是否有异常，最终都要执行的代码：记录日志
			DeptLog deptLog = new DeptLog();
			deptLog.setCreateTime(LocalDateTime.now());
			deptLog.setDescription("执行了解散部门的操作，此时解散的是"+id+"号部门");
			//调用其他业务类中的方法
			deptLogService.insert(deptLog);
		}
	}
}
测试：

重启springboot服务：

  • 执行了删除3号部门操作
  • 执行了插入部门日志操作
  • 程序发生Exception异常
  • 执行事务回滚（删除、插入操作因为在一个事务范围内，两个操作都会被回滚）

但是最终结果是dept_log表中没有记录日志数据

原因分析：
  • 在执行delete操作时开启了一个服务
  • 当执行insert操作时，insert设置的事务传播行是默认值REQUIRED，表示有事务就加入，没有则新建事务
  • 此时，delete和insert操作使用了同一个事务，同一个事务中的多个操作，要么同时成功，要么同时失败，所以当异常发生时进行事务回滚，就会回滚delete和insert操作
解决方案：

在DeptLogServiceImpl类中insert方法上，添加@Transactional（propagation = propagation.REQUIRES_NEW)

Propagation.REQUIRES_NEW：不论是否有事务，都创建新事务，运行在一个独立的事务中。

@Service
public class DeptLogServiceImpl implements DeptLogService {
	@Autowired
	private DeptLogMapper deptLogMapper;
	@Transactional(propagation = Propagation.REQUIRES_NEW)//事务传播行为：不论是否有事务，都新建事务
	@Override
	public void insert(DeptLog deptLog) {
		deptLogMapper.insert(deptLog);
	}
}

此时，DeptServiceImpl中的delete方法运行时，会开启一个事务。当调用deptLogService.insert(deptLog)时，也会创建一个新的事务，那此时，当insert方法运行完毕之后，事务就已经提交了。即时外部的事务出现异常，内部已经提交的事务，也不会回滚了，因为是两个独立的事务。

事务的传播行为只需要掌握两个：REQUIRED、REQUIRES_NEW

  • REQUIRED:大部分情况都是用该传播行为即可。
  • REQUIRES_NEW：当不希望事务之间相互影响时，可以使用该传播行为。比如：下订单前需要记录日志，不论订单保存成功与否，都需要保证日志记录能够记录成功。

img

AOP基础

AOP概述

什么是AOP？

  • AOP英文全称：Aspect Oriented Programming（面向切面编程、棉线方面编程），面向切面编程就是面向特定方法编程

AOP作用：在程序运行期间在不修改代码的基础上对已有方法进行增强（无侵入性：解耦）

面向指定的一个或多个方法进行编程，称为面向切面编程

其实AOP面向切面编程和OOP面向对象编程一样，仅仅是一种编程思想，而动态代理技术是这种思想最主流的实现方式。而Spring的AOP是Spring框架的高级技术，旨在管理bean对象的过程中底层使用动态代理机制，对特定的方法进行编程（功能增强）

AOP的优势：

  1. 减少重复代码
  2. 提高开发效率
  3. 维护方便
  4. 代码无侵入：没有修改原始的业务方法，就已经对原始的业务方法进行了功能的增强或功能的改变

AOP快速入门

需求：统计各个业务层方法执行耗时

实现步骤：

  1. 导入依赖：在pom.xml中导入AOP依赖
  2. 编写AOP程序：针对于特定方法根据业务需要进行编程

pom.xml

<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-aop</artifactId>
</dependency>

AOP程序：TimeAspect

@Component
@Aspect //当前类为切面类
@Slf4j
public class TimeAspect {
	@Around("execution(* com.itheima.service.*.*(..))")
	public Object recordTime(ProceedingJoinPoint pjp) throws
Throwable {
		//记录方法执行开始时间
		long begin = System.currentTimeMillis();
		//执行原始方法
		Object result = pjp.proceed();
		//记录方法执行结束时间
		long end = System.currentTimeMillis();
    	//计算方法执行耗时
		log.info(pjp.getSignature()+"执行耗时: {}毫秒",end-begin);
		return result;
 	}
}

AOP常见的应用场景：

  • 记录系统的操作日志
  • 权限控制
  • 事务管理：前面的Spring事务管理，底层其实也是通过AOP实现的，只要添加@Transactional注解之后，AOP程序自动会在原始方法运行前开启事务，在原始方法运行完毕之后提交或回滚事务

AOP核心概念

1、连接点：JoinPoint，可以被AOP控制的方法（暗含方法执行时的相关信息）

连接点指的是可以被aop控制的方法。如：入门程序当中所有业务方法都是可以被aop控制的方法

img

2、Advice，指哪些重复的逻辑，也就是共性功能（最终体现为一个方法）

在入门程序中是需要统计各个业务方法的执行耗时的，此时需要在这些业务方法开始之前，先记录方法运行的开始时间，在每一个业务方法运行结束的时候，在来记录这个方法运行的结束时间。

但是在AOP面向切面编程当中，只需要将这部分重复代码逻辑抽取出来单独定义。抽取出来的这部分重复的逻辑，就是共性的功能。

img

3、切入点：PointCut，匹配连接点的条件，通知仅会在切入点方法执行时被应用

切入点指的是匹配连接点的条件。通知仅会在切入点方法运行时才会被应用。

img

假如：切入点表达式改为DeptServiceImpl.list()，此时就代表仅仅只有list这个方法是切入点。只有list()方法在运行的时候才会应用通知。

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

当通知和切入点结合在一起，就形成一个切面。通过切面就能够描述当前aop程序需要针对于哪个原始方法，在什么时候执行什么样的操作。

img

切面所在的类，一般称为切面类（被@Aspect注解标识的类）

5、目标对象：target，通知所应用的对象

目标对象指的是通知所应用的对象

img

通知是如何与目标对象结合在一起，对目标对象当中的方法进行功能增强的？

img

Spring的AOP底层是基于动态代理技术实现的，也就是说程序在运行时，会自动的基于动态代理技术为目标对象生成一个对应的代理对象，在代理对象当中就会对目标对象当中的原始方法进行功能的增强。

img

AOP进阶

AOP当中的细节主要分为4个部分：

  • 通知类型
  • 通知顺序
  • 切入点表达式
  • 连接点

通知类型

Spring中AOP的通知类型：

  • @Around：环绕通知，此注解标注的通知方法在目标方法前、后都被执行
  • @Before：前置通知，此注解标注的通知方法在目标方法前被执行
  • @After：后置通知，此注解标注的通知方法在目标方法后被执行
  • @AfterReturning：返回后通知，此注解标注的通知方法在目标方法后被执行，有异常不会执行

代码展示

@Slf4j
@Component
@Aspect
public class MyAspect1 {
    // 前置通知
    @Before("execution(* com.dc.Service.*.*(..))")
    public void before(JoinPoint joinPoint) {
        log.info("before...");
    }

    // 环绕通知
    @Around("execution(* com.dc.Service.*.*(..))")
    public Object around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        log.info("around before...");

        // 调用目标对象的原始方法执行
        Object result = proceedingJoinPoint.proceed();

        // 原始方法如果执行时有异常，环绕通知中的后置代码不会在执行了
        log.info("around after ...");
        return result;
    }

    // 后置通知
    @After("execution(* com.dc.Service.*.*(..))")
    public void after(JoinPoint joinPoint) {
        log.info("after ....");
    }

    // 返回后通知（程序在正常执行情况下，会执行的后置通知）
    @AfterReturning("execution(* com.dc.Service.*.*(..))")
    public void afterThrowing(JoinPoint joinPoint) {
        log.info("afterThrowing ...");
    }
}

结果显示

img

程序没有发生异常的情况下，@AfterThrowing标识的通知方法不会执行

@Slf4j
@Service
public class DeptServiceImpl implements DeptService {
	@Autowired
	private DeptMapper deptMapper;
	@Override
	public List<Dept> list() {
		List<Dept> deptList = deptMapper.list();
		//模拟异常
		int num = 10/0;
		return deptList;
	}
}

查看idea中控制台日志输出

img

程序发生异常的情况下：

  • @AfterReturning标识的通知方法不会执行，@AfterThrowingg标识的通知方法执行了
  • @Around环绕通知中原始方法调用时有异常，通知中环绕后的代码逻辑也不会执行了（因为原始方法调用已经除了异常）

在使用通知时的注意事项：

  • @Around环绕通知需要自己调用ProceedingJoinPoint.proceed()来让原始方法执行，它通知不需要考虑目标方法执行
  • @Around环绕通知方法的返回值，必须指定为object，来接收原始方法的返回值，否则原始方法执行完毕，是获取不到返回值的

五种常见的通知类型，在刚才的测试中有什么问题？

 // 前置通知
    @Before("execution(* com.dc.Service.*.*(..))")

// 环绕通知
    @Around("execution(* com.dc.Service.*.*(..))")

 // 后置通知
    @After("execution(* com.dc.Service.*.*(..))")

 // 返回后通知（程序在正常执行情况下，会执行的后置通知）
    @AfterReturning("execution(* com.dc.Service.*.*(..))")

 // 异常通知（程序在出现异常的情况下，执行的后置通知）
    @AfterThrowing("execution(* com.dc.Service.*.*(..))")

在每一个注解里面都指定了切入点表达式，而且这些切入点表达式都是一摸一样的。此时代码当中就存在了大量重复性的切入点表达式，如果切入点表达式需要变动，就需要将所有的切入点表达式一个一个来改动，就变得非常繁琐。

可以通过抽取来解决切入点重复的问题

Spring提供了@PointCut注解，该注解的作用是将公共的切入点表达式抽取出来，需要用到的时候引用该切入点表达式即可。

@Slf4j
@Component
@Aspect
public class MyAspect1 {

    // 切入点方法（公共的切入点表达式）
    @Pointcut("execution(* com.dc.Service.*.*(..))")
    private void pt(){

    }

    // 前置通知(引用切入点）
    @Before("pt()")
    public void before(JoinPoint joinPoint) {
        log.info("before...");
    }

    // 环绕通知(引用切入点）
    @Around("pt()")
    public Object around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        log.info("around before...");

        // 调用目标对象的原始方法执行
        Object result = proceedingJoinPoint.proceed();

        // 原始方法如果执行时有异常，环绕通知中的后置代码不会在执行了
        log.info("around after ...");
        return result;
    }

    // 后置通知(引用切入点）
    @After("pt()")
    public void after(JoinPoint joinPoint) {
        log.info("after ....");
    }

    // 返回后通知（程序在正常执行情况下，会执行的后置通知）(引用切入点）
    @AfterReturning("pt()")
    public void afterReturning(JoinPoint joinPoint) {
        log.info("after ...");
    }

    // 异常通知（程序在出现异常的情况下，执行的后置通知）(引用切入点）
    @AfterThrowing("pt()")
    public void afterThrowing(JoinPoint joinPoint) {
        log.info("afterThrowing ....");
    }
}

注意：当切入点方法使用private修饰时，仅能在当前切面类中引用该表达式，当外部其他切面类中也要引用当前类中的切入点表达式，就需要把private改为public，而在引用时，具体的语法为：

全类名.方法名(),具体形式为：

@Slf4j
@Component
@Aspect
public class MyAspect2 {
	//引用MyAspect1切面类中的切入点表达式
	@Before("com.itheima.aspect.MyAspect1.pt()")
	public void before(){
		log.info("MyAspect2 -> before ...");
 	}
}

通知顺序

当在项目开发中，定义了多个切面类，而多个切面类中多个切入点都匹配了同一个目标方法。此时当目标方法在运行的时候，这多个切面类当中的这些通知方法都会运行。

此时这多个通知方法当中哪个先运行，哪个后运行？

定义多个切面类：

@Slf4j
@Component
@Aspect
public class MyAspect2 {
    // 前置通知
    @Before("execution(* com.dc.Service.*.*(..))")
    public void before(){
        log.info("MyAspect2 -> before ...");
    }

    // 后置通知
    @After("execution(* com.dc.Service.*.*(..))")
    public void after(){
        log.info("MyAspect2 -> after ...");
    }
}

@Slf4j
@Component
@Aspect
public class MyAspect3 {
    // 前置通知
    @Before("execution(* com.dc.Service.*.*(..))")
    public void before(){
        log.info("MyAspect3 -> before ...");
    }

    // 后置通知
    @After("execution(* com.dc.Service.*.*(..))")
    public void after(){
        log.info("MyAspect3 -> after ...");
    }
}

@Slf4j
@Component
@Aspect
public class MyAspect4 {
    // 前置通知
    @Before("execution(* com.dc.Service.*.*(..))")
    public void before(){
        log.info("MyAspect4 -> before ...");
    }

    // 后置通知
    @After("execution(* com.dc.Service.*.*(..))")
    public void after(){
        log.info("MyAspect4 -> after ...");
    }
}

结果显示：

img

通过以上程序可以看出在不同切面类中，默认按照切面类的类名字母排序：

  • 目标方法前的通知方法：字母排名靠前的先执行
  • 目标方法后的通知方法：字母排名靠前的后执行

如果想要控制通知执行顺序有两种方式：

  1. 修改切面类的类名（这种方法非常繁琐、而且不变管理）
  2. 使用Spring提供的@Order注解

使用@Order注解，控制通知的执行顺序：

@Slf4j
@Component
@Aspect
@Order(2)
public class MyAspect2 {
    // 前置通知
    @Before("execution(* com.dc.Service.*.*(..))")
    public void before(){
        log.info("MyAspect2 -> before ...");
    }

    // 后置通知
    @After("execution(* com.dc.Service.*.*(..))")
    public void after(){
        log.info("MyAspect2 -> after ...");
    }
}

Slf4j
@Component
@Aspect
@Order(1)
public class MyAspect4 {
    // 前置通知
    @Before("execution(* com.dc.Service.*.*(..))")
    public void before(){
        log.info("MyAspect4 -> before ...");
    }

    // 后置通知
    @After("execution(* com.dc.Service.*.*(..))")
    public void after(){
        log.info("MyAspect4 -> after ...");
    }
}

@Slf4j
@Component
@Aspect
@Order(3)
public class MyAspect3 {
    // 前置通知
    @Before("execution(* com.dc.Service.*.*(..))")
    public void before(){
        log.info("MyAspect3 -> before ...");
    }

    // 后置通知
    @After("execution(* com.dc.Service.*.*(..))")
    public void after(){
        log.info("MyAspect3 -> after ...");
    }
}

结果显示：

img

通知的执行顺序主要知道两点即可：

  1. 不同的切面类中，默认情况下通知的执行顺序是与切面类的类名字母排序是有关系的
  2. 可以在切面类上面添加@order注解，来控制不同的切面类通知的执行顺序

切入点表达式

切入点表达式：

  • 描述切入点方法的一种表达式
  • 作用：主要用来决定项目中的哪些方法需要加入通知
  • 常见形式：
    1. execution(…)：根据方法的签名类匹配
    2. @annotation(…)：根据注解匹配
execution

executioin主要根据方法的返回值、包名、方法名、方法参数等信息来匹配，语法为：

execution（访问修饰符？ 返回值 包名.类名.?方法名(方法参数) throws 异常?)

其中带?的表示可以省略的部分

  • 访问修饰符：可省略(比如：public、protected)
  • 包名.类名: 可省略
  • throws异常: 可省略(注意是方法上声明抛出的异常,不是实际抛出的异常)

示例:

@Before("execution(void com.dc.Service.impl.DeptServiceImpl.delete(java.lang.Integer))")

可以使用通配符描述切入点

  • *:单个独立的任意符号,可以通配任意返回值、包名、类名、方法名、任意类型的一个参数，也可以通配包、类、方法名的一部分
  • ..：多个连续的任意符号，可以通配任意层级的包，或任意类型、任意个数的参数

切入点表达式的语法规则：

  1. 方法的访问修饰符可以省略
  2. 返回值可以使用*号代替（任意返回值类型）
  3. 包名可以使用*号代替,代表任意包(一层包使用一个*)
  4. 使用..配置包名,标识此包以及此包下的所有子包
  5. 类名可以使用*号代替,表示任意类
  6. 方法名可以使用*号代替,表示任意方法
  7. 可以使用*配置参数,一个任意类型的参数
  8. 可以使用..配置参数,任意个任意类型的参数
切入点表达式示例

  • 省略方法的修饰符号

    execution(void com.dc.Service.impl.DeptServiceImpl.delete(java.lang.Integer))

  • 使用*代替返回值类型

    execution(* com.dc.Service.impl.DeptServiceImpl.delete(java.lang.Integer))

  • 使用*代替包名(一层包使用一个*)

    execution(* com.dc.*.*.DeptServiceImpl.delete(java.lang.Integer))

  • 使用..省略包名

    execution(* com..DeptServiceImpl.delete(java.lang.Integer))

  • 使用*代替类名

    execution(* com..*.delete(java.lang.Integer))

  • 使用*代替方法名

    execution(* com..*.*(java.lang.Integer))

  • 使用*代替参数

    execution(* com.dc.Service.impl.DeptServiceImpl.delete(*))

  • 使用..省略参数

    execution(* com..*.*(..))

注意:

  • 可以根据业务需要,可以使用且(&&)、或（||）、非（！）来组合比较复杂的切入点表达式

    execution(* com.dc.Service.DeptService.list(..)) || execution(* com.dc.Service.DeptService.delete(..))

切入点表达式的书写建议：

  • 所有业务方法名在命名时尽量规范，方便切入点表达式快速匹配。如：查询类方法都是find开头，更新类方法都是update开头

    // 业务类
@Service
public class DeptServiceImpl implements DeptService{
    
    public List<Dept> findAllDept(){
        // 省略代码
    }
    
    public Dept findDeptById(Integer id) {
        // 省略代码
    }
    
    public void updateDeptById(Integer id) {
        // 省略代码
    }
    
    public void updateDeptByMoreCondition(Dept dept) {
        // 省略代码
    }
}

    // 匹配DeptServiceImpl类中find开头的方法
execution(* com.dc.Service.impl.DeptServiceImpl.find*(..))

  • 描述切入点方法通常基于接口描述，而不是直接描述实现类，增强拓展性

    execution(* com.dc.Service.DeptService.*(…))

  • 在满足业务需要的前提下，尽量缩小切入点的匹配范围。如：包名匹配尽量不使用…，使用*匹配单个包

    execution(* com.dc...DeptServiceImpl.find*(…))

@annotation

如果要匹配多个无规则的方法，比如：list()和delete()这两个方法.这时基于execution这种切入点表达式来描述就不是很方便.这就需要另一种切入点表达式annotation来描述这一类的切入点,从而简化切入点表达式的书写

实现步骤:

  1. 编写自定义注解
  2. 在业务类要为连接点的方法上添加自定义注解

自定义注解:MyLog

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyLog {
}

业务类:DeptServiceImpl

@Slf4j
@Service
public class DeptServiceImpl implements DeptService {

    @Resource
    private DeptMapper deptMapper;
    // 查询所有的部门数据
    @Override
    @MyLog // 自定义注解（表示：当前方法属于目标方法）
    public List<Dept> list() {
        List<Dept> deptList = deptMapper.list();
        return deptList;
    }

    // 根据id删除部门信息
    @Override
    @MyLog // 自定义注解（表示：当前方法属于目标方法）
    @Transactional(rollbackFor = Exception.class)
    public void delete(Integer id) {
        // 根据部门id删除部门信息
        deptMapper.deleteById(id);
    }

    @Override
    @MyLog // 自定义注解（表示：当前方法属于目标方法）
    public void insert(Dept dept) {
        dept.setCreateTime(LocalDateTime.now());
        dept.setUpdateTime(LocalDateTime.now());
        deptMapper.insert(dept);
    }
}

切面类

@Slf4j
@Component
@Aspect
public class MyAspect6 {
    // 针对list方法和delete方法进行前置通知和后置通知

    // 前置通知
    @Before("@annotation(com.dc.anno.MyLog)")
    public void before(){
        log.info("MyAspect6 -> before ...");
    }

    // 后置通知
    @After("@annotation(com.dc.anno.MyLog)")
    public void after(){
        log.info("MyAspect6 -> after ...");
    }
}

重启SpringBoot服务,测试查询所有部门数据,查看控制日志

img

img

两种切入点表达式:

  • execution切入点表达式:
    • 根据所指定的方法的描述信息来匹配切入点方法,这种方法也是最为常用的一种方式
    • 如果要匹配的切入点方法的方法名不规则,或者有一些比较特殊的需求,通过execution切入点表达式描述比较繁琐
  • annotation切入点表达式
    • 基于注解的方式来匹配切入点方法，这种方式虽然多一步操作，需要自定义一个注解，但是相对来说比较灵活。需要匹配哪个方法，就在哪个方法上加上对应的注解就可以了。

img

连接点

在Spring中用JoinPoint抽象了连接点，用它可以获得方法执行时的相关信息，如目标类名、方法名、方法参数等。

  • 对于@Around通知，获取连接点信息只能使用ProceedingJoinPoint类型
  • 对于其他四种通知，获取连接点信息只能使用JoinPoint，它是ProceedingJoinPoint的父类型

示例：

@Slf4j
@Aspect
@Component
public class MyAspect7 {
    @Pointcut("@annotation(com.dc.anno.MyLog)")
    private void pt(){

    }

    //前置通知
    @Before("pt()")
    public void before(JoinPoint joinPoint) {
        log.info(joinPoint.getSignature().getName() + "MyAspect7 -> before ...");
    }

    // 后置通知
    @After("pt()")
    public void after(JoinPoint joinPoint) {
        log.info(joinPoint.getSignature().getName() + "MyAspect7 -> after ...");
    }

    // 环绕通知
    @Around("pt()")
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        // 获取类名
        String name = pjp.getTarget().getClass().getName();
        log.info("目标方法名：{}", name);

        // 获取方法执行时需要的参数
        Object[] args = pjp.getArgs();
        log.info("目标参数：{}", Arrays.toString(args));

        // 执行原始方法
        return pjp.proceed();
    }
}

执行查询部门数据的功能

img

img

没办法，我就是这么菜
关注
SpringBoot 事务&Aop 失效问题
qq_38454673的博客
11-19 967
SpringBoot 事务&Aop 失效问题最近准备搭建新的springboot项目，用到了shiro及aop，aop主要是日志和sping全局事务配置。但是service层事务怎么都没有生效，经过大半天的查阅资料最后终于找到罪魁祸首：==shiro==原因是我在shiro注入了service查询了权限，所有注入的service的aop都失效了，解决办法就是在shiro注入的service...
AOP 与 事务
qq_38735317的博客
11-01 2054
AOP aspect 由 pointcount 和 advice 组成, 它既包含了横切逻辑的定义, 也包括了连接点的定义. Spring AOP就是负责实施切面的框架, 它将切面所定义的横切逻辑织入到切面所指定的连接点中. AOP的工作重心在于如何将增强织入目标对象的连接点上, 这里包含两个工作: 如何通过 pointcut 和 advice 定位到特定的 joinpoint 上 如何在...
事务与aop
xiaoyi52的专栏
07-24 1821
事务配置AOP的基本概念就不说了，其作用是为了将一组操作提取出来，在必要的时候再将其插入到代码中去。提取出来的一组操作就是一个aop切面组件，事务是aop最常用的场景之一，严格上说是声明式事务。事务分为编程式事务和声明式事务。编程式事务指通过编码方式实现事务，管理使用TransactionTemplate，优点是灵活性更强，事务的粒度可以控制到语句级别。但缺点是对代码的侵入性较强。声明式事务是建立在
AOP实现入库异常回滚
不如养猪！
07-24 430
<aop:advisor pointcut="execution(* com.mingtian..service..*.*(..))" advice-ref="txAdvice" />
AOP事物部分回滚的原因
Gandoph的博客
05-21 1029
1.概述Spring AOP 默认对RuntimeException()异常或是其子类进行事务回滚，也就是说：    事务回滚：throw new RuntimeException("xxxxxxxxxxxx");     事物不回滚：throw new Exception("xxxxxxxxxxxx"); 那么，如何在抛出Exception或者自定义异常时，事务也进行回滚呢？有以下几种方案：在捕...
SpringAop学习笔记（二）——Spring事务回滚的原理
weixin_39555954的博客
08-17 935
目录 一、代码 二、Spring 事务失效之谜 一、代码 package com.xiaojie.annotation; import java.lang.annotation.*; /** * 自定义事务注解 */ @Target({ElementType.TYPE, ElementType.METHOD}) @Retention(RetentionPolicy.RUNTIME) @Inherited @Documented public @interface MyTransacti
SpringBoot-事务&AOP-黑马程序员学习笔记
最新发布
05-21
本笔记主要关注Spring Boot中的两个核心概念：事务管理和面向切面编程（AOP）。我们将深入探讨这两个主题，理解它们的工作原理以及如何在实际项目中应用。 ### 事务管理 事务是数据库操作的基本单元，确保数据的...
Spring与Mybatis整合&&aop整合pageHelper分页插件
08-25
- 在Spring与Mybatis的整合中，AOP常用于事务管理。可以定义一个事务切面，当满足特定条件（如方法执行异常）时，自动回滚事务。 3. PageHelper分页插件的使用： - PageHelper是Mybatis的第三方插件，提供了强大...
ObjectLocator&AOP; v4.1
03-28
AOP允许开发者将关注点分离，将业务逻辑和横切关注点（如日志记录、事务管理、性能监控等）进行解耦。在.NET 4.0及以上环境中，Netop.Util.dll库提供了AOP的支持。开发者可以通过定义切面、切点和通知来实现这些关注...
ISpring-IOC-AOP:自定义IOC & AOP实现
05-26
AOP提供了一种模块化横切关注点（如日志、事务管理）的方法，使得业务代码不受这些通用服务的侵扰。在Spring中，AOP主要通过代理模式实现。 1. **切面（Aspect）**：切面是封装了多个关注点的模块，例如一个事务...
springAOP 事物的回滚级别
Happy_wu的专栏
11-18 930
service如果想输出异常就在catch里面抛出runtimeexception异常 这样spring的aop事务能进行回滚。 主要是spring的aop事务只识别两种异常 一种就是runtimeexception一种就是error 这两种是默认的 （详细查看后再来补充）
一站式异常处理（spring AOP事务回滚问题）
u012289341的博客
02-14 999
感谢http://mp.weixin.qq.com/s/j8vc1g51geIvGvgEvCvi-w 异常的类别 ava中的异常的超类是java.lang.Throwable(后文省略为Throwable),它有两个比较重要的子类,java.lang.Exception(后文省略为Exception)和java.lang.Error(后文省略为Error)，其中Error由JVM虚拟机进行管理
事物传播行为：propagation = Propagation.REQUIRES_NEW 不生效问题
fenjindecainiao1的博客
10-24 5969
@Transactional(propagation = Propagation.REQUIRES_NEW, isolation = Isolation.READ_COMMITTED, rollbackFor = {Throwable.class}, readOnly = false) 传播行为：propagation = Propagation.REQUIRES_NEW 不生效问题 因为： 由...
spring管理的事务中的日志记录
tempsitegoogle
04-23 448
PROPAGATION_REQUIRES_NEW这个就比较绕口了。比如我们设计ServiceA.methodA的事务级别为PROPAGATION_REQUIRED，ServiceB.methodB的事务级别为PROPAGATION_REQUIRES_NEW， 那么当执行到ServiceB.methodB的时候，ServiceA.methodA所在的事务就会挂起，ServiceB.methodB会...
Spring（三）父子容器、国际化、异步调用、定时器、缓存
HK的博客
05-01 3535
父子容器、国际化、@Async、@Scheduled、@Cacheable
springAOP面向切面编程以及对事务的支持
qq_43814760的博客
04-21 1657
目录 一、springAOP 面向切面编程 （一）springAOP概念解析 （二）springAOP的XML文件配置 1.入门案例 2.AOP的工作流程 3.通知类型 4.切点表达式 5.配置所有通知类型 （三）springAOP通过注解去配置 二、springAOP对事务的支持 （一）事务的简介 1.jdbc中的事务 2.spring中的事务控制 3.spring中事务管理的核心类和方法 (二) 使用xml配置事务 1.使用spring创建一个转账的功能实...
Spring aop事务异常回滚（rollbackFor）机制和源码分析
码农的世界你不懂
03-02 3567
我们这使用spring aop进行声明式事务编程时，经常需要配置rollbackFor,指需要开启事务的方法抛出异常时，事务针对什么异常进行回滚，如下图是spring事务回滚的 源码：txInfo.transactionAttribute.rollbackon(ex)对异常类型进行判断，判断配置的事务属性是否对ex这个异常类型进行回滚， 如果进行回滚，则调txInfo.getTransacti
Spring中解决Aop 事务嵌套回滚问题
cuibruce的博客
11-04 4935
今天被坑了，这是部分代码 //组装操作日志  这个增强里面后面的两个参数必须一样，为函数执行后返回的结果  @AfterReturning(value="addLog()",argNames="rtv",returning="rtv")  public void packLogs(JoinPoint joinPoint,Object rtv) throws Throwable {     
Transaction 事务回滚无效，常见原因！！！
无术不学的博客
12-05 3343
http://www.cnblogs.com/culushitai/p/9205036.html
AOP实现SqlSugar自动事务处理
"这篇文章主要讲解如何利用AOP(面向切面编程)来实现SqlSugar的自动事务管理，特别是在带有接口层的三层架构中。通过AOP，我们可以将事务管理的逻辑从业务代码中分离出来，使得代码更加清晰，易于维护。下面我们将...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值