Java Web —— 第十天（AOP切面编程）

AOP基础

AOP概述

AOP:Aspect Oriented Programming(面向切面编程、面向方面编程)，其实就是面向特定方法编程场景

案例部分功能运行较慢，定位执行耗时较长的业务方法，此时需要统计每一个业务方法的执行耗时

实现:

动态代理是面向切面编程最主流的实现。而SpringAOP是Spring框架的高级技术，旨在管理bean对象的过程中，主要通过底层的动态代理机制，对特定的方法进行编程 

Spring AOP快速入门

步骤: 统计各个业务层方法执行耗时

1.导入依赖:在pom.xml中导入AOP的依赖

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

2.编写AOP程序:针对于特定方法根据业务需要进行编程

package com.example.aop;

import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;

/**
 * @author hyk~
 */

@Slf4j
@Component //当前类交给IOC容器管理
@Aspect //当前类是一个AOP类
public class TimeAspect {
    @Around("execution(* com.example.service.*.*(..))") //切入点表达式
    public Object recordTime(ProceedingJoinPoint joinPoint) throws Throwable {
        //1.记录开始时间
        long begin = System.currentTimeMillis();

        //2.调用原始方法运行
        Object result = joinPoint.proceed();

        //3.记录结束时间，计算方法执行耗时
        long end = System.currentTimeMillis();

        log.info(joinPoint.getSignature()+"方法执行耗时：{}ms",end-begin);

        return result;

    }

}

3.运行测试

场景

记录操作日志

权限控制

事务管理

...

优势

代码无侵入

减少重复代码

提高开发效率

维护方便

AOP核心概念

连接点:JoinPoint，可以被AOP控制的方法(暗含方法执行时的相关信息)

通知:Advice，指哪些重复的逻辑，也就是共性功能(最终体现为一个方法)

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

切面:Aspect，描述通知与切入点的对应关系 (通知+切入点)

目标对象: Target，通知所应用的对象

AOP执行流程

AOP进阶

通知类型

1.@Around: 环绕通知，此注解标注的通知方法在目标方法前、后都被执行

2.@Before:前置通知，此注解标注的通知方法在目标方法前被执行

3.@After:后置通知，此注解标注的通知方法在目标方法后被执行，无论是否有异常都会执行

4.@AfterReturning:返回后通知，此注解标注的通知方法在目标方法后被执行，有异常不会执

5.@AfterThrowing:异常后通知，此注解标注的通知方法发生异常后执行

package com.itheima.aop;

import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

/**
 * 使用 Lombok 提供的 @Slf4j 注解，自动为该类生成日志记录器。
 */
@Slf4j
/**
 * 将该类标记为 Spring 管理的组件，使其能够被 Spring 自动检测并注入。
 */
@Component
/**
 * @Aspect 注解将该类声明为一个切面类，用于定义切点和通知。如果解开此注解，MyAspect1 类将作为一个切面生效。
 */
// @Aspect
public class MyAspect1 {

    /**
     * 定义一个切点（Pointcut），表示在哪些方法或类上应用通知。
     * 此处的切点表达式为 execution(* com.itheima.service.impl.DeptServiceImpl.*(..))，
     * 表示切点是 com.itheima.service.impl.DeptServiceImpl 类中的所有方法。
     */
    @Pointcut("execution(* com.itheima.service.impl.DeptServiceImpl.*(..))")
    public void pt() {}

    /**
     * 前置通知（Before advice），在目标方法执行之前执行。
     * 当 DeptServiceImpl 类中的任意方法被调用时，会先执行此通知。
     */
    @Before("pt()")
    public void before() {
        log.info("before ...");
    }

    /**
     * 环绕通知（Around advice），在目标方法执行前后分别执行。
     * 该方法可以控制目标方法是否执行，甚至可以在执行前后添加自定义逻辑。
     *
     * @param proceedingJoinPoint 用于控制目标方法的执行
     * @return 目标方法的返回值
     * @throws Throwable 可能抛出的异常
     */
    @Around("pt()")
    public Object around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        log.info("around before ...");

        // 调用目标对象的原始方法并获取其返回值
        Object result = proceedingJoinPoint.proceed();

