Spring MVC+FastJson+hibernate-validator整合的完整实例教程

2023-09-13 13:55:04 62

一：hibernate-validator基础

1.简介：

通过使用注解Annotations给类或者类的属性加上约束(constraint),在运行期检查属性值的合法性.

2.作用：

在API接口开发中参数校验是非常重要的事情，因为客户端很可能会少传参数，或者值不合法，甚至参数值是恶意的，所以对客户端传来的参数的合法性就必须要校验了，其中将参数值的校验规则通过注解的形式注解到属性上是一种比较优雅的方式。

3.常用的约束注解

@Null被注释的元素必须为null
@NotNull被注释的元素必须不为null
@AssertTrue被注释的元素必须为true
@AssertFalse被注释的元素必须为false
@Min(value)被注释的元素必须是一个数字，其值必须大于等于指定的最小值
@Max(value)被注释的元素必须是一个数字，其值必须小于等于指定的最大值
@DecimalMin(value)被注释的元素必须是一个数字，其值必须大于等于指定的最小值
@DecimalMax(value)被注释的元素必须是一个数字，其值必须小于等于指定的最大值
@Size(max=,min=)被注释的元素的大小必须在指定的范围内
@Digits(integer,fraction)被注释的元素必须是一个数字，其值必须在可接受的范围内
@Past被注释的元素必须是一个过去的日期
@Future被注释的元素必须是一个将来的日期
@Pattern(regex=,flag=)被注释的元素必须符合指定的正则表达式
HibernateValidator附加的constraint
@NotBlank(message=)验证字符串非null，且长度必须大于0
@Email被注释的元素必须是电子邮箱地址
@Length(min=,max=)被注释的字符串的大小必须在指定的范围内
@NotEmpty被注释的字符串的必须非空
@Range(min=,max=,message=)被注释的元素必须在合适的范围内
@URL(protocol=,host=,port=,regexp=,flags=)被注释的字符串必须是一个有效的url
@CreditCardNumber被注释的字符串必须通过Luhn校验算法，银行卡，信用卡等号码一般都用Luhn计算合法性
@ScriptAssert(lang=,script=,alias=)要有JavaScriptingAPI即JSR223(“ScriptingfortheJavaTMPlatform”)的实现
@SafeHtml(whitelistType=,additionalTags=)classpath中要有jsoup包

4.初识hibernate-validator

publicclassAddress{
@NotNullprivateStringline1;
privateStringline2;
privateStringzip;
privateStringstate;
@Length(max=20)
@NotNull
privateStringcountry;
@Range(min=-2,max=50,message="Flooroutofrange")
publicintfloor;
//getter&&setter
}

二：整合校验hibernate-validator

该示例是在SpringMVC+FastJson整合（https://www.nhooo.com/article/139094.htm）基础上进行集成的，可以先看一下这篇文章（有源码供下载），在该文章的基础上整合hibernate-validator

整合步骤：

1、在pom.xml中引入hibernate-validator依赖


org.hibernate
hibernate-validator
5.4.1.Final

2、在[xxx]-servlet.xml中配置验证器：HibernateValidator








text/html;charset=UTF-8
application/json




QuoteFieldNames
WriteMapNullValue














classpath:conf/settings/validation
classpath:org/hibernate/validator/ValidationMessages

3、在src/main/resources/conf/settings位置定义验证消息文件描述validation.properties

validation.common.not.null=该字段不能为空
validation.common.not.range=长度非法
validation.common.format.error=格式错误

validation.param.age=年龄未满18周岁

rep.error.unknown=未知错误

4、新建实体类以供测试

UserEntity

