JavaWeb学习路线（9）—— 事务管理和AOP

一、事务管理

概念： 事务是一组操作的集合，这一组集合具有原子性，要么全部成功，要么全部失败。
作用： 当出现异常时，能有效控制数据不丢失。
使用方法—— 注解

（一）事务注解 @Tranactional

位置： 业务层（Service）方法上，类上，接口上
作用： 将当前方法交给Spring进行管理，方法执行前，开启事务；成功执行完毕，提交事务；出现异常，回滚事务。

//接口上
@Transactional
public interface EmpService{
    
    
	void delete(Integer id);
}

//类上
@Transactional
class EmpController implements EmpService{
    
    
	//方法上
	@Transactional
	@Override
	public void delete(Integer id){
    
    
		//处理代码
	}
}

（二）事务常见参数、
1、rollbackFor 事务回滚属性

（1）设置原因： @Transactional 默认在出现Runtime异常才能回滚。

（2）设置事务回滚属性： @Transactional( rollbackFor = Exception.class )

2、propagation 事务传播行为

（1）概念： 当一个事务方法被另一个实物方法调用时，这个事务如何进行事务控制
（2）常见的传播行为

传播行为	说明
REQUIRED（要求；需要）	默认，需要事务，有则加入事务，无则创建事务
REQUIRES_NEW（要求新的）	需要新事务，无论有无总是创建事务
SUPPORTS	支持事务，有则加入事务，无则在无事务状态下运行
NOT_SUPPORTED	不支持事务，在无事务状态下运行，如果存在事务，则挂起当前事务
MANDATORY（强制）	必须有事务，否则抛异常
NEVER	必须没有事务，否则抛异常
…

二、AOP

（一）AOP基础

概念： Aspect Oriented Programming（面向切面编程、面向方面编程），其实是面向特定方法编程。
作用： 通过动态代理机制，对特定的方法进行编程。
AOP的使用场景
- 记录操作日志
- 权限控制
- 事务管理
- …
AOP的优点
- 代码无侵入： 不改变原有的方法执行体
- 减少重复代码： 抽取公共操作代码
- 提高开发效率： 可以进行统一的操作
- 维护方便： 改变额外代码或原始代码时，不需要依次修改。
使用AOP
- 添加依赖org.springframework.boot.spring-boot-starter-aop
- 编写AOP程序

@Component //Spring容器进行管理
@Aspect //声明AOP
public class TimeAspect{
    
    
	//@Around —— 环绕通知 
	//execution(返回值 作用的包名.类/接口.方法(参数)) —— 启动范围
	@Around("execution(* com.zengoo.service.*.*(..))")
	public Object recordTime(ProceedingJoinPoint joinPoint) throws Throwable{
    
    
		//1.记录时间
		long begin = System.currentTimeMillis();
		//2.运行原始方法
		//ProceedingJoinPoint 是原始方法切入点
		Object result = joinPoint.proceed();
		//3.记录时间
		long end = System.currentTimeMillis();
		
		return result;
	}
}

（二）AOP的核心概念
1、连接点： JoinPoint，所有方法都属于连接点。
2、通知： Advice，指共性方法，即AOP的处理方法。
3、切入点： PointCut，实际被AOP控制的方法。
4、切面： Aspect，描述通知与切入点的对应关系，所有切面的集合被放到了切面类中。
5、目标对象： Target，AOP实际控制的方法。

@Component
@Aspect
public DemoAspect{
    
    
	//抽取切入点表达式
	@PointCut("execution(* com.zengoo.service.*.*(..))")
	public void pt(){
    
    }
	//切面
	@Around("pt()") //引用切入点
	//通知
	public Object around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{
    
    
		//前置代码...
		//目标对象
		Object result = proceedingJoinPoint.proceed();
		//后置代码...
		return result;
	}
}

（三）AOP参数细节
1、通知类型

通知类型	说明
@Around	环绕通知，此注解标注的通知方法在目标方法前、后都被执行。
@Before	前置通知，此注解标注的通知方法在目标方法前被执行。
@After	后置通知，此注解标注的通知方法在目标方法后被执行，无论是否发生异常。
@AfterReturning	返回后通知，此注解标注的通知方法在目标方法后被执行，发生异常则取消执行。
@AfterThrowing	异常后通知，此注解标注的通知方法异常后执行。

2、通知顺序

（1）不同切面类中，默认按照切面类的类名进行排序（繁琐）

Before 通知：排名靠前先执行。（入栈）
After 通知：排名考后先执行。（出栈）

（2）@Order(数字)控制优先级

Before 通知：数字小先执行。
After 通知：数字大先执行。

@Order(1) //最先执行Before，最后执行After
public class MyAspect1{
    
    
	...
}

