@Valid注解进行参数验证，以及嵌套验证

v1.0.1

普通验证

普通验证另可查看本人另一篇验证文档

代码节选

// controller入口
saveOrUpdate(@RequestBody @Valid UserDataDO data)
	
	// dataName是请求参数data的属性之一
 	@NotBlank(message = "名称(dataName)不能为空")
    @ApiModelProperty(value = "数据集名称", required = true)
    private String dataName;

分析

一般来说，这种写法可以满足需求，但是如果请求参数包含【嵌套对象】就不行了，比如下述例子：

	// userDataColList是data的属性之一
	@NotEmpty(message = "数据内容(colList)不能为空")
    @ApiModelProperty(value = "数据内容", required = true)
    private List<UserDataColDO> userDataColList;

这样写，只能验证userDataColList是否为空，因为加了 @NotEmpty注解。

嵌套验证

在对象的字段上再加@Valid注解，写法：

	// userDataColList是data的属性之一
	@Valid
	@NotEmpty(message = "数据内容(colList)不能为空")
    @ApiModelProperty(value = "数据内容", required = true)
    private List<UserDataColDO> userDataColList;

list如何注解验证

1）输入参数那里，使用ValidList替代List作为传入数组，文末附上ValidList.java

... ...
saveOrUpdateBatch(@RequestBody @Valid ValidList<XxxDO> list)
... ...

2）List<Teacher>作为E对象的属性，在它前面加上List<@Valid Teacher>
ps：请严格按照示例代码配置

附录

ValidList.java

package com.jxmpc.web.controller.tool;

import javax.validation.Valid;
import java.util.*;

/**
 * 功能：嵌套验证List
 *
 * @author: cc
 * @qq: 8416837
 * @date: 2020/8/21 15:37
 */
public class ValidList<E> implements List<E> {

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

    @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);
    }

    public List<E> getList() {
        return list;
    }

    public void setList(List<E> list) {
        this.list = list;
    }

}

待续