使用@Validated校验List接口参数的两种方式

注: 不仅限于两种，此处只列举了两种

创建springboot项目, 并添加 spring-boot-starter-validation jar包

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

定义接口和参数

@RestController
@RequestMapping(value = "/test")
public class TestController {

    @PostMapping(value = "/create")
    public String test(@RequestBody List<User> users){
        return "success";
    }

    @lombok.Data
    public static class User{
        @NotNull(message = "用户id不能为空")
        private Integer userId;
        @NotBlank(message = "用户名字不能为空")
        private String username;
        @NotNull(message = "薪资不能为空")
        private Double salary;
    }
}

添加校验

1. 直接在参数列表中添加@Validated注解(无效)

   public String test(@RequestBody @Validated List<User> users)
   

   如上所示，如果我们直接在参数列表中添加校验注解，如果是User对象参数是能够校验到参数的，如果是List<User>参数校验就无效了，该注解只能校验JavaBean。

2. 使用@Validated和@Valid注解(有效)
   在Controller类上加上@Validated, 在需要校验的参数上加上 @Valid, 就可以校验list里的实体类的属性。

   @Validated
   @RestController
   @RequestMapping(value = "/test")
   public class TestController {
   
    @PostMapping(value = "/create")
    public String test(@RequestBody @Valid List<User> users){
        return "success";
    }
   }
   

@Validated和@Valid注解的区别:

在Controller中校验方法参数时，使用@Valid和@Validated并无特殊差异（若不需要分组校验的话）。
@Valid：标准JSR-303规范的标记型注解，用来标记验证属性和方法返回值，进行级联和递归校验。
@Validated：Spring的注解，是标准JSR-303的一个变种（补充），提供了一个分组功能，可以在入参验证时，根据不同的分组采用不同的验证机制。

方法级别：
@Validated注解可以用于类级别，用于支持Spring进行方法级别的参数校验。
@Valid可以用在属性级别约束，用来表示级联校验。
@Validated只能用在类、方法和参数上，而@Valid可用于方法、字段、构造器和参数上。

1. 自定义实现一个List ValidatedList, 加@Validated注解(有效)

@RestController
@RequestMapping(value = "/test")
public class TestController {

    @PostMapping(value = "/create")
    public String test(@RequestBody @Validated ValidatedList<User> users){
        return "success";
    }
}

@lombok.Data
public class ValidatedList<E> implements List<E> , Serializable {
    @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);
    }
}