        log.info("around after ...");
        return result;
    }

    /**
     * 后置通知（After advice），在目标方法执行完毕后执行，无论方法是否抛出异常。
     */
    @After("pt()")
    public void after() {
        log.info("after ...");
    }

    /**
     * 返回通知（AfterReturning advice），在目标方法成功执行并返回结果后执行。
     * 如果方法抛出异常，则不会执行此通知。
     */
    @AfterReturning("pt()")
    public void afterReturning() {
        log.info("afterReturning ...");
    }

    /**
     * 异常通知（AfterThrowing advice），在目标方法抛出异常后执行。
     */
    @AfterThrowing("pt()")
    public void afterThrowing() {
        log.info("afterThrowing ...");
    }
}

正常运行 

有异常时

注意事项

@Around环绕通知需要自己调用 ProceedingJoinPoint.proceed() 来让原始方法执行，其他通知不需要考虑目标方法执行

@Around环绕通知方法的返回值，必须指定为object，来接收原始方法的返回值

@PointCut

该注解的作用是将公共的切点表达式抽取出来，需要用到时引用该切点表达式即可

通知顺序

当有多个切面的切入点都匹配到了目标方法，目标方法运行时，多个通知方法都会被执行

执行顺序

1.不同切面类中，默认按照切面类的类名字母排序:

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

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

2.用 @Order(数字) 加在切面类上来控制顺序

目标方法前的通知方法:数字小的先执行

目标方法后的通知方法:数字小的后执行

切入点表达式

切入点表达式:描述切入点方法的一种表达式

作用:主要用来决定项目中的哪些方法需要加入通知

常见形式

1.execution(.....):根据方法的签名来匹配

2.@annotation(.....) :根据注解匹配

切入点表达式-execution

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

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

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

访问修饰符:可省略 (比如: public、protected)

包名.类名: 可省略

throws 异常:可省略(注意是方法上声明抛出的异常，不是实际抛出的异常)

使用通配符描述切入点

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

1. 方法的访问修饰符可以省略

2. 返回值可以使用 * 号代替（任意返回值类型）

3. 包名可以使用 * 号代替，代表任意包（一层包使用一个 * ）

4. 使用 .. 配置包名，标识此包以及此包下的所有子包

5. 类名可以使用 * 号代替，标识任意类

6. 方法名可以使用 * 号代替，表示任意方法

7. 可以使用 * 配置参数，一个任意类型的参数

8. 可以使用 .. 配置参数，任意个任意类型的参数

同时匹配这两个方法

 @Pointcut("execution(* com.itheima.service.DeptService.list()) ||"+
    "execution(* com.itheima.service.DeptService.delete(java.lang.Integer))")
    private void pt(){}

    @Before("pt()")
    public void before(){
        log.info("MyAspect6 ... before ...");
    }

注意事项

根据业务需要，可以使用且 (&&)、或()、非(!)来组合比较复杂的切入点表达式

书写建议

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

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

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

@annotation

@annotation 切入点表达式，用于匹配标识有特定注解的方法

@annotation(com.itheima.anno.Log)

实现步骤：

1. 编写自定义注解

自定义注解：MyLog

@Retention(RetentionPolicy.RUNTIME) // 该注解在运行时可用
@Target(ElementType.METHOD) // 该注解只能用于方法
public @interface MyLog {
}

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

业务类：DeptServiceImpl

连接点

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

对于@Around通知，获取连接点信息只能使用ProceedingJoinPoint类型

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

package com.itheima.aop;

import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

import java.util.Arrays;

//切面类
@Slf4j
@Aspect
@Component
public class MyAspect8 {

    @Pointcut("execution(* com.itheima.service.DeptService.*(..))")
    private void pt(){}

    @Before("pt()")
    public void before(JoinPoint joinPoint){
        log.info("MyAspect8 ... before ...");
    }

    @Around("pt()")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        log.info("MyAspect8 around before ...");

        //1. 获取 目标对象的类名 .
        String name1 = joinPoint.getTarget().getClass().getName();
        log.info("目标对象的类名：{}",name1);

        //2. 获取 目标方法的方法名 .
        String name2 = joinPoint.getSignature().getName();
        log.info("目标方法的方法名:{}",name2);


        //3. 获取 目标方法运行时传入的参数 .
        Object[] args = joinPoint.getArgs();
        log.info("目标方法运行时传入的参数:{}",Arrays.toString(args));


        //4. 放行 目标方法执行 .
        Object result = joinPoint.proceed();


        //5. 获取 目标方法运行的返回值 .
        log.info("目标方法运行的返回值:{}",result);

        log.info("MyAspect8 around after ...");
        return result;

    }
}

AOP案例

案例

将案例中 增、删、改 相关接口的操作日志记录到数据库表中

