实现@RequestParam参数值校验

最新推荐文章于 2024-04-16 15:43:42 发布

Jeffrey_oWang

最新推荐文章于 2024-04-16 15:43:42 发布

阅读量3.7k

点赞数 2

分类专栏： JAVA 文章标签： springmvc RequestParam PathVariable aop

本文链接：https://blog.csdn.net/weixin_46248230/article/details/121620930

版权

JAVA 专栏收录该内容

36 篇文章 3 订阅

订阅专栏

需求描述：

在项目的实际的编写过程当中，通过JSR303针对于@RequestBody 可以进行参数的数据校验，但是如果是通过@RequestParam 或者是@PathVeriable 进行传值却没有什么很好的数据校验方式，通常只能通过：

if("".equals(message) || message == null){

throw new RuntimeException(“Bad Request”);

}

进行校验，所以想要编写一套注解实现对于@RequestParam 和@RequestPattern 的数据校验，实现的需求如下：

注解的value值为错误信息
注解的参数如果为null则抛出异常，如果为空也抛出异常，将异常交给异常处理器进行处理
可以指定异常的类型

结构：

@Param

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * @BelongsProject: springbootTest
 * @BelongsPackage: com.bazihou.springboottest.annotation
 * @Author: Wang Haipeng
 * @CreateTime: 2021-11-26 18:08
 * @Description: 校验参数
 * 配合FieldValid 一起使用，作用于方法的形式参数列表上，可以指定校验错误的数据信息
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.PARAMETER)
public @interface Param {

}

@FieldValid

import com.honglv.app.common.exception.SysException;

import java.lang.annotation.*;

/**
 * @BelongsProject: springbootTest
 * @BelongsPackage: com.bazihou.springboottest.annotation
 * @Author: Wang Haipeng
 * @CreateTime: 2021-11-28 15:17
 * @Description: 校验参数
 * 配合FieldParam一起使用，作用在方法上，可以指定验证错误的数据错误类型
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@Inherited
public @interface FieldValid {

}

CheckParamAspect

import com.honglv.app.common.annotation.FieldValid;
import com.honglv.app.common.annotation.Param;
import com.honglv.app.common.enums.ErrorCodeEnum;
import com.honglv.app.common.exception.SysException;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestParam;

import java.lang.annotation.Annotation;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;

/**
 * @BelongsProject: springbootTest
 * @BelongsPackage: com.bazihou.springboottest.aspect
 * @Author: Wang Haipeng
 * @CreateTime: 2021-11-26 18:09
 * @Description:
 *
 * 需求：
 * 1、被注解的方法可以验证所以@RequestParam 或者 @PathPatern 的参数不为null
 * 2、如果为null则抛出异常
 * 3、被注解的参数可以验证不为null ，如果为null可以抛出异常
 */
@Aspect
@Component
@Slf4j
public class CheckParamAspect {


    @Pointcut("@annotation(com.honglv.app.common.annotation.FieldValid)")
    public void pointCut() {
    }

    /**
     * @param joinPoint 切入点参数
     *                  校验逻辑：
     *                  获取参数对应的参数名，参数类型，和参数上的注解
     *                  如果参数上的注解同时有@Param 和@RequestParam 则校验数值
     *                  如果数据为引用数据类型，且值为null 则校验是否为String 类型，如果为是且为“”则抛出异常，否则校验成功
     *                  如果值为基本数据类型，因为基本数据类型本身如果没有传递则不会影响数据的传输，所以不进行校验
     */
    @Before("pointCut()")
    public void around(JoinPoint joinPoint) throws Throwable {
        Class<?> pubException = null;
        MethodSignature m = (MethodSignature) joinPoint.getSignature();
        Method method = m.getMethod();
        Class<?>[] parameterTypes = method.getParameterTypes();
        Object[] args = joinPoint.getArgs();
        Annotation[][] annotations = method.getParameterAnnotations();

        for (int i = 0; i < annotations.length; i++) {
            int flag = 0;
            for (int j = 0; j < annotations[i].length; j++) {
                if (annotations[i][j] instanceof RequestParam
                        || annotations[i][j] instanceof Param
                        || annotations[i][j] instanceof PathVariable) {
                    flag++;
                }
            }
            /*参数上同时具有@RequestBody 和@Param*/
            if (flag >= 2) {
                Class type = parameterTypes[i];
                /*参数不是基本数据类型*/
                if (!type.isPrimitive()) {
                    if (args[i] == null) {
                        log.info("@Param数据校验为空");
                        throw new SysException(ErrorCodeEnum.BADREQUEST);
                    } else {
                        if (type.equals(String.class) && "".equals(args[i])) {
                            log.info("@Param数据校验为空");
                            throw new SysException(ErrorCodeEnum.BADREQUEST);
                        }
                    }
                }
            }

        }
    }
}

测试及使用：

2）加强

反射获取注解的参数值

