一、AOP基础

1.AOP概述

• AOP: Aspect Oriented Programming (面向切面编程、面向方面编程)，其实就是面向特定方法编程。
• 实现原理：动态代理是面向切面编程最主流的实现。而SpringAOP是Spring框架的高级技术，旨在管理bean对象的过程中，主要通过底层的动态代理机制，对特定的方法进行编程。

2.AOP快速入门

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

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

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

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

package com.mannor.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;

@Slf4j
@Component  //交给IOC容器管理
@Aspect   //声明这是一个AOP类
public class TimeAspect {
    

    @Around("execution(* com.mannor.Service.*.*(..))")  //此语句表示需要记录Service下的所有类和接口中的所有方法和形参是任意的
    public Object recodeTime(ProceedingJoinPoint joinPoint) throws Throwable {
    
        //1.记录开始啥时间
        long begin = System.currentTimeMillis();
        //2.调用原始方法运行
        Object result = joinPoint.proceed();
        //3.记录结束时间，计算方法执行耗时
        long end = System.currentTimeMillis();
        log.info(joinPoint.getSignature() + "方法的耗时为：{}", end - begin);  //joinPoint.getSignature()方法记录了执行方法的签名(名字)
        return result;
    }
}

应用场景：记录操作日志，权限控制，事务管理等…
AOP的优势：代码无侵入，减少重复代码，提高开发效率，维护方便…

3.AOP核心概念

• 连接点:JoinPoint，可以被AOP控制的方法（暗含方法执行时的相关信息)
• 通知:Advice，指哪些重复的逻辑，也就是共性功能（最终体现为一个方法)
• 切入点:PointCut，匹配连接点的条件，通知仅会在切入点方法执行时被应用
• 切面:Aspect，描述通知与切入点的对应关系（通知+切入点)
• 目标对象:Target，通知所应用的对象

4.AOP的执行流程

• AOP程序的开发后，运行的就不是最初的目标对象，而是基于目标对象所生成的代理对象。

二、AOP进阶

1、通知类型

1. @Around:环绕通知，此注解标注的通知方法在目标方法前、后都被执行
2. @Before:前置通知，此注解标注的通知方法在目标方法前被执行
3. @After ∶后置通知，此注解标注的通知方法在目标方法后被执行，无论是否有异常都会执行
4. @AfterReturning : 返回后通知，此注解标注的通知方法在目标方法后被执行，有异常不会执行
5. @AfterThrowing :异常后通知，此注解标注的通知方法发生异常后执行
6. @PointCut该注解的作用是将公共的切点表达式抽取出来，需要用到时引用该切点表达式即可。（private仅在当前类中执行）

将以上注解添加到方法前面，然后在注解后面的括号上编写切入点表达式。

• 注意：
  • @Around环绕通知需要自己调用ProceedingJoinPoint.proceed()来让原始方法执行，其他通知不需要考虑目标方法执行
  • @Around环绕通知方法的返回值，必须指定为object，来接收原始方法的返回值。

当同时引用多个注解的相同切点表达式时，可以使用@Pointcut注解来定义一个方法声明，使用时调用即可（也可以在其他的AOP类上直接调用）：

package com.mannor.aop;

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

@Aspect
@Component
@Slf4j
public class MyAspect {
    
    @Pointcut("execution(* com.mannor.Service.impl.DeptServiceImpl.*(..))")
    private void pt() {
    
    }

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

2、通知顺序

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

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

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

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

法一就较繁琐，法二：

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

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

3、切入点表达式

1. 介绍

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

2. 作用

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

3. 常见形式:

1. execution(......):根据方法的签名来匹配
2. @annotation(......):根据注解匹配

4.execution

1.表达式

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

• 其中带?的表示可以省略的部分
  • 访问修饰符:可省略（比如: public、protected)
  • 包名.类名:可省略
  • throws异常:可省略（注意是方法上声明抛出的异常，不是实际抛出的异常)
• 示例：

@PointCut("execution (public void com.itheima.service.imp1.DeptServiceImpl.delete(java.lang.Integer))")

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

• *:单个独立的任意符号，可以通配任意返回值、包名、类名、方法名、任意类型的一个参数，也可以通配包、类、方法名的一部分

execution(* com.*.service.*.update*(*))

• ..:多个连续的任意符号，可以通配任意层级的包，或任意类型、任意个数的参数

execution(* com.itheima..Deptservice.*(..)) 

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

• 书写建议
  • 所有业务方法名在命名时尽量规范，方便切入点表达式快速匹配。如:查询类方法都是find开头，更新类方法都是update开头。
  • 描述切入点方法通常基于接口描述，而不是直接描述实现类，增强拓展性。
  • 在满足业务需要的前提下，尽量缩小切入点的匹配范围。如:包名匹配尽量不使用..,使用*匹配单个包。

