javax.validation和hibernate-validator參數校驗

@Validated和@Valid的區別

在Controller中校驗方法參數時，使用@Valid和@Validated並無特殊差異（若不需要分組校驗的話）
@Valid：標準JSR-303規範的標記型註解，用來標記驗證屬性和方法返回值，進行級聯和遞歸校驗
@Validated：Spring的註解，是標準JSR-303的一個變種（補充），提供了一個分組功能，可以在入參驗證時，根據不同的分組採用不同的驗證機制

方法級別：
@Validated註解可以用於類級別，用於支持Spring進行方法級別的參數校驗。@Valid可以用在屬性級別約束，用來表示級聯校驗。
@Validated只能用在類、方法和參數上，而@Valid可用於方法、字段、構造器和參數上

如何使用

這兩個包要同時導入！

   <dependency>
        <groupId>javax.validation</groupId>
        <artifactId>validation-api</artifactId>
        <version>2.0.1.Final</version>
      </dependency>
      <dependency>
        <groupId>org.hibernate.validator</groupId>
        <artifactId>hibernate-validator</artifactId>
        <version>6.0.7.Final</version>
      </dependency>

    @PostMapping("/tabletSign/pushInfo/patient")
    public AjaxResult pushInfoPatient(@Valid @RequestBody BizPatient bizPatient) {
    }

public class BizPatient {
    private static final long serialVersionUID = 1L;
    @NotNull(message = "id不能爲空")
    private Long patientId;
}

如何分組校驗？

有時候我們需要在不同的Controller中校驗不同的字段

Controller

    @PostMapping("/tabletSign/pushInfo/patient")
    public AjaxResult pushInfoPatient(
        @Validated(BizPatient.SaveGroup.class) @RequestBody BizPatient bizPatient) {
    }

    @PostMapping("/tabletSign/patient/signerInfo")
    public AjaxResult getSignerInfo(
        @Validated(BizPatient.SelectGroup.class) @RequestBody BizPatient bizPatient) {
    }

javaBean

public class BizPatient {
    private static final long serialVersionUID = 1L;
    /**
     * $column.columnComment
     */
    //非空判斷
    @NotNull(groups = {SaveGroup.class, SelectGroup.class}, message = "patientId 不能爲空")
    private Long patientId
}

如何校驗關聯對象？

    @PostMapping(value = "/saveOrUpdate")
    public GbmResult saveOrUpdate(@RequestBody @Validated GdVo gdVo) {
    }


@Data
public class GdVo {
    @Valid
    private GdAfterSalesDto gdAfterSalesDto;
    @Valid
    private List<GdProcessRecordDto> gdProcessRecordDto;
}

手動校驗工具類

• 有時候註解不生效，我們可以手動校驗
• 或者一個接口同時做add和update。如addAndUpdate接口。這個時候我們不好使用分組校驗。只能手動校驗

import org.springframework.validation.BindingResult;
import javax.validation.ConstraintViolation;
import javax.validation.Validation;
import javax.validation.Validator;
import java.util.Set;
import java.util.stream.Collectors;
public class ValidParameterUtils {
    private static Validator validator;

    static {
        validator = Validation.buildDefaultValidatorFactory().getValidator();
    }

    public static void validParameter(BindingResult validResult){
        if (validResult.hasErrors()){
            throw new GBMException(validResult.getFieldError().getDefaultMessage(),GbmResultCode.PARAMETER_EXCEPTION.code());
        }
    }
    public static void validateEntity(Object object, Class<?>... groups)
            throws GBMException {
        Set<ConstraintViolation<Object>> constraintViolations = validator.validate(object, groups);
        if (!constraintViolations.isEmpty()) {
            StringBuilder msg = new StringBuilder();
            for(ConstraintViolation<Object> constraint:  constraintViolations){
                msg.append(constraint.getMessage()).append("  ");
            }
            throw new GBMException(msg.toString(),GbmResultCode.FAIL.code());
        }
    }



    /**
     * @Des 返回錯誤信息
     * @Author yinkai
     * @Date 2022/2/28 9:24
     */
    public static String validateEntityRString(Object object, Class<?>... groups) {
        Set<ConstraintViolation<Object>> constraintViolations = validator.validate(object, groups);
        return constraintViolations.stream().map(ConstraintViolation::getMessage).collect(Collectors.joining("  "));
    }
}

使用

public class ZskQuestionsAndAnswersVo {

    @NotNull(groups = {AddGroup.class}, message = "knowledgeId爲空")
    private Long knowledgeId;