packagecom.mengdee.manage.validator;
importjavax.validation.constraints.Min;
importjavax.validation.constraints.NotNull;
importjavax.validation.constraints.Null;
importjavax.validation.constraints.Pattern;
importorg.hibernate.validator.constraints.Email;
importorg.hibernate.validator.constraints.Length;
importorg.hibernate.validator.constraints.NotBlank;
publicclassUserEntity{
@Null(groups={GroupA.class})
@NotNull(groups={GroupB.class})
@Min(value=1,message="id值必须大于0",groups={GroupB.class})
privateLongid;

@NotBlank(groups={GroupA.class,GroupB.class})
@Pattern(regexp="^(?![0-9]+$)(?![a-zA-Z]+$)[0-9A-Za-z]{6,20}$",message="由6-21字母和数字组成，不能是纯数字或纯英文",groups={GroupA.class,GroupB.class})
privateStringpassword;

@NotBlank(groups={GroupA.class,GroupB.class})
@Pattern(regexp="^((13[0-9])|(15[^4,\\D])|(18[0,3-9]))\\d{8}$",message="手机号格式不正确")
privateStringphone;


@NotBlank(groups={GroupB.class})
@Length(min=6,max=12,message="昵称长度为6到12位")
privateStringnickname;

@Min(value=18,message="{validation.param.age}")
privateintage;

@NotBlank(groups={GroupA.class})
@Email(message="{validation.common.format.error}")
privateStringemail;

@NotBlank
@Length(min=3,max=10,message="{validation.common.not.range}")
privateStringusername;


publicUserEntity(){

}


publicLonggetId(){
returnid;
}

publicvoidsetId(Longid){
this.id=id;
}

publicStringgetNickname(){
returnnickname;
}

publicvoidsetNickname(Stringnickname){
this.nickname=nickname;
}

publicintgetAge(){
returnage;
}

publicvoidsetAge(intage){
this.age=age;
}

publicStringgetEmail(){
returnemail;
}

publicvoidsetEmail(Stringemail){
this.email=email;
}

publicStringgetPassword(){
returnpassword;
}

publicvoidsetPassword(Stringpassword){
this.password=password;
}

publicStringgetUsername(){
returnusername;
}

publicvoidsetUsername(Stringusername){
this.username=username;
}

publicStringgetPhone(){
returnphone;
}

publicvoidsetPhone(Stringphone){
this.phone=phone;
}
}

UserModel

packagecom.mengdee.manage.validator;
importjavax.validation.constraints.Min;
importjavax.validation.constraints.Pattern;
importorg.hibernate.validator.constraints.Email;
importorg.hibernate.validator.constraints.Length;
importorg.hibernate.validator.constraints.NotBlank;
publicclassUserModel{
@Min(value=1,message="id值必须大于0")
privatelongid;

@NotBlank
@Length(min=6,max=12,message="昵称长度为6到12位")
privateStringnickname;

@Min(value=18,message="{validation.param.age}")
privateintage;

@NotBlank
@Email(message="{validation.common.format.error}")
privateStringemail;

@NotBlank
@Pattern(regexp="^(?![0-9]+$)(?![a-zA-Z]+$)[0-9A-Za-z]{6,20}$",message="由6-21字母和数字组成，不能是纯数字或纯英文")
privateStringpassword;

@NotBlank
@Length(min=3,max=10,message="{validation.common.not.range}")
privateStringusername;

@NotBlank
@Pattern(regexp="^((13[0-9])|(15[^4,\\D])|(18[0,3-9]))\\d{8}$",message="手机号格式不正确")
privateStringphone;


publicUserModel(){

}


publiclonggetId(){
returnid;
}

publicvoidsetId(longid){
this.id=id;
}

publicStringgetNickname(){
returnnickname;
}

publicvoidsetNickname(Stringnickname){
this.nickname=nickname;
}

publicintgetAge(){
returnage;
}

publicvoidsetAge(intage){
this.age=age;
}

publicStringgetEmail(){
returnemail;
}

publicvoidsetEmail(Stringemail){
this.email=email;
}

publicStringgetPassword(){
returnpassword;
}

publicvoidsetPassword(Stringpassword){
this.password=password;
}

publicStringgetUsername(){
returnusername;
}

publicvoidsetUsername(Stringusername){
this.username=username;
}

publicStringgetPhone(){
returnphone;
}

publicvoidsetPhone(Stringphone){
this.phone=phone;
}
}

UserDetail:

packagecom.mengdee.manage.validator;
importorg.hibernate.validator.constraints.NotBlank;
publicclassUserDetail{

privateLongid;

@NotBlank
privateStringaddress;

@NotBlank
privateStringcompany;



publicUserDetail(){

}


publicLonggetId(){
returnid;
}
publicvoidsetId(Longid){
this.id=id;
}
publicStringgetAddress(){
returnaddress;
}
publicvoidsetAddress(Stringaddress){
this.address=address;
}
publicStringgetCompany(){
returncompany;
}
publicvoidsetCompany(Stringcompany){
this.company=company;
}
}

使用ValidController进行测试

