【JAVA基础】AOP详解

卑微的小红猪

于 2024-08-05 15:01:49 发布

阅读量1.5k

点赞数 8

文章标签： java 开发语言

本文链接：https://blog.csdn.net/qq_54065582/article/details/140927358

版权

1.AOP定义

AOP（Aspect OrientedProgramming）：面向切面编程，面向切面编程（也叫面向方面编程），是目前软件开发中的一个热点，也是Spring框架中的一个重要内容。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

OK什么都看不懂，举个例子：

假如我现在有100个接口，都需要获取用户信息来进行处理，我们会在每一个接口当中都重写一遍获取用户信息的代码吗，当然不会！比较容易想到的方法就是写一个工具类，然后在每一个接口当中调用，这是一个不错的方法，AOP其实是对这一方法的改进，有一点像过滤器，是的，其实过滤器就是使用AOP实现的。

在一般的项目开发当中，经常会使用AOP来做日志管理，性能统计，安全控制等等比较公共的需求。

2.基本概念

（1）通知（Advice）：通知是切面中具体的横切逻辑，它定义了在切点何时执行什么操作。AOP定义了几种通知类型，包括前置通知（Before Advice）、后置通知（After Advice）、环绕通知（Around Advice）、异常通知（After-Throwing Advice）和最终通知（After-Finally Advice）等

（2）切点（Pointcut）：切点是用于定义在何处应用通知的表达式。切点表达式指定了哪些连接点（Joinpoint）将被通知所影响。连接点是程序执行过程中可以应用切面的点，例如方法调用、方法执行、对象实例化等。

（3）切面（Aspect）：在AOP中，切面是横切关注点的抽象，它包含了一组通知（Advice）和切点（Pointcut）。通知定义了在何时、何地执行横切逻辑，而切点定义了何处应用这些通知。

简单来看，我们可以将切面看作是切点+通知。

3.使用方式

（1）导入依赖

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

（2）编译AOP的应用接口

@RestController
public class AopController {

    @RequestMapping("/hello")
    public String sayHello(){
        System.out.println("hello");
        return "hello";
    }
  }

（3）编写切面

定义切面容器的注解：@Aspect

定义切点容器的注解：@Pointcut（该注解允许传入一个参数，是一个execution表达式）

execution表达式相关规范：

    /**
     * execution:表达式主体
     * 第一部分  代表方法返回值类型 *表示任何类型
     * 第二部分  com.example.demo.controller 表示要监控的包名
     * 第三部分 .. 代表当前包名以及子包下的所有方法和类
     * 第四部分 * 代表类名，*代表所有的类
     * 第五部分 *(..) *代表类中的所有方法(..)代表方法里的任何参数
     */

定义通知的注解：

通知有五种类型，分别是：

前置通知（@Before）：在目标方法调用之前调用通知
后置通知（@After）：在目标方法完成之后调用通知
环绕通知（@Around）：在被通知的方法调用之前和调用之后执行自定义的方法
返回通知（@AfterReturning）：在目标方法成功执行之后调用通知
异常通知（@AfterThrowing）：在目标方法抛出异常之后调用通知

@Aspect
@Component
public class TestAopAnnoAspect {

    @Pointcut("execution(* com.example.demo.controller..*(..))")
    public void PointCut(){
    }
    
    @Before("execution(* com.example.demo.controller..*(..))")
    public void Before() {
        System.out.println("请求之前");
    }

    @Around("execution(* com.example.demo.controller..*(..))")
    public Object Around(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("环绕");
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        Method method = signature.getMethod();
        AnnotationTest annotationTest = method.getAnnotation(AnnotationTest.class);
        String type = annotationTest.type();
        System.out.println("type 为：" + type);
        return joinPoint.proceed();
    }

    @After("execution(* com.example.demo.controller..*(..))")
    public void After() {
        System.out.println("在请求之后");
    }

    @AfterReturning("execution(* com.example.demo.controller..*(..))")
    public void AfterReturning() {
        System.out.println("在返回之后");
    }
}

（4）补充

这里补充一下获取通知的方式：