    @Length(max = 100, min = 1, message = "問題必須在1-100字符之間")
    @NotBlank(groups = {AddGroup.class}, message = "problemContent爲空")
    private String problemContent;
    @Length(max = 500, min = 1, message = "回答必須在1-500字符之間")
    @NotBlank(groups = {AddGroup.class}, message = "answer爲空")
    private String answer;

}

    @PostMapping(value = "/addQuestionsAndAnswers")
    public GbmResult addQuestionsAndAnswers(@RequestParam("img") MultipartFile[] img,
                                            @RequestParam("vedio") MultipartFile[] vedio,
                                            @Valid ZskQuestionsAndAnswersVo zskQuestionsAndAnswersVo) {
        ValidParameterUtils.validateEntity(zskQuestionsAndAnswersVo,AddGroup.class);
    }

還需定義全局異常處理器

@RestControllerAdvice
@Order(100)
public class GBMExceptionHandler {
    private Logger logger = LoggerFactory.getLogger(getClass());


    //處理Get請求中 使用@Valid 驗證路徑中請求實體校驗失敗後拋出的異常
    @ExceptionHandler(org.springframework.validation.BindException.class)
    @ResponseBody
    public GbmResult BindExceptionHandler(BindingResult e) {
        String message = e.getAllErrors().stream().map(DefaultMessageSourceResolvable::getDefaultMessage).collect(Collectors.joining());
        return GbmResult.error(GbmResultCode.PARAMETER_EXCEPTION.getCode(),message);
    }

校驗List

Controller類上加@Validated

@Validated
public class ZskKnowledgeController {

handel方法上加

@PostMapping(value = "/saveOrUpdateZskAccessories")
    public GbmResult saveOrUpdateZskAccessories(@RequestBody @Valid List<ZskAccessoriesListType> zskKnowledgeVoList) {

註解含義

@Pattern(regexp = "1[3|4|5|7|8][0-9]\d{8}",message = "手機號碼格式不正確")
@NotEmpty(message ="returnAndExchangeInformation 不能爲空")
@NotNull(message ="knowledgeId 不能爲空")
@Digits(integer = 10, fraction = 2, message = "補發運費格式錯誤")
@Length(max = 50, min = 1, message = "配件名稱必須在1-50字符之間")

Constraint 詳細信息
@AssertFalse 該值必須爲False
@AssertTrue 該值必須爲True
@DecimalMax(value，inclusive) 被註釋的元素必須是一個數字，其值必須小於等於指定的最大值 ，inclusive表示是否包含該值
@DecimalMin(value，inclusive) 被註釋的元素必須是一個數字，其值必須大於等於指定的最小值 ，inclusive表示是否包含該值
@Digits 限制必須爲一個小數，且整數部分的位數不能超過integer，小數部分的位數不能超過fraction
@Email 該值必須爲郵箱格式
@Future 被註釋的元素必須是一個將來的日期
@FutureOrPresent 被註釋的元素必須是一個現在或將來的日期
@Max(value) 被註釋的元素必須是一個數字，其值必須小於等於指定的最大值
@Min(value) 被註釋的元素必須是一個數字，其值必須大於等於指定的最小值
@Negative 該值必須小於0
@NegativeOrZero 該值必須小於等於0
@NotBlank 該值不爲空字符串，例如“ ”
@NotEmpty 該值不爲空字符串
@NotNull 該值不爲Null
@Null 該值必須爲Null
@Past 被註釋的元素必須是一個過去的日期
@PastOrPresent 被註釋的元素必須是一個過去或現在的日期
@Pattern(regexp) 匹配正則
@Positive 該值必須大於0
@PositiveOrZero 該值必須大於等於0
@Size(min,max) 數組大小必須在[min,max]這個區間

自定義註解

手動實現一個自定義註解，做到靈活指定字符串字段只包含數字、字母、特殊符號、中文的校驗

import javax.validation.Constraint;
import javax.validation.Payload;
import java.lang.annotation.*;

@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Constraint(
        validatedBy = {ContainCharValidator.class}
)
public @interface ContainChar {
    String message() default "";

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

    //必須包含這個，否則報錯
    //javax.validation.ConstraintDefinitionException: HV000074: com.gbm.cloud.treasure.entity.zsk.ContainChar contains Constraint annotation, but does not contain a payload parameter.
    Class<? extends Payload>[] payload() default {};

    ContainCharEnum[] value() default {ContainCharEnum.CHINESE, ContainCharEnum.NUMBER, ContainCharEnum.LETTER, ContainCharEnum.SYMBOL};

}

/**
 * @Des
 * @Author yinkai
 * @Date 2022/3/1 14:38
 */
public class ContainCharValidator implements ConstraintValidator<ContainChar, String> {
    private String message;
    private ContainCharEnum[] values;
    private Class<?>[] groups;

    @Override
    public void initialize(ContainChar constraintAnnotation) {
        this.message = constraintAnnotation.message();
        this.values = constraintAnnotation.value();
        this.groups = constraintAnnotation.groups();
    }

    /**
     * @Des 遍歷，全都不包含才返回false
     * @Author yinkai
     * @Date 2022/3/1 13:49
     */
    public boolean isValid2(String value, ConstraintValidatorContext context) {
        for (ContainCharEnum containCharEnum : values) {
            switch (containCharEnum) {
                case CHINESE:
                    if (!CHINESE.getPattern().matcher(value).find()) {
                        //禁止默認消息返回
                        context.disableDefaultConstraintViolation();
                        //自定義返回消息
                        context.buildConstraintViolationWithTemplate(message+"不包含"+containCharEnum).addConstraintViolation();
                        return false;
                    }
                    break;
                case NUMBER:
                    if (!NUMBER.getPattern().matcher(value).find()) {
                        //禁止默認消息返回
                        context.disableDefaultConstraintViolation();
                        //自定義返回消息
                        context.buildConstraintViolationWithTemplate(message+"不包含"+containCharEnum).addConstraintViolation();
                        return false;
                    }
                    break;
                case SYMBOL:
                    if (!SYMBOL.getPattern().matcher(value).find()) {
                        //禁止默認消息返回
                        context.disableDefaultConstraintViolation();
                        //自定義返回消息
                        context.buildConstraintViolationWithTemplate(message+"不包含"+containCharEnum).addConstraintViolation();
                        return false;
                    }
                    break;
                case LETTER:
                    if (!LETTER.getPattern().matcher(value).find()) {
                        //禁止默認消息返回
                        context.disableDefaultConstraintViolation();
                        //自定義返回消息
                        context.buildConstraintViolationWithTemplate(message+"不包含"+containCharEnum).addConstraintViolation();
                        return false;
                    }
                    break;
                default:
                    break;
            }
        }
        return true;
    }


    //遍歷，全都不包含才返回false || 包含之外的就返回false
    // !(包含一個 && 只包含內部)
    @Override
    public boolean isValid(String value, ConstraintValidatorContext context) {
        HashSet<Boolean> booleans = new HashSet<>(2);
        StringBuilder stringBuilder = new StringBuilder();
        for (ContainCharEnum containCharEnum : values) {
            booleans.add(containCharEnum.getPattern().matcher(value).find());
            stringBuilder.append(containCharEnum);
        }
        //不包含true-->全都是false-->全都不包含
        if (!booleans.contains(Boolean.TRUE)) {
            //禁止默認消息返回
            context.disableDefaultConstraintViolation();
            //自定義返回消息
            context.buildConstraintViolationWithTemplate(message + value + "不包含 " + stringBuilder).addConstraintViolation();
            return false;
        }
        Set<ContainCharEnum> noFindSet = Arrays.stream(values()).filter(m -> !ArrayUtil.contains(values, m)).collect(Collectors.toSet());
        for (ContainCharEnum containCharEnum : noFindSet) {
            if (containCharEnum.getPattern().matcher(value).find()) {
                //禁止默認消息返回
                context.disableDefaultConstraintViolation();
                //自定義返回消息
                context.buildConstraintViolationWithTemplate(message + value + "不能包含 " + containCharEnum).addConstraintViolation();
                return false;
            }
        }
        return true;
    }
}

public enum ContainCharEnum {
    CHINESE(0, "中文",Pattern.compile("[\u4E00-\u9FA5|\\！|\\，|\\。|\\（|\\）|\\《|\\》|\\“|\\”|\\？|\\：|\\；|\\【|\\】]")),
    NUMBER(1, "數字", Pattern.compile("[0-9]")),
    LETTER(2, "字母",Pattern.compile(".*[a-zA-Z]+.*")),
    SYMBOL(3, "特殊符號",Pattern.compile(".*[`~!@#$%^&*()+=|{}':;',\\[\\]·.<>/?~！@#￥%……&*（）——+|{}【】‘；：”“’。，、？\\\\]+.*"));

    @EnumValue//標記數據庫存的值是code
    private Integer code;
    @JsonValue
    private String desc;
    private Pattern pattern;


    ContainCharEnum(Integer code, String desc,Pattern pattern) {
        this.code = code;
        this.desc = desc;
        this.pattern = pattern;
    }

    @Override
    public String toString() {
        return desc;
    }

    public int getValue() {
        return code;
    }

    public Pattern getPattern() {
        return pattern;
    }
}