就是当访问部门管理和员工管理当中的增、删、改相关功能接口时，需要详细的操作日志，并保存 在数据表中，便于后期数据追踪。

操作日志信息包含： 操作人、操作时间、执行方法的全类名、执行方法名、方法运行时参数、返回值、方法执行时长

1. AOP起步依赖

<!--AOP起步依赖-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-aop</artifactId>
</dependency>

2. 导入准备好的数据库表结构

并引入对应的实体类 数据表

-- 操作日志表
create table operate_log(
 id int unsigned primary key auto_increment comment 'ID',
 operate_user int unsigned comment '操作人',
 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 '操作日志表';

3.实体类

//操作日志实体类
@Data
@NoArgsConstructor
@AllArgsConstructor
public class OperateLog {
    private Integer id; //主键ID
    private Integer operateUser; //操作人ID
    private LocalDateTime operateTime; //操作时间
    private String className; //操作类名
    private String methodName; //操作方法名
    private String methodParams; //操作方法参数
    private String returnValue; //操作方法返回值
    private Long costTime; //操作耗时
}

4.Mapper接口

@Mapper
public interface OperateLogMapper {
    @Insert("insert into operate_log (operate_user, operate_time,class_name, method_name, method_params, return_value, cost_time)" +
            " values (#{operateUser}, #{operateTime}, #{className}, #{methodName}, #{methodParams}, #{returnValue}, #{costTime})")
    void insert(OperateLog operateLog);

5.自定义注解@Log

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

6.修改业务实现类

在增删改业务方法上添加@Log注解

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

package com.example.aop;

import com.alibaba.fastjson.JSONObject;
import com.example.mapper.OperateLogMapper;
import com.example.pojo.OperateLog;
import com.example.utils.JwtUtils;
import io.jsonwebtoken.Claims;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.servlet.http.HttpServletRequest;
import java.time.LocalDateTime;
import java.util.Arrays;

/**
 * @author hyk~
 */
@Slf4j // 为当前类引入日志功能，方便打印日志信息
@Component // 将当前类作为一个组件管理起来，Spring会自动扫描并管理它
@Aspect // 声明该类为一个切面类，用于定义横切关注点，即对方法执行前后进行拦截和处理
public class LogAspect {

    @Autowired
    private HttpServletRequest request; // 自动注入HttpServletRequest对象，用于获取请求信息

    @Autowired
    private OperateLogMapper operateLogMapper; // 自动注入OperateLogMapper对象，用于操作数据库记录操作日志

    @Around("@annotation(com.example.anno.Log)") // 环绕通知：拦截被@Log注解标记的方法，执行前后插入额外逻辑
    public Object recordLog(ProceedingJoinPoint joinPoint) throws Throwable {
        // 获取请求头中的JWT令牌并解析，提取操作人的ID
        String jwt = request.getHeader("token"); // 从请求头中获取JWT令牌
        Claims claims = JwtUtils.parseJWT(jwt); // 解析JWT令牌，获取其中的声明
        Integer operateUser = (Integer) claims.get("id"); // 从声明中提取操作人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 begin = System.currentTimeMillis();

        // 调用目标方法，执行被拦截的方法
        Object result = joinPoint.proceed();

        // 记录操作结束时间
        Long end = System.currentTimeMillis();

        // 获取操作方法的返回值，并转换为JSON字符串
        String returnValue = JSONObject.toJSONString(result);

        // 计算操作耗时
        Long costTime = end - begin;

        // 创建操作日志对象，包含操作人、操作时间、类名、方法名、参数、返回值和耗时等信息
        OperateLog operateLog = new OperateLog(
                null, // 日志的主键ID，通常由数据库自动生成
                operateUser, // 操作人ID
                operateTime, // 操作时间
                className, // 操作类名
                methodName, // 操作方法名
                methodParams, // 操作方法参数
                returnValue, // 操作方法返回值
                costTime // 操作耗时
        );

        // 将操作日志插入数据库，持久化存储
        operateLogMapper.insert(operateLog);

        // 打印操作日志，记录到日志文件中
        log.info("AOP操作日志：{}", operateLog);

        // 返回目标方法的执行结果
        return result;
    }
}

解释

• @Aspect：定义了一个切面，用于在方法执行的前后插入逻辑。
• @Around：使用环绕通知，拦截指定注解标记的方法，在其执行前后添加逻辑。
• 日志记录逻辑：每次有标记了@Log注解的方法被调用时，都会记录操作人的ID、操作的时间、类名、方法名、参数、返回值及耗时，并将这些信息存储到数据库中。