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>

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

@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";
}