AOP Maven依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-aop</artifactId>
</dependency>编写目标类与方法
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequestMapping("/user/api/v1/")
public class UserController {
@RequestMapping("/seckill")
public String seckill(){
return "OK";
}
}编写切面类，使得切面绑定目标类
import com.zanglikun.springdataredisdemo.aop.appendDescAop.annotation.AppendFieldDesc;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.lang.annotation.Annotation;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Parameter;
import java.util.HashMap;
@Aspect // 声明切面类
@Component // 注册为Spring组件，不然切面类不生效，这里我是先关闭了，你使用请务必开启
@Slf4j
public class AopAdvice {
/**
* Pointcut 定义切入点，一般为方法级别。通过切点表达式体现。
* A原表达式：execution(public * com.zanglikun.springdataredisdemo.controller..*.*(..))
* A表达式是切入 com.zanglikun.springdataredisdemo.controller 下面所有的Public方法
* <p>
* 一般还有匹配注解的如：@annotation(com.zanglikun.springdataredisdemo.aop.fileLimitAop.FileLimit)
* 就是切入被FileLimit的注解
*/
@Pointcut("execution(public * com.zanglikun.springdataredisdemo.controller..*.*(..))")
public void onePointCut() {
}
/**
* 环绕通知
* 理解点1：joinPoint.proceed()作用是：执行被拦截的方法。
* 为什么叫环绕通知呢？我们一般在joinPoint.proceed()。上下位置放置我们要执行的代码，可以实现在方法前、后执行代码
*
* @param joinPoint 切点 注意Around的joinPoint 与其他的不一样
* @return
* @throws Throwable
* @Around("onePointCut()") 这种定义切入点方式和直接在@Around里面声明具体得切入点表达式一样
* 环绕通知，更灵活得自定义增强通知，可以注入ProceedingJoinPoint获取相关信息和执行方法
*/
@Around("onePointCut()")
public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
Object object = null;
log.info("环绕通知开始：我在方法前面执行了");
object = joinPoint.proceed(); //调用被切入方法，并获取其返回值
log.info("环绕通知结束：我在方法执行后再执行");
return object;
}
/**
* 用于在切入点的流程执行前生效，可以在方法中注入JoinPoint用于获取相关信息
*
* @param joinPoint 切点对象
*/
@Before("onePointCut()")
public void before(JoinPoint joinPoint) {
log.info("我是前置通知：我在方法前被执行");
}
/**
* finally通知，这就意味着无论如何都会执行这个通知(不论是否发生异常)，可以在方法中注入JoinPoint用于获取相关信息
*
* @param joinPoint 切点对象
*/
@After("onePointCut()")
public void after(JoinPoint joinPoint) {
log.info("我是finally通知：无论如何（只要不停电、强杀进程）我都会执行");
}
/**
* 异常通知，出现异常时执行，可以在方法中注入JoinPoint和Throwable用于获取相关信息
*
* @param joinPoint 切点对象
* @param e 异常对象。由throwing指定变量名！
*/
@AfterThrowing(pointcut = "onePointCut()", throwing = "e")
public void throwing(JoinPoint joinPoint, Exception e) {
log.info("我是异常通知：仅在出现异常时触发，本地异常：{}", e.getMessage());
}
/**
* 后置返回前通知 ，在finally通知之后，方法正常退出前执行，可以注入JoinPoint 和Object 获取相关信息和方法执行成功的返回结果
* 注意：returning的内容必须要与变量保持一致
*
* @param joinPoint 切点对象
* @param object 目标方法返回的对象，一般有returning执行变量名赋值
*/
@AfterReturning(pointcut = "onePointCut()", returning = "object")
public void returning(JoinPoint joinPoint, Object object) {
getJoinPointInfo(joinPoint, object);
log.info("我是后置通知，响应结果为：" + object);
}
}测试
我看别人说不同版本的Spring版本输出结果不一样!
2023-06-07 00:42:08.075 INFO 88128 --- [nio-8089-exec-5] c.z.s.config.AopAdvice : 环绕通知开始：我在方法前面执行了
2023-06-07 00:42:08.075 INFO 88128 --- [nio-8089-exec-5] c.z.s.config.AopAdvice : 我是前置通知：我在方法前被执行
2023-06-07 00:42:08.075 INFO 88128 --- [nio-8089-exec-5] c.z.s.config.AopAdvice : 我是后置通知，响应结果为：OK
2023-06-07 00:42:08.075 INFO 88128 --- [nio-8089-exec-5] c.z.s.config.AopAdvice : 我是finally通知：无论如何（只要不停电、强杀进程）我都会执行
2023-06-07 00:42:08.075 INFO 88128 --- [nio-8089-exec-5] c.z.s.config.AopAdvice : 环绕通知结束：我在方法执行后再执行如果你要拓展JoinPoint属性，请参考如下代码：
这代码的意思是给一个接口返回后，处理其返回对象的字段，如果有@AppendFieldDesc就会触发替换字典值的非生产代码。当然有些RequestBody在此处意义不大，仅仅做更加健全的demo使用哈。
/**
* 后置返回前通知 ，在finally通知之后，方法正常退出前执行，可以注入JoinPoint 和Object 获取相关信息和方法执行成功的返回结果
* 注意：returning的内容必须要与变量保持一致
*
* @param joinPoint 切点对象
* @param object 目标方法返回的对象，一般有returning执行变量名赋值
*/
@AfterReturning(pointcut = "onePointCut()", returning = "object")
public void returning(JoinPoint joinPoint, Object object) {
getJoinPointInfo(joinPoint, object);
log.info("我是后置通知，响应结果为：" + object);
}
/**
* @param joinPoint
* @return
*/
public Object getJoinPointInfo(JoinPoint joinPoint, Object returnRes) {
// 这串代码的含义是获取HttpServletRequest、HttpServletResponse获取的是本线程的哦
{
ServletRequestAttributes requestAttributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
HttpServletRequest request = requestAttributes.getRequest();
HttpServletResponse response = requestAttributes.getResponse();
}
Object[] args = joinPoint.getArgs(); // 获取方法的所有入参值，但是无法准确获取入参类型，但是要去修改属性值，必须得获取对象
for (Object arg : args) {
System.out.println(arg);
}
// 获取AOP签名
MethodSignature signature = (MethodSignature) joinPoint.getSignature();
Method method = signature.getMethod(); // 获取被调用的方法
Class<?> returnType = method.getReturnType(); // 获取返回值的类型
Parameter[] parameters = method.getParameters(); // 获取方法的入参
for (Parameter parameter : parameters) {
parameter.getName(); // 获取参数名称例如：User user 获取的是user
Annotation[] classAnnotations = parameter.getAnnotations(); // 获取该入参的所有注解
Class<?> type = parameter.getType(); // 获取入参的字节码文件以便于快速获得变量的属性
if (parameter.isAnnotationPresent(RequestBody.class)) { // 如果该变量被RequestBody修饰了，才会执行
Field[] declaredFields = type.getDeclaredFields(); // 获取该变量的所有属性列表
for (Field declaredField : declaredFields) {
if (declaredField.isAnnotationPresent(AppendFieldDesc.class)) { // 如果变量被AppendFieldDesc修饰后，才执行
// 开始替换为字典值
try {
declaredField.setAccessible(true);
Object o = declaredField.get(returnRes);
if (o instanceof String) {
getDictionary(); // 初始化数据
HashMap<String, Object> stringObjectHashMap = returnMap.get(declaredField.getName());
declaredField.set(returnRes, stringObjectHashMap.get(o));
}
} catch (IllegalAccessException e) {
throw new RuntimeException(e);
} finally {
declaredField.setAccessible(false);
}
}
}
}
}
return returnRes;
}
HashMap<String, HashMap<String, Object>> returnMap = new HashMap<>();
// 自己主动去缓存Cache Code=Name oldValue NewValue
HashMap<String, HashMap<String, Object>> getDictionary() {
HashMap<String, Object> dbReturn = new HashMap<>();
dbReturn.put("1", "张三");
dbReturn.put("2", "李四");
returnMap.put("name", dbReturn);
return returnMap;
} 特殊说明： 上述文章均是作者实际操作后产出。烦请各位，请勿直接盗用！转载记得标注原文链接：www.zanglikun.com
第三方平台不会及时更新本文最新内容。如果发现本文资料不全，可访问本人的Java博客搜索：标题关键字。以获取全部资料 ❤
第三方平台不会及时更新本文最新内容。如果发现本文资料不全，可访问本人的Java博客搜索：标题关键字。以获取全部资料 ❤
