@Validated和@Valid的区别？校验级联属性（内部类）

每篇一句

nba里有两大笑话：一是科比没天赋，二是詹姆斯没技术

相关阅读

【小家java】深入了解数据校验：java bean validation 2.0（jsr303、jsr349、jsr380）hibernate-validation 6.x使用案例
【小家spring】让controller支持对平铺参数执行数据校验（默认spring mvc使用@valid只能对javabean进行校验）
【小家spring】spring方法级别数据校验：@validated + methodvalidationpostprocessor优雅的完成数据校验动作

---

对spring感兴趣可扫码加入wx群：`java高工、架构师3群`（文末有二维码）

---

前言

介绍了spring环境下实现优雅的方法级别的数据校验，并且埋下一个伏笔：它在spring mvc（controller层）里怎么应用呢？本文为此继续展开讲解spring mvc中的数据校验~

可能小伙伴能立马想到：这不一样吗？我们使用controller就是方法级别的，所以它就是直接应用了方法级别的校验而已嘛~对于此疑问我先不解答，而是顺势再抛出两个问题你自己应该就能想明白了：

1. 上文有说过，基于方法级别的校验spring默认是并未开启的，但是为什么你在spring mvc却可以直接使用@valid完成校验呢？
   1. 可能有的小伙伴说他用的是springboot可能默认给开启了，其实不然。哪怕你用的传统spring mvc你会发现也是直接可用的，不信你就试试
2. 类比一下：spring mvc的handlerinterceptor是aop思想的实现，但你有没有发现即使你没有启动@enableaspectjautoproxy的支持，它依旧好使~

若你能想明白我提出的这两个问题，下文就非常不难理解了。当然即使你知道了这两个问题的答案，还是建议你读下去。毕竟：永远相信本文能给你带来意想不到的收获~

使用示例

关于数据校验这一块在spring mvc中的使用案例，我相信但凡有点经验的java程序员应该没有不会使用的，并且还不乏熟练的选手。在此之前我简单“采访”过，绝大多数程序员甚至一度认为spring中的数据校验就是指的在controller中使用@validated校验入参javabean这一块~

因此下面这个例子，你应该一点都不陌生：

@getter
@setter
@tostring
public class person {

    @notnull
    private string name;
    @notnull
    @positive
    private integer age;

    @valid // 让innerchild的属性也参与校验
    @notnull
    private innerchild child;

    @getter
    @setter
    @tostring
    public static class innerchild {
        @notnull
        private string name;
        @notnull
        @positive
        private integer age;
    }

}

@restcontroller
@requestmapping
public class hellocontroller {

    @postmapping("/hello")
    public object hellopost(@valid @requestbody person person, bindingresult result) {
        system.out.println(result.geterrorcount());
        system.out.println(result.getallerrors());
        return person;
    }
}

发送post请求：/hello content-type=application/json，传入的json串如下：

{
  "name" : "fsx",
  "age" : "-1",
  "child" : {
    "age" : 1
  }
}

控制台有如下打印：

2
[field error in object 'person' on field 'child.name': rejected value [null]; codes [notnull.person.child.name,notnull.child.name,notnull.name,notnull.java.lang.string,notnull]; arguments [org.springframework.context.support.defaultmessagesourceresolvable: codes [person.child.name,child.name]; arguments []; default message [child.name]]; default message [不能为null], field error in object 'person' on field 'age': rejected value [-1]; codes [positive.person.age,positive.age,positive.java.lang.integer,positive]; arguments [org.springframework.context.support.defaultmessagesourceresolvable: codes [person.age,age]; arguments []; default message [age]]; default message [必须是正数]]

从打印上看：校验生效（拿着错误消息就可以返回前端展示，或者定位到错误页面都行）。

此例两个小细节务必注意：

1. @requestbody注解不能省略，否则传入的json无法完成数据绑定（即使不绑定，校验也是生效的哦）~
2. 若方法入参不写bindingresult result这个参数，请求得到的直接是400错误，因为若有校验失败的服务端会抛出异常org.springframework.web.bind.methodargumentnotvalidexception。若写了，那就调用者自己处理喽~

据我不完全和不成熟的统计，就这个案例就覆盖了小伙伴们实际使用中的90%以上的真实使用场景，使用起来确实非常的简单、优雅、高效~

但是作为一个有丰富经验的程序员的你，虽然你使用了@valid优雅的完成了数据校验，但回头是你是否还会发现你的代码里还是存在了大量的if else的基础的校验？什么原因？其实根本原因只有一个：很多case使用@valid并不能覆盖，因为它只能校验javabean
我相信你是有这样那样的使用痛点的，本文先从原理层面分析，进而给出你所遇到的痛点问题的参考解决参考方案~

