Spring AOP 权限检查 Spring AOP实现权限检查的功能

时间:2021-03-16 溪源的奇思妙想人气:0

想了解Spring AOP实现权限检查的功能的相关内容吗，溪源的奇思妙想在本文为您仔细讲解Spring AOP 权限检查的相关知识和一些Code实例，欢迎阅读和指正，我们先划重点：Spring,AOP,权限检查,Spring,AOP,权限，下面大家一起来学习吧。

前言

最近开发了一个接口，完成后准备自测时，却被拦截器拦截了，提示：(AUTH-NO)未能获得有效的请求参数！怎么会这样呢？

于是我全局搜了这个提示语，结果发现它被出现在一个Aspect类当中了，并且把一个 @interface 作为了一个切点，原来这里利用了Spring AOP面向切面的方式进行权限控制。

正文

Spring AOP 即面向切面，是对OOP面向对象的一种延伸。
AOP机制可以让开发者把业务流程中的通用功能抽取出来，单独编写功能代码。在业务流程执行过程中，Spring框架会根据业务流程要求，自动把独立编写的功能代码切入到流程的合适位置。

我们通过AOP机制可以实现：Authentication 权限检查、Caching 缓存、Context passing 内容传递、Error handling 错误处理等功能，这里我们讲一下怎么用Spring AOP来实现权限检查。

Spring AOP实现权限检查

引入依赖

<!--lombok-->
<dependency>
  <groupId>org.projectlombok</groupId>
  <artifactId>lombok</artifactId>
  <version>1.18.2</version>
  <optional>true</optional>
</dependency>

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

<dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-aspects</artifactId>
</dependency>

<dependency>
 <groupId>org.aspectj</groupId>
 <artifactId>aspectjweaver</artifactId>
 <version>1.9.2</version>
</dependency>

<dependency>
 <groupId>aopalliance</groupId>
 <artifactId>aopalliance</artifactId>
 <version>1.0</version>
</dependency>

MyPermissionTag.class自定义注解

@Retention: 用来修饰注解，是注解的注解，称为元注解。
@Target:用来说明对象的作用范围

/**
 * 用户请求权限校验
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface MyPermissionTag {
  String value() default "";
  String name() default "";
}

这里特别讲一下@Retention，按生命周期来划分可分为3类：

RetentionPolicy.SOURCE：注解只保留在源文件，当Java文件编译成class文件的时候，注解被遗弃（运行时去动态获取注解信息）；
RetentionPolicy.CLASS：注解被保留到class文件，但jvm加载class文件时候被遗弃，这是默认的生命周期（在编译时进行一些预处理操作）；
RetentionPolicy.RUNTIME：注解不仅被保存到class文件中，jvm加载class文件之后，仍然存在（做一些检查性的操作）；

这3个生命周期分别对应于：Java源文件(.java文件) —> .class文件 —> 内存中的字节码。

AuthInterceptor 权限检查的切面

这里简单介绍一下，切面的执行方法和其执行顺序：

@Around 通知方法将目标方法封装起来
@Before 通知方法会在目标方法调用之前执行
@After 通知方法会在目标方法返回或者异常后执行
@AfterReturning 通知方法会在目标方法返回时执行
@Afterthrowing 通知方法会在目标方法抛出异常时执行

这里以一个返回正常的情况为例：（异常替换最后一步即可）

AuthInterceptor.class

注意要在启动类扫描这个class，并且添加 @EnableAspectJAutoProxy(proxyTargetClass =
true)

@Slf4j
@Aspect
@Component
public class AuthInterceptor {


  /**
   * 参数处理
   *
   * @param point
   */
  @Before("@annotation(com.luo.common.tag.MyPermissionTag)")
  public void beforeProReq(JoinPoint point) {
    log.info("前置拦截-开始");
    Request req = getOperationRequest(point.getArgs());
    if (req != null) {
      //解密帐号
      log.info("前置拦截-开始解密ACCOUNT:{}", req.getAccount());


      log.info("前置拦截-结束解密ACCOUNT:{}", req.getAccount());
    }
    log.info("前置拦截-结束");
  }


  @Around("@annotation(com.luo.common.tag.MyPermissionTag)")
  public Object authCheck(ProceedingJoinPoint pjp) throws Throwable {
    log.info("权限拦截-开始");
    //请求方法
    ReqMethod reqMethod = getPermissionTag(pjp);


    MyPermissionTag myPermissionTag =reqMethod.perTag;
    log.info(myPermissionTag.value()); //获取配置的值
    log.info("权限拦截-开始-拦截到方法:{}", reqMethod.getMethodName());


    if("true".equals(myPermissionTag.value().toString())){
      //错误返回
      Response notGoRes = new Response();
      Request req = getOperationRequest(pjp.getArgs());
      // 校验请求对象
      if (req == null) {
        notGoRes.setErrorMsg("(AUTH)未能获得有效的请求参数！");
        log.info("(AUTH-NO)未能获得有效的请求参数！");
        return notGoRes;
      }else {//可以在这里根据请求参数对请求做进一步校验


        log.info("完成请求校验:"+req);




      }
    }else {
      log.info("未开启权限校验");
    }


    return pjp.proceed();
  }




  /**
   * 获取 request 接口中的请求参数
   * @param args
   * @return
   */
  private Request getOperationRequest(Object[] args) {
    if (args == null || args.length <= 0) {
      log.error("AUTH权限验证：拦截方法的请求参数为空！");
      return null;
    }
    Object obj = args[0];
    if (obj instanceof Request) {
      log.info("AUTH权限验证：请求对象为正确的OperationRequest对象");
      return (Request) obj;
    }
    return null;
  }




  /**
   * 获取拦截的资源标签
   * 这里可以获取方法名+注解信息(包括 key+value 等)
   * @param pjp
   * @return
   * @throws SecurityException
   * @throws NoSuchMethodException
   */
  private ReqMethod getPermissionTag(ProceedingJoinPoint pjp) throws NoSuchMethodException, SecurityException {
    Signature signature = pjp.getSignature();
    MethodSignature methodSignature = (MethodSignature) signature;
    Method targetMethod = methodSignature.getMethod();
    Method realMethod = pjp.getTarget().getClass().getDeclaredMethod(signature.getName(), targetMethod.getParameterTypes());
    MyPermissionTag permissionTag = realMethod.getAnnotation(MyPermissionTag.class);
    return new ReqMethod(permissionTag, realMethod.getName());
  }


  @Setter
  @Getter
  class ReqMethod {


    private MyPermissionTag perTag;
    private String methodName;


    public ReqMethod(MyPermissionTag perTag, String methodName) {
      this.perTag = perTag;
      this.methodName = methodName;
    }


  }
}

验证

测试接口

@PostMapping("/helloluo")
@MyPermissionTag(value = "true")
public String helloluo(UserPojoReq userPojoReq){
  return "Hello World";
}

发送请求

验证

加载全部内容