packagecom.mengdee.manage.controller;
importjavax.servlet.http.HttpServletRequest;
importjavax.validation.Valid;
importorg.springframework.stereotype.Controller;
importorg.springframework.validation.BindingResult;
importorg.springframework.validation.FieldError;
importorg.springframework.web.bind.annotation.RequestMapping;
importorg.springframework.web.bind.annotation.RequestMethod;
importorg.springframework.web.bind.annotation.ResponseBody;

importcom.mengdee.manage.validator.UserModel;

@Controller
@RequestMapping("/Valid")
publicclassValidControllerextendsBaseController{

//http://localhost:8081/platform-springmvc-webapp/Valid/test?age=18&nickname=mengdee&id=1&email=123@qq.com&password=root123&username=123&phone=18321758957
@RequestMapping(value="/test",method=RequestMethod.GET)
public@ResponseBodyObjectvalidation(HttpServletRequestrequest,@ValidUserModeluser,BindingResultbindingResult){
if(bindingResult.hasErrors()){
FieldErrorfieldError=bindingResult.getFieldError();

returnsuper.ResponseJsonError(fieldError);
}

return"ok";
}


//一个方法同时校验多个对象需要绑定多个结果BindingResult，出现一个@Valid就对应后面声明的一个BindingResult
@RequestMapping(value="/test2",method=RequestMethod.GET)
public@ResponseBodyObjectvalidationMore(HttpServletRequestrequest,
@ValidUserModeluser,BindingResultbindingResult,
@ValidUserDetailuserDetail,BindingResultbindingResult2){
if(bindingResult.hasErrors()){
FieldErrorfieldError=bindingResult.getFieldError();

returnsuper.ResponseJsonError(fieldError);
}

if(bindingResult2.hasErrors()){
FieldErrorfieldError=bindingResult2.getFieldError();

returnsuper.ResponseJsonError(fieldError);
}
return"ok";
}
}

使用注意：

1、对于多个字段，系统验证的顺序好像和字段声明的顺序是不一样的，好像是无须的

2、对于每个验证如果没有message属性，系统会使用默认的，如对应@NotBlank相当于@NotBlank(message=”不能为空”)

3、对于引用类型如String等类型，一定要结合@NotNull、@NotEmpty或者@NotBlank来配合使用，如果不写空的约束，经测试，该字段是不参与校验的，如单独使用@Pattern、@Length、@Email等是不会进行验证的，必须要使用空的约束来限制

@Min：用于基本数据类型，如int、long等

@NotNull：任何对象的value不能为null

@NotEmpty：集合对象的元素不为0，即集合不为空，也可以用于字符串不为null

@NotBlank：只能用于字符串不为null，并且字符串trim()以后length要大于0

三：分组校验@Validated

@Valid是属于javax.validation.Valid里的。
@Validated是@Valid的一次封装，是spring提供的校验机制使用（org.springframework.validation.annotation.Validated），@Valid不提供分组功能

1.分组的作用（使用场景）：

每个校验的注解约束都有一个groups属性，用于指定该约束是属于哪个组的，这样在同一个字段上就可以配置多套约束，在使用的时候只需要指定使用那套约束即可，例如对于注册用户和修改用户信息时，注册时id必须为空，修改用户信息时id必须不能为空，在使用的时候只需要将这两种约束分配到不同的组中即可，如添加时使用组A的约束，更新时使用组B的约束

2.分组就是一个空接口interface

GroupA和GroupB

packagecom.mengdee.manage.validator;
publicinterfaceGroupA{
}

packagecom.mengdee.manage.validator;
publicinterfaceGroupB{
}

在使用时指定具体使用那套分组的约束@Validated({GroupA.class})

3.组序列@GroupSequence

默认情况下，不同组别的约束验证是无序的，组序列就是按照分组的前后顺序依次验证，如先验证GroupA组的约束，再验证GroupB组的约束。如果对组的校验顺序有要求，例如必须先校验A组再校验B组，可以使用@GroupSequence来定义每个组的顺序

使用场景：

（1）第二个组中的约束验证依赖于一个稳定状态来运行，而这个稳定状态是由第一个组来进行验证的。

（2）某个组的验证比较耗时，CPU和内存的使用率相对比较大，最优的选择是将其放在最后进行验证。因此，在进行组验证的时候尚需提供一种有序的验证方式，这就提出了组序列的概念。

