hibernate validator自定义校验注解以及基于服务（服务组）的校验

hibernate validator是Bean Validation 1.1 (JSR 349) Reference Implementation，其广泛的应用在mvc的参数校验中，尤其是使用服务端spring mvc模板的时候。在这里，我们要讲的不是如何使用的问题。而是如何基于其提供更加符合项目要求以及最小化重复实现的目标，在不少情况下，我们在不同的服务中，对于相同的请求类Req，对于其中不同字段的校验要求是不同的，比如有些时候name字段是必须的，但其他情况下是非必须的，所以需要跟着服务或者服务组进行校验。再如，几乎每个系统都会使用到数据字典，使用数据字典的时候，有两种方式可以校验其取值范围，一种是直接使用java枚举类型，另外一种是人工进行判断。只不过，我们不建议使用枚举类型，但是我们也希望能够和通用的参数一样进行校验，而不是对于数据字典进行特殊校验。对于这两种情况，都可以在hibernate validator的技术上实现。对于服务分组，可以新增一个注解比如ValidServices实现，对于枚举校验，可以增加一个自定义的校验注解实现，如下：

ValidServices.java

package tf56.lf.base.metadata.validate;

import java.lang.annotation.Retention;
import java.lang.annotation.Target;
import java.lang.annotation.ElementType;
import java.lang.annotation.RetentionPolicy;
/**
* 参数校验分组注解
* @author admin
*
*/
@Target({ElementType.FIELD})
@Retention(value = RetentionPolicy.RUNTIME)
public @interface ValidServices {
String[] services();
}

package tf56.lf.base.metadata.validate;

import java.util.Map;

public class ValidationResult {
// 校验结果是否有错
private boolean success = true;

// 校验错误信息
private Map<String, String> errorPair;

public boolean isSuccess() {
return success;
}

public void setSuccess(boolean success) {
this.success = success;
}

public Map<String, String> getErrorPair() {
return errorPair;
}

public void setErrorPair(Map<String, String> errorPair) {
this.errorPair = errorPair;
}
}

Dict.java

package tf56.lf.base.metadata.validate;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

import javax.validation.Constraint;
import javax.validation.Payload;

@Target({ElementType.FIELD})
@Retention(value = RetentionPolicy.RUNTIME)
@Constraint(validatedBy = { DictValidator.class })
@Documented
public @interface Dict {

String dictName();

String message() default "{数据字典取值不合法,请参考标准数据字典管理}";

Class<?>[] groups() default {};

Class<? extends Payload>[] payload() default {};

}

DictValidator：

package tf56.lf.base.metadata.validate;

import javax.validation.ConstraintValidator;
import javax.validation.ConstraintValidatorContext;

import tf56.lf.base.metadata.cons.DictUtils;

public class DictValidator implements ConstraintValidator<Dict, String> {

private String dictName;

@Override
public void initialize(Dict dictAnno) {
this.dictName = dictAnno.dictName();
}

@Override
public boolean isValid(String value, ConstraintValidatorContext context) {
if (DictUtils.isValid(dictName, value)) {
return true;
}
context.disableDefaultConstraintViolation();
context.buildConstraintViolationWithTemplate("该字段的当前值" + value + "不在数据字典" + dictName + "的有效取值范围内, 有效值为:[" + DictUtils.getDictKeys(dictName) + "]").addConstraintViolation();
return false;
}

}

DictUtils为字典取值范围校验类，每个公司的实现不同，读者自己构建一个即可。

主类：

package tf56.lf.common.util;

import java.lang.reflect.Field;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;

import javax.validation.ConstraintViolation;
import javax.validation.Validation;
import javax.validation.Validator;
import javax.validation.constraints.AssertTrue;
import javax.validation.constraints.Past;
import javax.validation.constraints.Pattern;
import javax.validation.groups.Default;

import org.apache.commons.collections.CollectionUtils;
import org.hibernate.validator.constraints.Email;
import org.hibernate.validator.constraints.Length;
import org.hibernate.validator.constraints.NotBlank;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import tf56.lf.base.metadata.validate.Dict;
import tf56.lf.base.metadata.validate.ValidServices;
import tf56.lf.base.metadata.validate.ValidationResult;
import tf56.lf.common.cons.SpiderSystemError;
import tf56.lf.common.exception.LfException;