@Order(2） //最后执行Before，最先执行After
class MyAspect2{
    
    
	...
}

3、切入点表达式

（1）概念： 描述切入点方法的一种表达式
（2）作用： 匹配项目中的方法加入通知
（3）常见形式：

execution([访问修饰符] 返回值 [包名.类名.]方法名(方法参数) [throws 异常])：根据方法签名匹配
- 通配符
  - * ：单个独立的任意字符，通配任意返回值、包名、类名、方法名、参数或名称的一部分。
  - … ：多个连续的任意符号，通配任意层级的包或任意类型、任意个数的参数
- 多方法匹配
  - ||、&&、！ ：用于多个具体方法的匹配
- 书写建议
  - 所有业务的方法名在命名时尽量规范，方便切入点表达式快速匹配。例如查询类方法使用query或find开头，更新类方法使用update或modify开头。
  - 描述切入点方法通常基于接口描述，增强拓展性。
  - 在满足业务的前提下，尽量缩小切入点的匹配范围。
execution(@annotation(...))：根据注解匹配

//自定义一个注解
@Retention(RetentionPolicy.RUNTIME) //生效时间
@Target(ElementType.METHOD) //作用位置
public @interface MyAnnotation{
    
    }


@Service
class xxxServiceImpl implements xxxService{
    
    
	//标记切入点
	@MyAnnotation
	@Override
	public xxx xxx(){
    
     return xxx; }
}

@Component
@Aspect
class MyAspect{
    
    
	//匹配所有加上了 @MyAnnotation 的方法
	@PointCut(@annotation("com.zengoo.annotation.MyAnnotation"))
	public void ptAnnotation(){
    
    }
	
	@Before("ptAnnotation()")
	public void xxx(){
    
    
		...
	}
}

4、连接点

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

对于 @Around 通知，使用 ProceedingJoinPoint
其它四种通知，使用JoinPoint，它是 ProceedingJoinPoint的父类型。

@Before
public void testxxx(JoinPoint joinPoint){
    
    };

实现方法	说明
joinPoint.getTarget().getClass().getName()	获取类名
joinPoint.getSignature().getName()	获取方法名
joinPoint.getArgs()	获取运行时传入的参数
joinPoint.proceed()	运行目标方法
joinPoint.proceed()的返回值	获取返回值

（四）AOP案例——操作日志

（1）操作日志的信息

操作人
操作时间
执行方法的全类名
执行方法名
方法运行时的参数
返回值
方法执行时长

（2）实现

准备工作

AOP依赖与lombok依赖

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

数据库结构

create table operate_log(
	id int usigned primary key auto_increment comment '操作ID',
	operate_user int unsigned comment '操作人ID',
	operate_time datetime comment '操作时间',
	class_name varchar(100) comment '执行方法的全类名',
	method_name varchar(100) comment '执行方法名',
	method_params varchar(1000) comment '方法运行时的参数',
	return_value varchar(2000) comment '返回值',
	cost_time bigint comment '方法执行时长,单位：ms'
) comment '操作日志表'

实体类

@Data
@NoArgsConstructor
@AllArgsConstructor
public class OperateLog{
    
    
	private Integer id;
	private Integer operateUser;
	private LocalDateTime operatetime;
	private String className;
	private String methodName;
	private String methodParams;
	private String returnValue;
	private Long costTime;
}

编码

自定义注解 @Log

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

}

定义切面类，完成记录操作日志的逻辑

@Component
@Aspect
public class OperateAspect {
    
    

	@Autowired
	private HttpServletRequest request;

	@Autowired
	private OperateLogMapper operateLogMapper;

    @Pointcut("@annotation(com.zengoo.annotation.Log)")
    public void pc(){
    
    }

    @Around("pc()")
    public Object operateLog(ProceedingJoinPoint joinPoint) throws Throwable {
    
    

		//操作人的ID
		//获取令牌并解析
		String jwt = request.getHeader("token");
		Claims claims = JwtUtils.parseJWT(jwt);
		Integer operateUser = (Integer) claims.get("id");
		
		//操作时间
		LocalDateTime operateTime = LocalDateTime.now();
		
		//操作类名
		String className = joinPoint.getTarget().getClass.getName();

		//操作方法名
		String methodName = joinPoint.getSignature().getName();
	
		//传入的形参列表
		Object[] args = joinPoint.getArgs();
		String methodParams = Arrays.toString(args);
		
		Long start = System.currentTimeMillis();
        Object result = joinPoint.proceed();
        Long end= System.currentTimeMillis();
        
		//返回值
		Stirng returnValue = JSONObject.toJSONString(result);

		//耗时
		Long costTime = end - start;
		
		//记录操作日志
		//该方法是插入记录的sql
		OperateLog operateLog = new OperateLog(	
				null,
				operateUser,
				operateTime,
				className,
				methodName,
				methodParams,
				returnValue,
				costTime
		);
		operateLogMapper.record(operateLog); 
		
        return result;
    }
}

JavaWeb学习路线（9）—— 事务管理和AOP

猜你喜欢