@RequestBody接收Json参数 | 用自定义注解对Vo对象中Date类型日期格式校验

最新推荐文章于 2023-05-13 11:26:01 发布

手hold刺猬

最新推荐文章于 2023-05-13 11:26:01 发布

阅读量2.7k

点赞数 4

分类专栏： 003.疑难问题文章标签： java springmvc json 正则表达式 spring boot

本文链接：https://blog.csdn.net/u012708719/article/details/116698147

版权

003.疑难问题专栏收录该内容

2 篇文章 0 订阅

订阅专栏

标题太长有木有？主要是为了把问题描述清楚，免得进错文章。

问题描述

昨天测试的同事测试接口的时候，测试出来一个Date类型校验问题。

要求输入的日期格式是：yyyy-MM-dd HH:mm:ss，Vo中使用的注解如下：

@DateTimeFormat(pattern=”yyyy-MM-dd HH:mm:ss”)

测试同事输入下面两种参数都是保存成功，当输入为“202105”参数时，保存的数据变为“1970-01-01 08:03:22”，由此发现这个问题。

常用的三种日期格式化的注解解释如下：

//入参格式化注解
@DateTimeFormat(pattern=”yyyy-MM-dd HH:mm:ss”)

//出餐格式化注解
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
@JSONField(format = "yyyy-MM-dd HH:mm:ss") //建议这种

由于@RequestBody注解先将json字符串转换成对应的Vo对象，Vo对象中的字段上添加的注解再生效，@DateTimeFormat只是做格式化，无法做格式校验。

解决方案

用自定义注解进行json字符串中的日期格式做校验。

解决思路：

1.从request对象中获取原始json字符串入参。由于自定义注解接口ConstraintValidator的实现获取到的参数值是@RequestBody注解将json字符串参数解析成Vo对象后的Date对象，不是原始json字符串值，所以需要从request中获取json原始参数值；

2.获取到json入参原始值使用正则表达式对日期进行格式进行校验。

温馨提示：

1.由于自定义注解中是无法直接获取到request对象，所以需要按照各自框架获取request对象的方式进行获取。

2.获取到的原始json字符串入参可能包含空格、回车、换行符、制表符这些特殊字符，所以需要进行特殊字符处理。

3.获取Vo对象中添加注解的属性名。

详细见：getFieldName(ConstraintValidatorContext context)即：【((ConstraintValidatorContextImpl) context).basePath.currentLeafNode.name】

代码实现

SearchTaskVo.java

/**
 * 任务结束时间
 **/
@ApiModelProperty("任务结束时间")
@JSONField(format = "yyyy-MM-dd HH:mm:ss")
@DateFormatValidation(format = "yyyy-MM-dd HH:mm:ss", message = "与要求的日期格式[yyyy-MM-dd HH:mm:ss]不符")
private Date afcx5206;

DateFormatValidation.java

import javax.validation.Constraint;
import javax.validation.Payload;
import java.lang.annotation.*;

/**
 * 说明：日期格式校验
 *
 * @Author Wanghx
 * @Date 2021/5/11 10:16
 * @Version 1.0
 **/
