使用反射实现@RequestBody的参数校验功能

springboot中对实体类参数中属性进行校验一般都是使用javax.validation中提供的注解

我这次这个项目需要所有接口参数加密，我这里参数解密是使用自定义参数解析器实现HandlerMethodArgumentResolver接口来实现的，通过获取请求体中的加密字符串然后解密后封装到接口参数中。所以就不用@RequestBody注解了，并且那些参数校验的属性也不会起作用。

如果要是在接口里面写if校验就有点。。不优雅，然后就想到在参数解析的时候自己根据这些注解进行校验

package com.gt.gxjhpt.configuration;

import cn.hutool.core.convert.Convert;
import cn.hutool.core.util.ArrayUtil;
import cn.hutool.core.util.CharsetUtil;
import cn.hutool.core.util.ReUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.crypto.symmetric.AES;
import cn.hutool.json.JSONArray;
import cn.hutool.json.JSONObject;
import cn.hutool.json.JSONUtil;
import com.gt.gxjhpt.annotation.ParamsAES;
import com.gt.gxjhpt.entity.dto.BaseReq;
import com.gt.gxjhpt.utils.AESUtil;
import lombok.extern.log4j.Log4j2;
import org.jetbrains.annotations.Nullable;
import org.springframework.core.MethodParameter;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.support.WebDataBinderFactory;
import org.springframework.web.context.request.NativeWebRequest;
import org.springframework.web.method.support.HandlerMethodArgumentResolver;
import org.springframework.web.method.support.ModelAndViewContainer;

import javax.servlet.http.HttpServletRequest;
import javax.validation.ConstraintViolationException;
import javax.validation.constraints.*;
import java.io.IOException;
import java.lang.annotation.Annotation;
import java.lang.reflect.Field;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.Collection;
import java.util.stream.Collectors;

/**
 * 解析加密注解
 *
 * @author vhukze
 * @date 2021/9/8 11:14
 */
@Log4j2
public class AESDecodeResolver implements HandlerMethodArgumentResolver {

    /*
        json参数的key
     */
    private static final String NAME = "str";

    /**
     * 如果接口或者接口参数有解密注解，就解析
     */
    @Override
    public boolean supportsParameter(MethodParameter parameter) {
        return parameter.hasMethodAnnotation(ParamsAES.class) || parameter.hasParameterAnnotation(ParamsAES.class);
    }