原理分析

controller提供的使用@valid便捷校验javabean的原理，和spring方法级别的校验支持的原理是有很大差异的（可类比spring mvc拦截器和spring aop的差异区别~），那么现在就看看这块吧

请不要忽视优雅代码的力量，它会成倍提升你的编码效率、成倍降低后期维护成本，甚至成倍提升你的扩展性和成倍降低你写bug的可能性~

回忆databinder/webdatabinder

若对spring数据绑定模块不是很熟悉的（有阅读过我之前文章的可忽略），建议先补：

1. 【小家spring】聊聊spring中的数据绑定 --- databinder本尊（源码分析）
2. 【小家spring】聊聊spring中的数据绑定 --- webdatabinder、servletrequestdatabinder、webbindinginitializer...

databinder类名叫数据绑定，但它在org.springframework.validation这个包，可见spring它把数据绑定和数据校验牢牢的放在了一起，并且内部弱化了数据校验的概念以及逻辑（spring想让调用者无需关心数据校验的细节，全由它来自动完成，减少使用的成本）。

我们知道databinder它主要对外提供了bind(propertyvalues pvs)和validate()方法，当然还有处理绑定/校验失败的相关（配置）组件：

public class databinder implements propertyeditorregistry, typeconverter {
    ...
    @nullable
    private abstractpropertybindingresult bindingresult; // 它是个bindingresult
    @nullable
    private messagecodesresolver messagecodesresolver;
    private bindingerrorprocessor bindingerrorprocessor = new defaultbindingerrorprocessor();
    // 最重要是它：它是org.springframework.validation.validator
    // 一个databinder 可以持有对个验证器。也就是说对于一个bean，是可以交给多个验证器去验证的（当然一般都只有一个即可而已~~~）
    private final list<validator> validators = new arraylist<>();
    
    public void bind(propertyvalues pvs) {
        mutablepropertyvalues mpvs = (pvs instanceof mutablepropertyvalues ? (mutablepropertyvalues) pvs : new mutablepropertyvalues(pvs));
        dobind(mpvs);
    }
    ...
    public void validate() {
        object target = gettarget();
        assert.state(target != null, "no target to validate");
        bindingresult bindingresult = getbindingresult();
    
        // 拿到所有的验证器  一个个的对此target进行验证~~~
        // call each validator with the same binding result
        for (validator validator : getvalidators()) {
            validator.validate(target, bindingresult);
        }
    }
}

databinder提供了这两个非常独立的原子方法：绑定 + 校验。他俩结合完成了我们的数据绑定+数据校验，完全的和业务无关~

网上有很多文章说databinder完成数据绑定后继续校验，这种说法是不准确的呀，因为它并不处理这部分的组合逻辑，它只提供原始能力~

spring mvc处理入参的时机

spring mvc处理入参的逻辑是非常复杂的，前面花大篇幅讲了spring mvc对返回值的处理器：handlermethodreturnvaluehandler，详见：
【小家spring】spring mvc容器的web九大组件之---handleradapter源码详解---一篇文章带你读懂返回值处理器handlermethodreturnvaluehandler

同样的，本文只关注它对@requestbody这种类型的入参进行讲解~
处理入参的处理器：handlermethodargumentresolver，处理@requestbody最终使用的实现类是：requestresponsebodymethodprocessor，spring借助此处理器完成一系列的消息转换器、数据绑定、数据校验等工作~

requestresponsebodymethodprocessor

这个类应该是陌生的，在上面推荐的处理mvc返回值的文章中有提到过它：它能够处理@responsebody注解返回值（请参考它的supportsreturntype()方法~）
它还有另一个能力是：它能够处理请求参数（当然也是标注了@requestbody它的~）
所以它既是个处理返回值的handlermethodreturnvaluehandler，有是一个处理入参的handlermethodargumentresolver。所以它命名为processor而不是resolver/handler嘛，这就是命名的艺术~

// @since 3.1
public class requestresponsebodymethodprocessor extends abstractmessageconvertermethodprocessor {

    @override
    public boolean supportsparameter(methodparameter parameter) {
        return parameter.hasparameterannotation(requestbody.class);
    }
    // 类上或者方法上标注了@responsebody注解都行
    @override
    public boolean supportsreturntype(methodparameter returntype) {
        return (annotatedelementutils.hasannotation(returntype.getcontainingclass(), responsebody.class) || returntype.hasmethodannotation(responsebody.class));
    }
    