@Target({ElementType.FIELD, ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Constraint(validatedBy = {DateFormatValidator.class})
public @interface DateFormatValidation {

    //验证失败错误提示信息，使用注解时没有设置错误信息则默认使用信息
    String message() default "格式错误";

    //验证格式的规则，使用注解时没有设置验证格式规则则默认使用下面的格式
    String format() default "yyyy-MM-dd";

    //分组验证
    Class<?>[] groups() default {};

    Class<? extends Payload>[] payload() default {};

}

DateFormatValidator.java

import org.hibernate.validator.internal.engine.constraintvalidation.ConstraintValidatorContextImpl;
import org.hibernate.validator.internal.engine.constraintvalidation.ConstraintViolationCreationContext;
import org.hibernate.validator.internal.engine.path.NodeImpl;
import org.hibernate.validator.internal.engine.path.PathImpl;

import javax.servlet.http.HttpServletRequest;
import javax.validation.ConstraintValidator;
import javax.validation.ConstraintValidatorContext;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * 说明：日期格式校验
 *
 * @Author Wanghx
 * @Date 2021/4/30 10:17
 * @Version 1.0
 **/
public class DateFormatValidator extends BaseRestService implements ConstraintValidator<DateFormatValidation, Date> {
    private DateFormatValidation dateFormatValidation;

    @Override
    public void initialize(DateFormatValidation constraintAnnotation) {
        this.dateFormatValidation = constraintAnnotation;
    }


    @Override
    public boolean isValid(Date value, ConstraintValidatorContext context) {
        //如果 value 为空则不进行格式验证，为空验证可以使用 @NotBlank @NotNull @NotEmpty 等注解来进行控制，职责分离
        if (value == null) {
            return true;
        }
        //获取规定的格式
        String format = dateFormatValidation.format();

        //验证日期的格式是否正确
        try {
            //获取原始json参数值
            String originalValue = getOriginalValueByFieldName(getFieldName(context));
            //用长度进行比较
            if (ValidateUtil.isNotEmpty(originalValue) && originalValue.length() != format.length()) {
                return false;
            }
            //校验字符串日期格式
            if (!verifyFormatDateStr(originalValue, format)) {
                return false;
            }

            //用日期格式化验证
            SimpleDateFormat simpleDateFormat = new SimpleDateFormat(format);
            simpleDateFormat.format(value);
        } catch (Exception e) {
            return false;
        }
        return true;
    }


    /**
     * 校验字符串日期格式
     *
     * @param dateStr
     * @param format
     * @return
     */
    private boolean verifyFormatDateStr(String dateStr, String format) {
        boolean resultFlag = false;
        //允许的日期格式
        List<String> formatList = Arrays.asList(DatePattern.PATTEN_DATETIME, DatePattern.PATTEN_DATETIME_SERIAL, DatePattern.PATTEN_DATE, DatePattern.PATTEN_DATE_yyyyMMdd);
        Map<String, String> allDateFormat = getAllDateFormat();
        if (ValidateUtil.isNotEmpty(dateStr) && ValidateUtil.isNotEmpty(format) && formatList.contains(format)) {
            String regex = allDateFormat.get(format);//根据format拼接的正则表达式
            resultFlag = Pattern.compile(regex).matcher(dateStr).matches();
        }
        return resultFlag;
    }

    /**
     * 获取日期格式的正则表达式，根据具体业务需要可新增
     *
     * @return
     */
    private Map<String, String> getAllDateFormat() {
        String yyyy = "((1|2)[0-9]{3})";
        String MM = "(0[1-9]|1[012])";
        String dd = "(0[1-9]|[12][0-9]|3[01])";
        String HH = "((0|1)[0-9]|2[0-3])";
        String mm = "([0-5][0-9])";
        String ss = "([0-5][0-9])";

        Map<String, String> resultMap = new HashMap<String, String>();
        resultMap.put(DatePattern.PATTEN_DATETIME, yyyy + "-" + MM + "-" + dd + " " + HH + ":" + mm + ":" + ss);
        resultMap.put(DatePattern.PATTEN_DATETIME_SERIAL, yyyy + MM + dd + HH + mm + ss);
        resultMap.put(DatePattern.PATTEN_DATE, yyyy + "-" + MM + "-" + dd);
        resultMap.put(DatePattern.PATTEN_DATE_yyyyMMdd, yyyy + MM + dd);
        return resultMap;
    }

    /**
     * 获取添加注解的字段名称
     *
     * @param context
     * @return
     */
    private String getFieldName(ConstraintValidatorContext context) {
        String fieldName = "";
        if (context != null) {
            List<ConstraintViolationCreationContext> constraintViolationCreationContexts = ((ConstraintValidatorContextImpl) context).getConstraintViolationCreationContexts();
            if (ValidateUtil.isNotEmpty(constraintViolationCreationContexts)) {
                ConstraintViolationCreationContext constraintViolationCreationContext = constraintViolationCreationContexts.get(0);
                PathImpl path = constraintViolationCreationContext.getPath();
                if (path != null) {
                    NodeImpl node = path.makeLeafNodeIterable();
                    if (node != null) {
                        fieldName = node.getName();
                    }
                }
            }
        }

        return fieldName;
    }


    /**
     * 根据字段名称获取json原始值
     *
     * @param fieldName
     * @return
     */
    private String getOriginalValueByFieldName(String fieldName) throws Exception {
        String resultStr = "";//结果值
        if (!StringUtil.isBlank(fieldName)) {
            //获取request对象，【注：根据各自项目获取request对象即可】
            HttpServletRequest request = getRequest();
            //获取json参数原始值，并封装到Map集合中
            Map<String, Object> reqPostParamsMap = new HashMap<String, Object>();
            if (request != null) {
                //未清洗的json原始值
                String reqPostStr = getRequestPostStr(request);
                //清洗json原始值
                if (!StringUtil.isBlank(reqPostStr)) {
                    reqPostStr = reqPostStr.substring(reqPostStr.indexOf("{"), reqPostStr.indexOf("}"));
                    //去除字符串中的空格、回车、换行符、制表符这些特殊字符
                    Pattern p = Pattern.compile("\\s*|\t|\r|\n");
                    Matcher m = p.matcher(reqPostStr);
                    reqPostStr = m.replaceAll("");
                    //去除前后{}和"
                    reqPostStr = reqPostStr.substring(2, reqPostStr.length() - 1);
                    //将json字符串参数解析后封装成Map
                    String[] reqPostParamList = reqPostStr.split("\",\"");
                    for (String reqPostParam : reqPostParamList) {
                        String[] keyAndValue = reqPostParam.split("\":\"");
                        if (keyAndValue.length >= 2) {
                            reqPostParamsMap.put(keyAndValue[0], keyAndValue[1]);
                        }
                    }
                }
            }
            //根据字段名称获取对应的原始值
            Object o = reqPostParamsMap.get(fieldName);
            if (o != null) {
                resultStr = o.toString();
            }
        }
        return resultStr;
    }


    /**
     * 获取 post 请求的 byte[] 数组
     *
     * @param request
     * @return
     * @throws IOException
     */
    private static byte[] getRequestPostBytes(HttpServletRequest request)
            throws IOException {
        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;
        }
        return buffer;
    }

    /**
     * 获取 post 请求内容
     *
     * @param request
     * @return
     * @throws IOException
     */
    private static String getRequestPostStr(HttpServletRequest request)
            throws IOException {
        byte buffer[] = getRequestPostBytes(request);
        String charEncoding = request.getCharacterEncoding();
        if (charEncoding == null) {
            charEncoding = "UTF-8";
        }
        return new String(buffer, charEncoding);
    }


}

测试验证结果

至此问题解决~

文章中有何隐藏问题欢迎留言交流~

有好的解决方案欢迎留言~

手hold刺猬

关注

4
点赞
踩
5

收藏

觉得还不错? 一键收藏
0
评论
@RequestBody接收Json参数 | 用自定义注解对Vo对象中Date类型日期格式校验

标题太长有木有？主要是为了把问题描述清楚，免得进错文章。问题描述昨天测试的同事测试接口的时候，测试出来一个Date类型校验问题。要求输入的日期格式是：yyyy-MM-dd HH:mm:ss，Vo中使用的注解如下：@DateTimeFormat(pattern=”yyyy-MM-dd HH:mm:ss”)测试同事输入下面两种参数都是保存成功，当输入为“202105”参数时，保存的数据变为“1970-01-01 08:03:22”，由此发现这个问题。常用的三种日期格式化的注解解
复制链接

扫一扫