5.@annotation

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

1. 编写一个注解annotation：

package com.mannor.aop;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)   //指定什么时候生效
@Target(ElementType.METHOD)    //作用的地方
public @interface MyLog {
    

}

2. 在需要执行的方法上添加注解@MyLog(上述定义)

@Service
public class DeptServiceImpl implements DeptService {
    

    @Autowired
    private DeptMapper deptMapper;

    @MyLog
    @Override
    public Dept getDeptId(Integer id) {
    
        Dept dept = deptMapper.getDeptId(id);
        return dept;
    }

	@MyLog
    @Override
    public void update(Dept dept) {
    
        dept.setUpdateTime(LocalDateTime.now());
        deptMapper.update(dept);
    }
}

3. 基于@anotation注解来描述切入点表达式,指定自定义注解的全类名

@Aspect
@Component
@Slf4j
public class MyAspect {
    

    @Pointcut("@annotation(com.mannor.aop.MyLog)")
    private void pt() {
    
    }

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

4、连接点

• 在Spring中用JoinPoint抽象了连接点，用它可以获得方法执行时的相关信息，如目标类名、方法名、方法参数等。
  • 对于@Around通知，获取连接点信息只能使用ProceedingJoinPoint
  • 对于其他四种通知，获取连接点信息只能使用JoinPoint ，它是 ProceedingJoinPoint 的父类型
• 示例代码：

package com.mannor.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.Before;
import org.aspectj.lang.annotation.Pointcut;

import java.util.Arrays;

@Aspect
@Component
@Slf4j
public class MyAspect1 {
    
    @Pointcut("execution(* com.mannor.Service.DeptService.*(..))")
    private void pt() {
    
    }

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

    @Around("pt()")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
    
        log.info("Aspect around before......");
        //1．获取目标对象的类名﹒
        String className = joinPoint.getTarget().getClass().getName();
        log.info("获取目标对象的类名{}",className);
        
        //2．获取目标方法的方法名﹒
        String methodName = joinPoint.getSignature().getName();
        log.info("获取目标方法名：{}",methodName);

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

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

        //5．获取 目标方法运行的返回值
		log.info("目标方法运行时的返回值：{}",result);
        log.info("Aspect around after......");
        return result;
    }
}

三、AOP案例

• 将增、删、改相关接口的操作日志记录到数据库表中。
• 日志信息包含:操作人、操作时间、执行方法的全类名、执行方法名、方法运行时参数、返回值、方法执行时长

1.准备工作

1. 建立好数据表和实体类—略
2. 自定义注解

package com.mannor.anno;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

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

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

package com.mannor.aop;

import com.alibaba.fastjson.JSONObject;
import com.fasterxml.jackson.annotation.JsonTypeInfo;
import com.mannor.Mapper.OperateLogMapper;
import com.mannor.pojo.OperateLog;
import com.mannor.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.net.http.HttpClient;
import java.time.LocalDateTime;
import java.util.Arrays;

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

    @Autowired
    private HttpServletRequest request;

    @Autowired
    private OperateLogMapper operateLogMapper;

    @Around("@annotation(com.mannor.anno.Log)")
    public Object recordLog(ProceedingJoinPoint joinPoint) throws Throwable {
    

        //编写对OperateLog对象的各个属性赋值
        String jwt = request.getHeader("token");
        Claims claims = JwtUtils.parseJWT(jwt);
        Integer operateUser = (Integer) claims.get("id");  //获取id
        LocalDateTime operateTime = LocalDateTime.now();  //获取当前时间
        String className = joinPoint.getTarget().getClass().getName();
        String methodName = joinPoint.getTarget().getClass().getName();  //获取当前方法名
        Object[] args = joinPoint.getArgs();  //获取参数
        String methodParams = Arrays.toString(args);
        long begin = System.currentTimeMillis();   //原始方法开始时的时间
        //调用原始方法执行
        Object result = joinPoint.proceed();
        long end = System.currentTimeMillis();  //原始方法执行后的时间

        String returnValue = JSONObject.toJSONString(result);  //方法返回值
        Long costTime = end - begin;

        //记录操作日志
        OperateLog operateLog = new OperateLog(null, operateUser, operateTime, className, methodName, methodParams, returnValue, costTime);  //赋值给实体类
        operateLogMapper.insert(operateLog);
        log.info("记录操作的日志：{}",operateLog);
        return result;
    }
}

4. 在相应的Mapper操作上添加@Log注解，来表示需要记录日志到数据库的操作(如此案例中的增删改操作)