public class ValidationUtils {

private static Map<Field,Set<String>> validFields = new ConcurrentHashMap<Field,Set<String>>();

static final Logger logger = LoggerFactory.getLogger(ValidationUtils.class);

private static Validator validator = Validation
.buildDefaultValidatorFactory().getValidator();

public static <T> ValidationResult validateEntity(String serviceId,T obj) {
boolean noNeedCheck = true;
Map<String, String> errorMsg = new HashMap<String, String>();
Field[] fields = obj.getClass().getDeclaredFields();
for(int i=0;i<fields.length;i++) {
if(validFields.get(fields[i]) == null) {
Set<String> services = new HashSet<String>();
ValidServices serviceAnno = fields[i].getAnnotation(ValidServices.class);
if (serviceAnno != null) {
for (int j=0;j<serviceAnno.services().length;j++) {
services.add(String.valueOf(serviceAnno.services()[j]));
}
}
validFields.putIfAbsent(fields[i], services);
}
if (validFields.get(fields[i]).isEmpty() || validFields.get(fields[i]).contains(serviceId)) {
noNeedCheck = false;
Map<String, String> errorPair = validatePropertyInternal(serviceId,obj,fields[i].getName());
errorMsg.putAll(errorPair);
}
}
if (noNeedCheck) {
logger.warn("服务" + serviceId + "在" + obj.getClass().getCanonicalName() + "中所有字段都没有配置做任何校验.");
}
ValidationResult result = new ValidationResult();
if (!errorMsg.isEmpty()) {
result.setErrorPair(errorMsg);
result.setSuccess(false);
}
return result;
}

private static <T> Map<String, String> validatePropertyInternal(String serviceId, T obj,
String propertyName) {
Set<ConstraintViolation<T>> set = validator.validateProperty(obj,
propertyName, Default.class);
Map<String, String> errorMsg = new HashMap<String, String>();
if (CollectionUtils.isNotEmpty(set)) {
for (ConstraintViolation<T> cv : set) {
errorMsg.put(propertyName, cv.getMessage());
}
}
return errorMsg;
}

public static <T> ValidationResult validateProperty(String serviceId, T obj,
String propertyName) {
ValidationResult result = new ValidationResult();
Field field = null;
try {
field = obj.getClass().getDeclaredField(propertyName);
} catch (NoSuchFieldException | SecurityException e) {
throw new LfException(SpiderSystemError.ERR_NO_SUCH_FIELD_OR_FORBIDDEN);
}
if(validFields.get(field) == null) {
Set<String> services = new HashSet<String>();
ValidServices serviceAnno = field.getAnnotation(ValidServices.class);
if (serviceAnno != null) {
for (int i=0;i<serviceAnno.services().length;i++) {
services.add(String.valueOf(serviceAnno.services()[i]));
}
}
validFields.putIfAbsent(field, services);
}
if (validFields.get(field).isEmpty() || validFields.get(field).contains(serviceId)) {
Map<String, String> errorPair = validatePropertyInternal(serviceId,obj,field.getName());
if (!errorPair.isEmpty()) {
result.setErrorPair(errorPair);
result.setSuccess(false);
}
}
return result;
}

public static void main(String[] args) {
SimpleEntity entity = new SimpleEntity();
entity.setValid(true);
ValidationResult result = ValidationUtils.validateEntity("1001",entity);
if (!result.isSuccess()) {
System.out.println(FastJsonUtil.serializeFromObject(result.getErrorPair()));
}

result = ValidationUtils.validateEntity("100",entity);
if (!result.isSuccess()) {
System.out.println(FastJsonUtil.serializeFromObject(result.getErrorPair()));
}

entity = new SimpleEntity();
entity.setValid(true);
result = ValidationUtils.validateEntity("1",entity);
if (!result.isSuccess()) {
System.out.println(FastJsonUtil.serializeFromObject(result.getErrorPair()));
}
}

public static class SimpleEntity {

@ValidServices(services = { "1001","1002" })
@NotBlank(message="名字不能为空或者空串")
@Length(min=2,max=10,message="名字必须由2~10个字组成")
private String name;

@Dict(dictName = "payType")
private String payType;

@Past(message="时间不能晚于当前时间")
private Date date;

@Email(message="邮箱格式不正确")
private String email;

@Pattern(regexp="(?![0-9]+$)(?![a-zA-Z]+$)[0-9A-Za-z]{5,10}",message="密码必须是5~10位数字和字母的组合")
private String password;

@AssertTrue(message="字段必须为真")
private boolean valid;

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public Date getDate() {
return date;
}

public void setDate(Date date) {
this.date = date;
}

public String getEmail() {
return email;
}

public void setEmail(String email) {
this.email = email;
}

public String getPassword() {
return password;
}

public void setPassword(String password) {
this.password = password;
}

public boolean isValid() {
return valid;
}

public void setValid(boolean valid) {
this.valid = valid;
}
}
}

输出如下：

{"name":"名字不能为空或者空串","payType":"该字段的当前值null不在数据字典payType的有效取值范围内, 有效值为:[OTHER,BANK,CASH,TF_ACCOUNT]"}
{"payType":"该字段的当前值null不在数据字典payType的有效取值范围内, 有效值为:[OTHER,BANK,CASH,TF_ACCOUNT]"}
{"payType":"该字段的当前值null不在数据字典payType的有效取值范围内, 有效值为:[OTHER,BANK,CASH,TF_ACCOUNT]"}