（（（1）））JoinPoint接口

    // @Before注解：声明当前方法是前置通知方法
    // value属性：指定切入点表达式，由切入点表达式控制当前通知方法要作用在哪一个目标方法上
    // 在前置通知方法形参位置声明一个JoinPoint类型的参数，Spring就会将这个对象传入
    // 根据JoinPoint对象就可以获取目标方法名称、实际参数列表
    @Before(value = "pointCut()")
    public void add(JoinPoint joinPoint) {
        // 1.通过JoinPoint对象获取目标方法签名对象
        // 方法的签名：一个方法的全部声明信息
        Signature signature = joinPoint.getSignature();
 
        // 2.通过方法的签名对象获取目标方法的详细信息
        // 获取方法名
        String name = signature.getName();
 
        int modifiers = signature.getModifiers();
        // System.out.println(modifiers);
        String declaringTypeName = signature.getDeclaringTypeName();
        // System.out.println(declaringTypeName);
        Class declaringType = signature.getDeclaringType();
        // System.out.println(declaringType);
 
        // 3.通过JoinPoint对象获取外界调用目标方法时传入的实参列表
        Object[] args = joinPoint.getArgs();
 
        System.out.println("[LogAspect --> 前置通知] 方法" + name + "执行了,参数为：" + Arrays.toString(args));
    }

（（（2）））方法返回值：在返回通知中，通过@AfterReturning注解的returning属性获取目标方法的返回值

    // @AfterReturning注解标记返回通知方法
    // 在返回通知中获取目标方法返回值分两步：
    // 第一步：在@AfterReturning注解中通过returning属性设置一个名称
    // 第二步：使用returning属性设置的名称在通知方法中声明一个对应的形参
    @AfterReturning(value = "pointCut()", returning = "result")
    public void printLogAfterSuccess(JoinPoint joinPoint, Object result) {
        String name = joinPoint.getSignature().getName();
        System.out.println("[LogAspect --> 返回通知] 方法" + name + "成功返回了,返回值为:" + result);
    }

（（（3）））目标方法抛出的异常：在异常通知中，通过@AfterThrowing注解的throwing属性获取目标方法抛出的异常对象

// @AfterThrowing注解标记异常通知方法
// 在异常通知中获取目标方法抛出的异常分两步：
// 第一步：在@AfterThrowing注解中声明一个throwing属性设定形参名称
// 第二步：使用throwing属性指定的名称在通知方法声明形参，Spring会将目标方法抛出的异常对象从这里传给我们
@AfterThrowing(value = "pointCut()", throwing = "exception")
public void printLogAfterException(JoinPoint joinPoint, Exception exception) {
    String name = joinPoint.getSignature().getName();
    System.out.println("[LogAspect --> 异常通知] 方法" + name + "抛异常了,异常为：" + exception);
}

4.案例应用

这里使用注解开发的案例实现一个日志记录的AOP功能的开发。

（1）定义日志实体类

import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import java.io.Serializable;
import java.time.LocalDateTime;

@Data
@TableName("api_log")
public class LogInfo implements Serializable {
    private static final long serialVersionUID = 1L;

    @TableId(value = "ID") 
    private String id;

    @TableField(value = "REQUEST_PATH") 
    private String requestPath;

    @TableField(value = "REQUEST_METHOD") 
    private String requestMethod;

    @TableField(value = "REQUEST_IP") 
    private String requestIP;

    @TableField(value = "REQUEST_PARAMS") 
    private String requestParams; // 改用Map类型以提高灵活性和安全性

    @TableField(value = "SQL_CONTENT")
    private String sqlContent;

    @TableField(value = "RESPONSE") 
    private String response; // 序列化前将对象转为字符串表示

    @TableField(value = "EXCEPTION_MESSAGE") 
    private String exceptionMessage;

    @TableField(value = "REQUEST_STATUS") 
    private String requestStatus; 

    @TableField(value = "START_TIME") 
    private LocalDateTime startTime;

    @TableField(value = "END_TIME") 
    private LocalDateTime endTime;

    @TableField(value = "PROCESSING_TIME") 
    private long processingTime;

}

（2）定义切面

import com.alibaba.fastjson.JSON;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import java.time.LocalDateTime;
import java.util.Arrays;
import java.util.UUID;

/**
 * 添加aop日志打印
 * @author yhw
 */