一个组可以定义为其他组的序列，使用它进行验证的时候必须符合该序列规定的顺序。在使用组序列验证的时候，如果序列前边的组验证失败，则后面的组将不再给予验证。

使用注解GroupSequence定义组序列：GroupAB

packagecom.mengdee.manage.validator;
importjavax.validation.GroupSequence;
@GroupSequence({GroupA.class,GroupB.class})
publicinterfaceGroupAB{

ValidationController

packagecom.mengdee.manage.controller;
importjavax.servlet.http.HttpServletRequest;
importorg.springframework.stereotype.Controller;
importorg.springframework.validation.BindingResult;
importorg.springframework.validation.FieldError;
importorg.springframework.validation.annotation.Validated;
importorg.springframework.web.bind.annotation.RequestMapping;
importorg.springframework.web.bind.annotation.RequestMethod;
importorg.springframework.web.bind.annotation.ResponseBody;

importcom.mengdee.manage.validator.GroupA;
importcom.mengdee.manage.validator.GroupAB;
importcom.mengdee.manage.validator.GroupB;
importcom.mengdee.manage.validator.UserEntity;

@Controller
@RequestMapping("/validated")
publicclassValidationControllerextendsBaseController{

//校验时指定了GroupA，那么只校验约束中包含GroupA的约束，没有包含就不校验，例如对于phone，@NotBlank指定的分组，而@Pattern没有指定分组，那么只校验空着一个约束，不校验手机号格式
//http://localhost:8081/platform-springmvc-webapp/validated/groupA?password=root123&phone=123
@RequestMapping(value="/groupA",method=RequestMethod.GET)
public@ResponseBodyObjectgroupA(HttpServletRequestrequest,@Validated({GroupA.class})UserEntityuser,BindingResultbindingResult){
if(bindingResult.hasErrors()){
FieldErrorfieldError=bindingResult.getFieldError();

returnthis.ResponseJsonError(fieldError);
}

return"ok";
}

//http://localhost:8081/platform-springmvc-webapp/validated/groupB?phone=123&password=root123&id=1
@RequestMapping(value="/groupB",method=RequestMethod.GET)
public@ResponseBodyObjectgroupB(HttpServletRequestrequest,@Validated({GroupB.class})UserEntityuser,BindingResultbindingResult){
if(bindingResult.hasErrors()){
FieldErrorfieldError=bindingResult.getFieldError();

returnthis.ResponseJsonError(fieldError);
}

return"ok";
}

//groupAB
//http://localhost:8081/platform-springmvc-webapp/validated/groupAB?phone=111&password=root123&nickname=123&email=xxx@qq.com
//@Validated({GroupA.class,GroupB.class}):GroupA和GroupB的关系是或的关系，就像数据库中的OR一样，只要满足一个条件就会对该约束进行校验，同时使用多个组注意多个组之间没有先后属性之说，并不是先校验组A，然后再校验组B
//因为id的为空和不为空的约束都会进行检查，所以先注释掉该属性
@RequestMapping(value="/groupAB",method=RequestMethod.GET)
public@ResponseBodyObjectgroupAB(HttpServletRequestrequest,@Validated({GroupA.class,GroupB.class})UserEntityuser,BindingResultbindingResult){
if(bindingResult.hasErrors()){
FieldErrorfieldError=bindingResult.getFieldError();

returnthis.ResponseJsonError(fieldError);
}

return"ok";
}

//default
//http://localhost:8081/platform-springmvc-webapp/default?email=xxx@163.com&age=18
//@Validated如果没有指定groups则验证没有分组的属性（此时和@Valid功能一样）,如果一个字段上有多个约束，都必须没有指定组，如果部分约束指定的组，部分约束没有指定约束，那么在使用@Validated时不进行检查的
@RequestMapping(value="/default",method=RequestMethod.GET)
public@ResponseBodyObjectdefaultGroup(HttpServletRequestrequest,@ValidatedUserEntityuser,BindingResultbindingResult){
if(bindingResult.hasErrors()){
FieldErrorfieldError=bindingResult.getFieldError();

returnthis.ResponseJsonError(fieldError);
}

return"ok";
}

//localhost:8081/platform-springmvc-webapp/validated/sequence?phone=123&password=root123&email=123&nickname=123
//对于一个属性上有多个约束，并且多个约束不都在同一个组，那么在检查的时候顺序是根据GroupSequence定义的先后顺序来检查的
@RequestMapping(value="/sequence",method=RequestMethod.GET)
public@ResponseBodyObjectsequence(HttpServletRequestrequest,@Validated({GroupAB.class})UserEntityuser,BindingResultbindingResult){
if(bindingResult.hasErrors()){
FieldErrorfieldError=bindingResult.getFieldError();

returnthis.ResponseJsonError(fieldError);
}
return"ok";
}
}

四：自定义hibernatevalidation注解

当hibernatevalidation提供的注解不能满足需求时，可以自定义校验约束。

自定义注解约束步骤：

创建注解
创建注解对应的约束验证类
使用注解
测试注解

创建注解@Phone

packagecom.mengdee.manage.validator;
importjava.lang.annotation.Target;
importjavax.validation.Constraint;
importjavax.validation.Payload;
importstaticjava.lang.annotation.ElementType.ANNOTATION_TYPE;
importstaticjava.lang.annotation.ElementType.CONSTRUCTOR;
importstaticjava.lang.annotation.ElementType.FIELD;
importstaticjava.lang.annotation.ElementType.METHOD;
importstaticjava.lang.annotation.ElementType.PARAMETER;
importstaticjava.lang.annotation.RetentionPolicy.RUNTIME;
importjava.lang.annotation.Documented;
importjava.lang.annotation.Retention;
@Target({METHOD,FIELD,ANNOTATION_TYPE,CONSTRUCTOR,PARAMETER})
@Retention(RUNTIME)
@Documented
@Constraint(validatedBy={PhoneConstraint.class})
public@interfacePhone{
Stringmessage()default"手机号格式错误";
Stringregexp()default"^((13[0-9])|(15[^4,\\D])|(18[0,3-9]))\\d{8}$";
Class[]groups()default{};
Class[]payload()default{};
@Target({METHOD,FIELD,ANNOTATION_TYPE,CONSTRUCTOR,PARAMETER})
@Retention(RUNTIME)
@Documented
public@interfaceList{
Phone[]value();
}
}

创建手机号注解对应的约束验证类PhoneConstraint

packagecom.mengdee.manage.validator;
importjavax.validation.ConstraintValidator;
importjavax.validation.ConstraintValidatorContext;
publicclassPhoneConstraintimplementsConstraintValidator{
privateStringregexp;
@Override
publicvoidinitialize(PhonephoneAnnotation){
this.regexp=phoneAnnotation.regexp();
}

@Override
publicbooleanisValid(Stringvalue,ConstraintValidatorContextcontext){
if(value==null){
returntrue;//HV000028:UnexpectedexceptionduringisValidcall
}

if(value.matches(regexp)){
returntrue;
}
returnfalse;
}
}

在属性上使用注解@Phone

packagecom.mengdee.manage.validator;
importorg.hibernate.validator.constraints.NotBlank;
publicclassUserDetail{
@NotBlank
@Phone
privateStringphone;
publicUserDetail(){

}

publicStringgetPhone(){
returnphone;
}

publicvoidsetPhone(Stringphone){
this.phone=phone;
}
}

测试注解

//http://localhost:8081/platform-springmvc-webapp/Valid/test3?address=123&company=456&phone=123
@RequestMapping(value="/test3",method=RequestMethod.GET)
public@ResponseBodyObjectvalidationCustomAnnotation(HttpServletRequestrequest,
@ValidUserDetailuserDetail,BindingResultbindingResult){
if(bindingResult.hasErrors()){
FieldErrorfieldError=bindingResult.getFieldError();
returnsuper.ResponseJsonError(fieldError);
}
return"ok";
}

完整代码下载：http://xiazai.jb51.net/201804/yuanma/platform-springmvc-webapp(jb51.net).rar

总结

以上就是这篇文章的全部内容了，希望本文的内容对大家的学习或者工作具有一定的参考学习价值，如果有疑问大家可以留言交流，谢谢大家对毛票票的支持。

参考文章：

hibernatevalidation文档：http://docs.jboss.org/hibernate/validator/5.2/reference/en-US/html_single/#validator-customconstraints：
自定义注解：https://www.nhooo.com/article/139111.htm
深入理解Java：注解（Annotation）自定义注解入门：https://www.nhooo.com/article/35949.htm

Spring MVC+FastJson+hibernate-validator整合的完整实例教程

热门推荐

随机推荐