/*
	如果Method对象被FieldValid注解则返回true
*/
if (method.isAnnotationPresent(FieldValid.class)){
    		/*获取对应注解对象*/
            FieldValid fieldValid = method.getAnnotation(FieldValid.class);
            /*根据注解对象调用方法获取值*/
            pubException = fieldValid.value();
        }

创建指定Exception 类型的异常

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@Inherited
public @interface FieldValid {
    /**
     * @return 校验错误的数据错误类型
     */
    Class value() default SysException.class;
}

         Class<?> pubException = null;
		if (method.isAnnotationPresent(FieldValid.class)){
            FieldValid fieldValid = method.getAnnotation(FieldValid.class);
            /*指定的异常类对象的Class对象*/
            pubException = fieldValid.value();
        }
        /*判断自定义异常是不是pubException的父类（pubException是指定的异常类型）*/
        if (!SysException.class.isAssignableFrom(pubException)){
            exceptionFlag = false;
        }

/*如果pubException是自定义异常的父类*/
if (exceptionFlag){
    			/*反射获取构造方法创建对应的实例对象*/
            	Constructor<?> constructor = 			 pubException.getConstructor(ErrorCodeEnum.class);
                            constructor.setAccessible(true);
                            throw (Throwable) constructor.newInstance(ErrorCodeEnum.BADREQUEST);
                        }else {
    						/*不是则抛出自定义异常*/
                            throw new SysException(ErrorCodeEnum.BADREQUEST);
                        }

3）最终实现

package com.bazihou.springboottest.aspect;

import com.bazihou.springboottest.annotation.FieldValid;
import com.bazihou.springboottest.annotation.Param;
import com.bazihou.springboottest.enums.ErrorCodeEnum;
import com.bazihou.springboottest.exception.SysException;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.util.pattern.PathPattern;

import java.lang.annotation.Annotation;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

/**
 * @BelongsProject: springbootTest
 * @BelongsPackage: com.bazihou.springboottest.aspect
 * @Author: Wang Haipeng
 * @CreateTime: 2021-11-26 18:09
 * @Description:
 *
 * 需求：
 * 1、被注解的方法可以验证所以@RequestParam 或者 @PathPatern 的参数不为null
 * 2、如果为null则抛出异常
 * 3、被注解的参数可以验证不为null ，如果为null可以抛出异常
 */
@Aspect
@Component
@Slf4j
public class CheckParamAspect {


    @Pointcut("@annotation(com.bazihou.springboottest.annotation.FieldValid)")
    public void pointCut() {}


    @Before("pointCut()")
    public void before(JoinPoint joinPoint) throws Throwable {
        Class<?> pubException = null;
        boolean exceptionFlag = true;
        MethodSignature m = (MethodSignature) joinPoint.getSignature();
        Method method = m.getMethod();
        /*参数类型的Class对象数组*/
        Class<?>[] parameterTypes = method.getParameterTypes();
        /*参数数据值*/
        Object[] args = joinPoint.getArgs();
        Annotation[][] annotations = method.getParameterAnnotations();
        if (method.isAnnotationPresent(FieldValid.class)){
            FieldValid fieldValid = method.getAnnotation(FieldValid.class);
            /*指定的异常类对象的Class对象*/
            pubException = fieldValid.value();
        }
        /*判断SysException是不是pubException的父类*/
        if (!SysException.class.isAssignableFrom(pubException)){
            exceptionFlag = false;
        }

        for (int i = 0; i < annotations.length; i++) {
            int flag = 0;
            int index = -1;
            for (int j = 0; j < annotations[i].length; j++) {
                if (annotations[i][j] instanceof RequestParam
                        || annotations[i][j] instanceof PathVariable) {
                    flag++;
                }else if (annotations[i][j] instanceof Param){
                    flag++;
                    index = j;
                }
            }
            /*参数上同时具有@RequestBody 和@Param*/
            if (flag >= 2) {
                /*获取到Param注解的Annotation对象*/
                Param param = (Param) annotations[i][index];
                Class type = parameterTypes[i];
                /*参数不是基本数据类型*/
                if (!type.isPrimitive()) {
                    if (args[i] == null ||
                            (type.equals(String.class) && "".equals(args[i]))) {
                        log.info(param.value());
                        if (exceptionFlag){
                            Constructor<?> constructor = pubException.getConstructor(ErrorCodeEnum.class);
                            constructor.setAccessible(true);
                            throw (Throwable) constructor.newInstance(ErrorCodeEnum.BADREQUEST);
                        }else {

                            throw new SysException(ErrorCodeEnum.BADREQUEST);
                        }
                    }
                }
            }

        }
    }
}

Jeffrey_oWang

关注

2
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
实现@RequestParam参数值校验

需求描述：在项目的实际的编写过程当中，通过JSR303针对于@RequestBody 可以进行参数的数据校验，但是如果是通过@RequestParam 或者是@PathVeriable 进行传值却没有什么很好的数据校验方式，通常只能通过：if("".equals(message) || message == null){ throw new RuntimeException(“Bad Request”);}进行校验，所以想要编写一套注解实现对于@RequestParam 和@RequestPa
复制链接

扫一扫