记@Validated注解

@Validated注解是为了给请求接口时，判断对象的值是否是你需要的属性做判断。

在编程中我使用的主要用的有：

        1、@NotNull     （不能为null）

        2、@NotEmpty （不为空也不能为null，其主要限制String类型）

        3、@NotBlank  （不能为空，去除一开始的空格后长度不能为0）

在网上还看到一些常用注释，现记录下来：

感觉比较实用的：

        1、@Size(max,min)         （限制字符长度必须在min到max之前)

        2、@Past                         （限制必须是过去的日期）

        3、@PastOrPresent         （限制必须是过去的日期或者是当前时间）

        4、@Future                      （限制必须是以后的日期）

        5、@FutureOrPresent      （限制必须是以后的日期或者是当前时间）

        6、@Max(value)               （限制必须为不大于value的值）

        7、@Min(value)                （限制必须为不小于value的值）

        8、@Pattern(value)          （限制必须符合指定的正则表达式）

        9、@Email                       （限制必须为email格式）

不常用的：

        1、@Null                            （限制只能为空）

        2、@AssertFalse               （限制必须是false）

        3、@AssertTrue.                （限制必须为true）

        4、@DecimalMax(value)    （限制必须为不大于value的值）

        5、@DecimalMin(value)     （限制必须为不小于value的值）

        6、@Digits(Integer,fraction)（限制必须为一个小数，且整数部分位数不超过Intger，小数不超过fraction）

        7、@Negative                     （限制必须为负整数）

        8、@NegativeOrZero         （限制必须为负整数或零）

        8、@Positive                      （限制必须为正整数）

        9、@PositiveOrZero           （限制必须为正整数或零）

---

现在来讲一下如何使用：

1、导入依赖（有两种）

第一种：（我使用的是第一种）

<dependency>
    <groupId>javax.validation</groupId>
    <artifactId>validation-api</artifactId>
    <version>2.0.1.Final</version>
</dependency>
<dependency>
    <groupId>org.hibernate.validator</groupId>
    <artifactId>hibernate-validator</artifactId>
</dependency>

第二种：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-validation</artifactId>
 </dependency>

2、创建对象、接口；

创建对象

@Data
public class XxxAddParam{
    
    @NotNull(message = "用户id不能为空")
    private Integer id; 

    @NotEmpty(message = "用户姓名不能为空")
    private String name;
}

创建接口

@Slf4j
@RestController
@RequestMapping("/xxx")
public class XxxController {

    @PostMapping("/addXxx")
    public Result addXxx(@RequestBody @Validated XxxAddParam XxxAddParam){
        return Result.success();
    }

}

---

在一开始可能会遇到如下问题：

         1、@Validated注解的默认异常过长；

org.springframework.web.bind.MethodArgumentNotValidException: Validation failed for argument [0] in public com.xwdBoy.common.helper.Result com.xwdBoy.web.controller.XxxController.addXxx(com.xwdBoy.param.XxxAddParam): [Field error in object 'XxxAddParam' on field 'name': rejected value []; codes [NotEmpty.XxxAddParam.name,NotEmpty.name,NotEmpty.java.lang.String,NotEmpty]; arguments [org.springframework.context.support.DefaultMessageSourceResolvable: codes [XxxAddParam.name,name]; arguments []; default message [name]]; default message [用户姓名不能为空]]

         2、无法对List<xx>对象进行验证；

第一个问题是需要加上全局异常处理就可以通过：

/**
 * HTTP接口统一的错误处
 * @author sj
 */
@ControllerAdvice
@Slf4j
@Priority(1)
public class GlobalExceptionHandler {

    @ExceptionHandler(MethodArgumentNotValidException.class)
    @ResponseBody
    public Result handleMethodArgumentNotValidException(MethodArgumentNotValidException ex) {
        BindingResult bindingResult = ex.getBindingResult();
        List<FieldError> errors = bindingResult.getFieldErrors();
        //初始化错误信息大小
        Result result = new Result();
        for (FieldError error : errors) {
            result.setMsg(error.getDefaultMessage());
            result.setCode(ResultEnum.ERROR.getCode());
            return result;
        }
        return Result.error(ResultEnum.ERROR.getCode(), ResultEnum.ERROR.getMsg());
    }
    @ExceptionHandler(BizException.class)
    @ResponseStatus(HttpStatus.OK)
    @ResponseBody
    public Result handleBizExceptions(BizException e) {
        log.error(e.getMessage(), e);
        return Result.error(e.getCode(), e.getMessage());
    }

    @ResponseBody
    @ExceptionHandler(HttpRequestMethodNotSupportedException.class)
    public Result httpRequestMethodNotSupportedExceptionException(HttpRequestMethodNotSupportedException e) {
        String message = Optional.ofNullable(e.getMessage()).orElse(ResultEnum.HTTP_REQUEST_METHOD_NOT_SUPPORTED.getMsg());
        log.warn("HttpRequestMethodNotSupportedException:", e);
        return Result.error(ResultEnum.HTTP_REQUEST_METHOD_NOT_SUPPORTED.getCode(), message);
    }

    @ResponseBody
    @ExceptionHandler(MultipartException.class)
    public Result fileUploadExceptionHandler(MultipartException e) {
        log.warn("上传文件异常:{}", e.getMessage());
        return Result.error(ResultEnum.ERROR.getCode(), "文件过大，单个不超200M");
    }
}

第二个问题对list进行操作（在入参的时候使用ValidList<xx>）：

@Data
public class ValidList<E> implements List<E> {

    @Valid
    private List<E> list = new LinkedList<>();

    @Override
    public int size() {
        return list.size();
    }

    @Override
    public boolean isEmpty() {
        return list.isEmpty();
    }

    @Override
    public boolean contains(Object o) {
        return list.contains(o);
    }

    @Override
    public Iterator<E> iterator() {
        return list.iterator();
    }

    @Override
    public Object[] toArray() {
        return list.toArray();
    }

    @Override
    public <T> T[] toArray(T[] a) {
        return list.toArray(a);
    }

    @Override
    public boolean add(E e) {
        return list.add(e);
    }

    @Override
    public boolean remove(Object o) {
        return list.remove(o);
    }

    @Override
    public boolean containsAll(Collection<?> c) {
        return list.containsAll(c);
    }

    @Override
    public boolean addAll(Collection<? extends E> c) {
        return list.addAll(c);
    }

    @Override
    public boolean addAll(int index, Collection<? extends E> c) {
        return list.addAll(index, c);
    }

    @Override
    public boolean removeAll(Collection<?> c) {
        return list.removeAll(c);
    }

    @Override
    public boolean retainAll(Collection<?> c) {
        return list.retainAll(c);
    }

    @Override
    public void clear() {
        list.clear();
    }

    @Override
    public E get(int index) {
        return list.get(index);
    }

    @Override
    public E set(int index, E element) {
        return list.set(index, element);
    }

    @Override
    public void add(int index, E element) {
        list.add(index, element);
    }

    @Override
    public E remove(int index) {
        return list.remove(index);
    }

    @Override
    public int indexOf(Object o) {
        return list.indexOf(o);
    }

    @Override
    public int lastIndexOf(Object o) {
        return list.lastIndexOf(o);
    }

    @Override
    public ListIterator<E> listIterator() {
        return list.listIterator();
    }

    @Override
    public ListIterator<E> listIterator(int index) {
        return list.listIterator(index);
    }

    @Override
    public List<E> subList(int fromIndex, int toIndex) {
        return list.subList(fromIndex, toIndex);
    }
}