@Slf4j
@Aspect
@Component
@Order(1) // 设置切面优先级
public class LogAspect {

    private static final ThreadLocal<LogInfo> threadLocalLogInfo = ThreadLocal.withInitial(LogInfo::new);
    @Resource
    private LogInfoDao logInfoDao;
    private Long startTime;
    private Long endTime;

    public LogAspect() {
    }

    /**
     * 定义请求日志切入点，其切入点表达式有多种匹配方式,这里是指定路径
     */
    @Pointcut("execution(public * com.indexManagement.controller.modelController.queryServiceDetailByParam(..))")
    public void webLogPointcut() {
    }


    /**
     * 前置通知
     *
     * @param joinPoint
     * @throws Throwable
     */
    @Before("webLogPointcut()")
    public void doBefore(JoinPoint joinPoint) {
        try {
            LogInfo logInfo = threadLocalLogInfo.get();
            logInfo.setId(UUID.randomUUID().toString().replaceAll("-", ""));
            ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
            HttpServletRequest request = attributes.getRequest();
            startTime = System.currentTimeMillis();
            log.info("请求开始时间：{}", LocalDateTime.now());
            log.info("请求路径：{}", request.getRequestURI());
            log.info("请求方法：{}", request.getMethod());
            log.info("请求IP：{}", request.getRemoteAddr());
            log.info("请求参数：{}", Arrays.toString(joinPoint.getArgs()));
            logInfo.setStartTime(LocalDateTime.now());
            logInfo.setRequestPath(request.getRequestURI());
            logInfo.setRequestMethod(request.getMethod());
            logInfo.setRequestIP(request.getRemoteAddr());
            logInfo.setRequestParams(JSON.toJSONString(joinPoint.getArgs()));
        } catch (Exception e) {
            log.error("日志记录前置处理异常：", e);
        }
    }

    /**
     * 返回通知
     *
     * @param ret
     * @throws Throwable
     */
    @AfterReturning(returning = "ret", pointcut = "webLogPointcut()")
    public void doAfterReturning(Object ret) throws Throwable {
        try {
            LogInfo logInfo = threadLocalLogInfo.get();
            String sql = SqlHolder.getSql();
            log.info("执行SQL：{}", sql);
            endTime = System.currentTimeMillis();
            log.info("请求结束时间：{}", LocalDateTime.now());
            log.info("处理耗时：{}ms", (endTime - startTime));
            logInfo.setSqlContent(sql);
            logInfo.setEndTime(LocalDateTime.now());
            logInfo.setProcessingTime(System.currentTimeMillis() - startTime);
            logInfo.setResponse(JSON.toJSONString(ret));
            logInfo.setRequestStatus("成功");
            logInfoDao.insert(logInfo);
        } catch (Exception e) {
            log.error("日志记录返回处理异常：", e);
        } finally {
            SqlHolder.removeSql(); // 确保清除ThreadLocal中的SQL
            threadLocalLogInfo.remove(); // 清理ThreadLocal中的LogInfo
        }
    }

    /**
     * 异常通知
     *
     * @param ex
     */
    @AfterThrowing(value = "webLogPointcut()", throwing = "ex")
    public void doAfterThrowing(Exception ex) {
        try {
            LogInfo logInfo = threadLocalLogInfo.get();
            String sql = SqlHolder.getSql();
            log.error("抛出异常：{}", ex.getMessage()); // 记录更多异常信息，考虑实际场景可能需要记录堆栈信息
            endTime = System.currentTimeMillis();
            log.info("请求结束时间：{}", LocalDateTime.now());
            log.info("处理耗时：{}ms", (endTime - startTime));
            logInfo.setSqlContent(sql);
            logInfo.setExceptionMessage(ex.getMessage());
            logInfo.setEndTime(LocalDateTime.now());
            logInfo.setProcessingTime(System.currentTimeMillis() - startTime);
            logInfo.setRequestStatus("失败");
            logInfoDao.insert(logInfo);
        } catch (Exception e) {
            log.error("日志记录异常处理异常：", e);
        } finally {
            SqlHolder.removeSql(); // 确保清除ThreadLocal中的SQL
            threadLocalLogInfo.remove(); // 清理ThreadLocal中的LogInfo
        }
    }
}