自定义注解，根据注解拦截接口判断请求是否放行

一时失言乱红尘 2022-03-02 04:46 260阅读 0赞

@Documented
    @Inherited
    @Target({ ElementType.FIELD, ElementType.METHOD })
    @Retention(RetentionPolicy.RUNTIME)
    public @interface AclValide {
        String url() default "";
    }
    
    
    @Aspect
    @Component
    public class AclValideAspect {
        private static Logger logger = LoggerFactory.getLogger(AclValideAspect.class);
        //配置切入点 只对配置AclValide注解的接口进行切入
        @Pointcut("@annotation(com.hanshow.wise.base.privileges.annotation.AclValide)")
        public void controllerAspect() {
            logger.info("ACL注解权限拦截切入点加载");
        }
    
        //在执行方法前获取AclValide配置的url地址,与redis缓存中的权限集合比对,判断用户是否拥有此权限访问该接口
        @Before("controllerAspect()")
        public void doBefore(JoinPoint joinPoint) {
            logger.info("=====AclValideAspect前置通知开始=====");
            //    访问目标方法参数,有三种方法(实际有四种)
            //    1.joinpoint.getargs():获取带参方法的参数
            //    2.joinpoint.getTarget():.获取他们的目标对象信息
            //    3..joinpoint.getSignature():(signature是信号,标识的意思):获取被增强的方法相关信息
            Object[] args = joinPoint.getArgs();
            if (args == null) {
                //controller请求地址没有参数直接放行
                logger.info("请求接口没有参数,不进行权限校验");
                return;
            }
            //获取请求头参数
            BaseQUERY baseQUERY = null;
            for (int i = 0; i < args.length; i++) {
                Object obj = args[i];
                //请求参数中其中一个是JSONObject
                if (obj instanceof JSONObject) {
                    baseQUERY = JSON.parseObject(JSON.toJSONString(obj), BaseQUERY.class);
                    if (baseQUERY == null || StringUtil.isEmptyTrim(baseQUERY.getMerchantId()) || StringUtil.isEmptyTrim(baseQUERY.getUserId())) {
                        logger.info("请求头数据不全,merchantId={},userId={},request={},不进行权限校验", baseQUERY.getMerchantId(), baseQUERY.getUserId(), JSON.toJSONString(baseQUERY));
                        return;
                    }
                    break;
                } else if (obj instanceof BaseQUERY) {
                    //请求参数中其中一个是BaseQUERY
                    baseQUERY = (BaseQUERY) obj;
                    if (StringUtil.isEmptyTrim(baseQUERY.getMerchantId()) || StringUtil.isEmptyTrim(baseQUERY.getUserId())) {
                        logger.info("请求头数据不全,merchantId={},userId={},request={},不进行权限校验", baseQUERY.getMerchantId(), baseQUERY.getUserId(), JSON.toJSONString(baseQUERY));
                        return;
                    }
                    break;
                }
            }
            //请求接口有参数,但是参数类型没有JSONObject,BaseQUERY两种的任何一种
            if (baseQUERY == null) {
                logger.info("请求接口有参数,但是参数类型没有JSONObject,BaseQUERY两种的任何一种,不进行权限校验");
                return;
            }
            //获取注解方法参数值
            Signature signature = joinPoint.getSignature();
            MethodSignature methodSignature = (MethodSignature) signature;
            Method method = methodSignature.getMethod();
            AclValide aclValideAnnotation = method.getAnnotation(AclValide.class);
            //权限在缓存中的key值
            String resourcePathkey = AspectConstant.PRIVILEGES_PICK_CENTER_SIMPLE + baseQUERY.getMerchantId() + "" + baseQUERY.getUserId();
            Long listLength = RedisUtil.getListLength(resourcePathkey);
            if (listLength == null) {
                logger.info("从缓存获取权限集合长度失败,resourcePathkey={},不进行权限校验", resourcePathkey);
                return;
            }
            List<String> list = RedisUtil.getList(resourcePathkey, 0, listLength);
            if (list == null) {
                logger.info("从缓存获取权限集合失败,resourcePathkey={},不进行权限校验", resourcePathkey);
            } else {
                if (list.contains(aclValideAnnotation.url())) {
                    //符合权限放行
                } else {
                    throw new WiseException(JSON.toJSONString(BaseDTO.genErrBaseDTO(baseQUERY, BaseError.E10_PERMISSION_DENIED)));
                }
            }
        }
    
    }

@AclValide(url = "/resource/getTree")
    @RequestMapping(value = "/resource/getTree", method = RequestMethod.POST)
    @ResponseBody
    public Object getTree(HttpServletRequest request, @RequestBody JSONObject jsonObject) {
    }

@Component
    public class CustomExceptionResolver implements HandlerExceptionResolver {
        private static Logger logger = LoggerFactory.getLogger(CustomExceptionResolver.class);
        @Override
        public ModelAndView resolveException(HttpServletRequest request, HttpServletResponse response, Object handler, Exception exception) {
            ModelAndView modelAndView = new ModelAndView();
            response.setStatus(HttpStatus.OK.value()); //设置状态码
            response.setContentType(MediaType.APPLICATION_JSON_VALUE); //设置ContentType
            response.setCharacterEncoding("UTF-8"); //避免乱码
            response.setHeader("Cache-Control", "no-cache, must-revalidate");
            try {
                if (exception instanceof WiseException) {
                    WiseException wiseException = (WiseException) exception;
                    response.getWriter().write(wiseException.getMessage());
                    logger.error("全局异常处理类捕捉到异常:" + wiseException.getMessage());
                } else {
                    BaseDTO<Map<String, Object>> objectBaseDTO = BaseDTO.genErrBaseDTO(BaseError.E11_INNER_DATA_ERROR);
                    Map<String, Object> returnMap = new HashMap<>();
    //                returnMap.put("errMsg", exception.getMessage());
    //                returnMap.put("exception", exception);
    //                objectBaseDTO.setData(returnMap);
                    if(objectBaseDTO.getRequestId()==null){
                        objectBaseDTO.setRequestId(UUIDUtils.genUUID());
                    }
                    response.getWriter().write(JSONObject.fromObject(objectBaseDTO).toString());
                    logger.error("全局异常处理类捕捉到异常:", exception);
                }
            } catch (Exception e) {
                logger.error("全局异常处理失败", e);
            }
            return modelAndView;
        }
    }