spring中使用AOP拦截方法

使用Aspect需要引入aop依赖

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

aop流程执行

aop流程图

1.使用@Annotation

需要创建一个注解，用在需要拦截的方法上或者类上

 package com.gyh.annotation;

 import java.lang.annotation.*;
 
 @Documented
 @Retention(RetentionPolicy.RUNTIME)
 @Target(ElementType.METHOD)
 public @interface AspectAnnotation {
 
 }

2.创建拦截处理器

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

@Component
@Aspect
public class HandleAspect {

    private static final Logger logger = LoggerFactory.getLogger(HandleAspect .class); 

    /**
   *  这里是使用注解的方式定位需要拦截的方法
   * 也可以通过切点表达式直接指定需要拦截的package,需要拦截的class 以及 method
   * 切点表达式:   execution(...) 如果以注解可以使用 && 链接
   * @Pointcut("execution(* *.getReceiptInfo(..))")
   */
    @Pointcut("@annotation(com.gyh.annotation.AspectAnnotation)")
    public void pointCut(){}

    /**
      * 也可使用注解参数
      * @Around(value = "@annotation(aspect)")
      * public Object around(JoinPoint joinPoint, AspectAnnotation aspect) {
      */
    @Around("pointCut()")
    public Object handle(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        Object result = proceedingJoinPoint.proceed();
        String business = proceedingJoinPoint.getSignature().getName();

         logger.info("=============================>" + business );          

        // 获取参数
        Object[] args = proceedingJoinPoint.getArgs();

        // 业务处理逻辑 .......................

        return result;
    }

    /**
     *  前置通知
     *  没有返回值
     */
    @Before(value = "pointCut()")
    public void before(JoinPoint joinPoint){
        logger.info("前置通知执行");
        / / 前置处理逻辑 ...
    }

    /**
     *  后置通知
     *  没有返回值
     */
    @After("pointCut()")
    public void afterMethod(JoinPoint joinPoint){
        log.info("后置通知执行");
        // 后置处理逻辑...
    }

    /**
     * 返回 通知
     * rsult为返回内容
      */
    @AfterReturning(value="pointCut()",returning="result")
    public void afterReturningMethod(JoinPoint joinPoint,Object result){
        log.info("返回通知");
        // 返回处理逻辑...
    }

    /**
     * 异常通知
     * e异常内容
      */
    @AfterThrowing(value="Pointcut()",throwing="e")
    public void afterReturningMethod(JoinPoint joinPoint, Exception e){
        log.info("异常通知");
        // 异常 处理逻辑
    }

}

@Before 在切点方法之前执行
@After 在切点方法之后执行
@AfterReturning 切点方法返回后执行
@AfterThrowing 切点方法抛异常执行
@Around 属于环绕增强，能控制切点执行前，执行后，，用这个注解后，程序抛异常，会影响@AfterThrowing这个注解

3.需要拦截的方法（这里我们使用的是拦截controller）

@RestController
public class MessageController {
    
    @AspectAnnotation()
    @GetMapping("get")
    public R get(String param){
      return R.ok();
    }
}

最后编辑于：2022.03.31 08:22:03