    // 这是处理入参封装校验的入口，也是本文关注的焦点
    @override
    public object resolveargument(methodparameter parameter, @nullable modelandviewcontainer mavcontainer,
            nativewebrequest webrequest, @nullable webdatabinderfactory binderfactory) throws exception {
        
        // 它是支持`optional`容器的
        parameter = parameter.nestedifoptional();
        // 使用消息转换器httpinputmessage把request请求转换出来
        // 此处注意：比如本例入参是person类，所以经过这里处理会生成一个空的person对象出来（反射）
        object arg = readwithmessageconverters(webrequest, parameter, parameter.getnestedgenericparametertype());

        // 获取到入参的名称
        // 请注意：这里的名称是类名首字母小写，并不是你方法里写的名字。比如本利若形参名写为personaaa，但是name的值还是person
        string name = conventions.getvariablenameforparameter(parameter);

        // 只有存在binderfactory才会去完成自动的绑定、校验~
        // 此处web环境为：servletrequestdatabinderfactory
        if (binderfactory != null) {
            webdatabinder binder = binderfactory.createbinder(webrequest, arg, name);

            // 显然传了参数才需要去绑定校验嘛
            if (arg != null) {

                // 这里完成数据绑定+数据校验~~~~~（绑定的错误和校验的错误都会放进errors里）
                // applicable：适合
                validateifapplicable(binder, parameter);

                // 若有错误消息haserrors()，并且仅跟着的一个参数不是errors类型，spring mvc会主动给你抛出methodargumentnotvalidexception异常
                // 否则，调用者自行处理
                if (binder.getbindingresult().haserrors() && isbindexceptionrequired(binder, parameter)) {
                    throw new methodargumentnotvalidexception(parameter, binder.getbindingresult());
                }
            }
        
            // 把错误消息放进去 证明已经校验出错误了~~~
            // 后续逻辑会判断model_key_prefix这个key的~~~~
            if (mavcontainer != null) {
                mavcontainer.addattribute(bindingresult.model_key_prefix + name, binder.getbindingresult());
            }
        }

        return adaptargumentifnecessary(arg, parameter);
    }

    // 校验，如果合适的话。使用webdatabinder，失败信息最终也都是放在它身上~  本方法是本文关注的焦点
    // 入参：methodparameter parameter
    protected void validateifapplicable(webdatabinder binder, methodparameter parameter) {
        // 拿到标注在此参数上的所有注解们（比如此处有@valid和@requestbody两个注解）
        annotation[] annotations = parameter.getparameterannotations();
        for (annotation ann : annotations) {
            // 先看看有木有@validated
            validated validatedann = annotationutils.getannotation(ann, validated.class);

            // 这个里的判断是关键：可以看到标注了@validated注解 或者注解名是以valid打头的 都会有效哦
            //注意：这里可没说必须是@valid注解。实际上你自定义注解，名称只要一valid开头都成~~~~~
            if (validatedann != null || ann.annotationtype().getsimplename().startswith("valid")) {
                // 拿到分组group后，调用binder的validate()进行校验~~~~
                // 可以看到：拿到一个合适的注解后，立马就break了~~~
                // 所以若你两个主机都标注@validated和@valid，效果是一样滴~
                object hints = (validatedann != null ? validatedann.value() : annotationutils.getvalue(ann));
                object[] validationhints = (hints instanceof object[] ? (object[]) hints : new object[] {hints});
                binder.validate(validationhints);
                break;
            }
        }
    }
    ...
}

本文我们只着眼于关注@valid的数据校验这块，有几个相关的使用小细节，总结如下：

1. 形参（@requestbody标注的入参）的name(形参名)和你写什么无关，若是实体类名字就是类名首字母小写。（若是数组、集合等，都会有自己特定的名称）
2. @validated和@valid都能使校验生效，但却不仅仅是它哥俩才能行：任何名称是"valid"打头的注解都能使得数据校验生效
   1. 自定义注解名称以valid开头，并且给个value属性同样能够指定group分组
   2. 个人直接建议使用@validated即可，而去使用@valid了，更不用自己给自己找麻烦去自定义注解啥的了~
3. 只有当errors(bindingresult)入参是是仅跟着@valid注解的实体，spring mvc才会把错误消息放权交给调用者处理，否则（没有或者不是紧挨着）它会抛出methodargumentnotvalidexception异常~

这是使用@requestbody结合@valid完成数据校验的基本原理。其实当spring mvc在处理@requestpart注解入参数据时，也会执行绑定、校验的相关逻辑。对应处理器是requestpartmethodargumentresolver，原理大体上和这相似，它主要处理multipart相关，本文忽略~

---