    @Override
    public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer modelAndViewContainer,
                                  NativeWebRequest webRequest, WebDataBinderFactory webDataBinderFactory) throws IOException, InstantiationException, IllegalAccessException {

        AES aes = AESUtil.aes;

        // 获取post请求的json字符串
        String postStr = getPostStr(webRequest);

        // 接口参数的字节码对象
        Class<?> parameterType = parameter.getParameterType();
        //如果是实体类参数，把请求参数封装
        if (BaseReq.class.isAssignableFrom(parameterType)) {

            //获取加密的请求数据并解密
//            String beforeParam = webRequest.getParameter(NAME);
            String afterParam = aes.decryptStr(JSONUtil.parseObj(postStr).get(NAME).toString(),
                    CharsetUtil.CHARSET_UTF_8);

            // 校验参数
            if (parameter.hasParameterAnnotation(Validated.class)) {
                Validated validated = parameter.getParameterAnnotation(Validated.class);
                this.verifyObjField(afterParam, parameterType, validated.value());
            }

            //json转对象  // 这里的return就会把转化过的参数赋给控制器的方法参数
            return JSONUtil.toBean(afterParam, parameterType);

            // 如果是非集合类，就直接解码返回
        } else if (!Iterable.class.isAssignableFrom(parameterType)) {
//            String decryptStr = aes.decryptStr(webRequest.getParameter(parameter.getParameterName()), CharsetUtil.CHARSET_UTF_8);
//            return Integer.class.isAssignableFrom(parameter.getParameterType()) ? Integer.parseInt(decryptStr) : decryptStr;

            Object value = JSONUtil.parseObj(aes.decryptStr(JSONUtil.parseObj(postStr).get(NAME).toString(),
                    CharsetUtil.CHARSET_UTF_8)).get(parameter.getParameterName());

            this.verifyOneField(parameter, value);

            return value;
            //如果是集合类
        } else if (Iterable.class.isAssignableFrom(parameterType)) {
            //获取加密的请求数据并解密
//            String beforeParam = webRequest.getParameter(NAME);
            String afterParam = aes.decryptStr(JSONUtil.parseObj(postStr).get(NAME).toString(),
                    CharsetUtil.CHARSET_UTF_8);

            //转成对象数组
            JSONArray jsonArray = JSONUtil.parseArray(afterParam);

            this.verifyCollField(parameter, jsonArray);

            return jsonArray.toList(Object.class);
        }

        return null;

    }

    /**
     * 校验单个参数
     */
    private void verifyOneField(MethodParameter parameter, Object value) {
        for (Annotation annotation : parameter.getParameterAnnotations()) {
            if (annotation instanceof NotBlank) {
                if (value == null || StrUtil.isBlank(value.toString())) {
                    log.info("参数为空");
                    throw new ConstraintViolationException(null);
                }
            }
            if (annotation instanceof NotNull) {
                if (value == null) {
                    log.info("参数为空");
                    throw new ConstraintViolationException(null);
                }
            }
            // 只能是字符串类型
            if (annotation instanceof Size) {
                Size size = (Size) annotation;
                if (value != null && (value.toString().length() < size.min() || value.toString().length() > size.max())) {
                    log.info("参数长度不对");
                    throw new ConstraintViolationException(null);
                }
            }
        }
    }

    /**
     * 校验集合类型
     */
    private void verifyCollField(MethodParameter parameter, JSONArray jsonArray) {

        for (Annotation annotation : parameter.getParameterAnnotations()) {
            if (annotation instanceof NotEmpty) {
                if (jsonArray == null || jsonArray.size() == 0) {
                    log.info("集合参数值为空");
                    throw new ConstraintViolationException(null);
                }
            }
            if (annotation instanceof Size) {
                Size size = (Size) annotation;
                if (jsonArray.size() < size.min() || jsonArray.size() > size.max()) {
                    log.info("集合参数值大小不对");
                    throw new ConstraintViolationException(null);
                }
            }
        }
    }

    /**
     * 校验实体类参数
     *
     * @param param  前端传的参数（json字符串）
     * @param clazz  接口实体类参数的字节码对象
     * @param groups 校验那些组
     */
    private void verifyObjField(String param, Class<?> clazz, Class<?>[] groups) {

        // 前端传的参数
        JSONObject jsonObj = JSONUtil.parseObj(param);

        // 实体类所有字段
        Field[] fields = clazz.getDeclaredFields();

        for (Field field : fields) {
            // 字段如果不可访问，设置可访问
            if (!field.isAccessible()) {
                field.setAccessible(true);
            }

            Annotation[] annotations = field.getDeclaredAnnotations();

            for (Annotation annotation : annotations) {

                if (annotation instanceof NotNull) {
                    NotNull notNull = (NotNull) annotation;
                    if ((ArrayUtil.isEmpty(groups) && ArrayUtil.isEmpty(notNull.groups()))
                            || ArrayUtil.containsAny(groups, notNull.groups())) {
                        if (jsonObj.get(field.getName()) == null) {
                            log.info("字段>>>>>>" + field.getName() + "值有问题");
                            throw new ConstraintViolationException(null);
                        }
                    }
                }

                if (annotation instanceof NotBlank) {
                    NotBlank notBlank = (NotBlank) annotation;
                    if ((ArrayUtil.isEmpty(groups) && ArrayUtil.isEmpty(notBlank.groups()))
                            || ArrayUtil.containsAny(groups, notBlank.groups())) {
                        Object val = jsonObj.get(field.getName());
                        if (val == null || StrUtil.isBlank(val.toString())) {
                            log.info("字段>>>>>>" + field.getName() + "值有问题");
                            throw new ConstraintViolationException(null);
                        }
                    }
                }

               
                if (annotation instanceof Size) {
                    Size size = (Size) annotation;
                    if ((ArrayUtil.isEmpty(groups) && ArrayUtil.isEmpty(size.groups()))
                            || ArrayUtil.containsAny(groups, size.groups())) {
                        Object val = jsonObj.get(field.getName());
                        if (val instanceof String) {
                            if (val.toString().length() < size.min() || val.toString().length() > size.max()) {
                                log.info("字段>>>>>>" + field.getName() + "值有问题");
                                throw new ConstraintViolationException(null);
                            }
                        }
                        if (val instanceof Collection && Convert.toList(val).size() == 0) {
                            log.info("字段>>>>>>" + field.getName() + "值有问题");
                            throw new ConstraintViolationException(null);
                        }
                    }
                }

                if (annotation instanceof Pattern) {
                    Pattern pattern = (Pattern) annotation;
                    if ((ArrayUtil.isEmpty(groups) && ArrayUtil.isEmpty(pattern.groups()))
                            || ArrayUtil.containsAny(groups, pattern.groups())) {
                        Object val = jsonObj.get(field.getName());
                        if (val != null && !ReUtil.isMatch(pattern.regexp(), val.toString())) {
                            log.info("字段>>>>>>" + field.getName() + "值正则校验失败");
                            throw new ConstraintViolationException(null);
                        }
                    }
                }

                if (annotation instanceof Max) {
                    Max max = (Max) annotation;
                    if ((ArrayUtil.isEmpty(groups) && ArrayUtil.isEmpty(max.groups()))
                            || ArrayUtil.containsAny(groups, max.groups())) {
                        Object val = jsonObj.get(field.getName());
                        if (val != null && Convert.toInt(val) > max.value()) {
                            log.info("字段>>>>>>" + field.getName() + "值太大");
                            throw new ConstraintViolationException(null);
                        }
                    }
                }

            }


        }

    }

    @Nullable
    private String getPostStr(NativeWebRequest webRequest) throws IOException {
        //获取post请求的json数据
        HttpServletRequest request = (HttpServletRequest) webRequest.getNativeRequest();
        int contentLength = request.getContentLength();
        if (contentLength < 0) {
            return null;
        }
        byte[] buffer = new byte[contentLength];
        for (int i = 0; i < contentLength; ) {

            int readlen = request.getInputStream().read(buffer, i,
                    contentLength - i);
            if (readlen == -1) {
                break;
            }
            i += readlen;
        }
        String str = new String(buffer, CharsetUtil.CHARSET_UTF_8);
        StringBuilder sb = new StringBuilder();
        for (char c : str.toCharArray()) {
            //去掉json中的空格 换行符 制表符
            if (c != 32 && c != 13 && c != 10) {
                sb.append(c);
            }
        }
        return sb.toString();
    }

}

校验注解就写了几个常用的，需要其他的还可以自己加。不需要分组校验的可以把判断分组的删掉