==此处提示一个点，此文发出去后有一个好奇的小宝宝问我入参能使用多个对象并且都用@requestbody标注吗？==
关于这个问题姑且先不考虑合理与否，我们这样做试试：

    @postmapping("/hello")
    public object hellopost(@valid @requestbody person personaaa, bindingresult result, @valid @requestbody person personbbb) {
        ...
    }

请求却报错了：

resolved [org.springframework.http.converter.httpmessagenotreadableexception: i/o error while reading input message; nested exception is java.io.ioexception: stream closed]

错误消息很好理解：请求域的body体是只能被读取一次的（流只能被读取一次嘛）。
若你是好奇的，你可能还会问：url参数呢？请求链接?后面的参数呢，如何封装？？？因为本部分内容不是本文的关注点，若有兴趣请出门左拐~

说明：关于使用map、list、数组等接受@requestbody参数的情况类似，区别在于绑定器上，对map、list的校验前面文章有过讲解，此处就不展开了。

希望读者能掌握这部分内容，因为它和面向使用者比较重要的@initbinder强关联~~~

实际使用中一般使用@validated分组校验（若需要），然后结合全局异常的处理方式来友好的对调用者展示错误消息~

全局异常处理示例

当校验失败时，spring会抛出methodargumentnotvalidexception异常，该异常会持有校验结果对象bindingresult，从而获得校验失败信息。本处只给示例，仅供参考：

@restcontrolleradvice
public class methodargumentnotvalidexceptionhandler {


    @exceptionhandler(methodargumentnotvalidexception.class)
    public result handlemethodargumentnotvalid(methodargumentnotvalidexception ex) {
        bindingresult bindingresult = ex.getbindingresult();

        stringbuilder stringbuilder = new stringbuilder();
        for (fielderror error : bindingresult.getfielderrors()) {
            string field = error.getfield();
            object value = error.getrejectedvalue();
            string msg = error.getdefaultmessage();
            string message = string.format("错误字段：%s，错误值：%s，原因：%s；", field, value, msg);
            stringbuilder.append(message).append("\r\n");
        }
        return result.error(msgdefinition.illegal_arguments.codeof(), stringbuilder.tostring());
    }
}

遗留痛点

你是否发现，虽然spring mvc给我们提供了极其方便的数据校验方式，但是它还是有比较大的局限性的：它要求待校验的入参是javabean

请注意：并不一样要求是请求body体哦，比如get请求的入参若用javabean接收的话，依旧能启用校验

但在实际应用中，其实我们非常多的controller方法的方法入参是平铺的，也就是所谓的平铺参数，形如这样：

    @putmapping("/hello/id/{id}/status/{status}")
    public object helloget(@pathvariable integer id, @pathvariable integer status) {
        ...
        return "hello world";
    }

其实，特别是get请求的case，@requestparam入参一般是非常多的（比如分页查询），难道对于这种平铺参数的case，我们真的是能通过人肉if else的去校验吗？
兴许你对此问题有兴趣，那就参阅本文吧，它能给你提供解决方案：【小家spring】让controller支持对平铺参数执行数据校验（默认spring mvc使用@valid只能对javabean进行校验）

==@validated和@valid的区别==

如题的问题，我相信是很多小伙伴都很关心的一个对比，若你把这个系列都有喵过，那么这个问题的答案就浮出水面了：

1. @valid：标准jsr-303规范的标记型注解，用来标记验证属性和方法返回值，进行级联和递归校验
2. @validated：spring的注解，是标准jsr-303的一个变种（补充），提供了一个分组功能，可以在入参验证时，根据不同的分组采用不同的验证机制
3. 在controller中校验方法参数时，使用@valid和@validated并无特殊差异（若不需要分组校验的话）
4. @validated注解可以用于类级别，用于支持spring进行方法级别的参数校验。@valid可以用在属性级别约束，用来表示级联校验。
5. @validated只能用在类、方法和参数上，而@valid可用于方法、字段、构造器和参数上

最后提示一点：spring boot的web starter已经加入了bean validation以及实现的依赖，可以直接使用。但若是纯spring mvc环境，请自行导入~

总结

本文介绍的是我们平时使用得最多的数据校验场景：使用@validated完成controller的入参校验，实现优雅的处理数据校验。同时希望通过本文能让你彻底弄懂@validated和@valid使用上的区别以及联系，在实际生产使用中能够做到更加的得心应手~

知识交流

若文章格式混乱，可点击：

==the last：如果觉得本文对你有帮助，不妨点个赞呗。当然分享到你的朋友圈让更多小伙伴看到也是被作者本人许可的~==

若对技术内容感兴趣可以加入wx群交流：java高工、架构师3群。
若群二维码失效，请加wx号：fsx641385712（或者扫描下方wx二维码）。并且备注："java入群" 字样，会手动邀请入群