实体类的非空等校验

Bertha 。 2023-01-10 11:55 167阅读 0赞

开发中经常需要校验前端传来的对象属性是否为空等,整理出一份文档

1.添加依赖

<dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-validation</artifactId>
 </dependency>

2.实体类添加非空注解

import lombok.Data;
    import org.hibernate.validator.constraints.Length;
    import javax.validation.constraints.Email;
    import javax.validation.constraints.NotEmpty;
    import javax.validation.constraints.Pattern;
    
    @Data
    public class UserInfo {
        @NotEmpty(message = "用户名不能为空")
        private String username;
    
        @NotEmpty(message = "密码不能为空")
        @Length(min = 4,max = 32)
        private String password;
    
        @NotEmpty(message = "邮箱不能为空")
        @Email(message = "邮箱格式不正确")
        private String email;
    
        @NotEmpty(message = "手机号码不能为空")
        @Pattern(regexp = "1[3|4|5|7|8][0-9]\\d{8}",message = "手机号码格式不正确")
        private String phone;
    }

3.在controller中使用

@PostMapping("/save")
        public R saveUser(@Validated @RequestBody UserInfo userInfo) {
            userService.save(userInfo);
            return R.ok();
        }

也可以就在controller中捕获了进行处理,也可以全局处理

@PostMapping("/save")
 public ModelAndView save(@Validated UserInfo userInfo, BindingResult bindingResult, Map<String, Object> map) {
 if (bindingResult.hasErrors()) {
 map.put("msg", bindingResult.getFieldError().getDefaultMessage());
 map.put("url", "/sell/seller/user/index");
 return new ModelAndView("common/error", map);
 }
 
 // 业务逻辑处理
 
 map.put("url", "/sell/seller/user/list");
 return new ModelAndView("common/success", map);
 }

4.编写异常处理器全局处理

/**
     * 自定义异常
     */
    public class RRException extends RuntimeException {
    	private static final long serialVersionUID = 1L;
    	
        private String msg;
        private int code = 500;
        
        public RRException(String msg) {
    		super(msg);
    		this.msg = msg;
    	}
    	
    	public RRException(String msg, Throwable e) {
    		super(msg, e);
    		this.msg = msg;
    	}
    	
    	public RRException(String msg, int code) {
    		super(msg);
    		this.msg = msg;
    		this.code = code;
    	}
    	
    	public RRException(String msg, int code, Throwable e) {
    		super(msg, e);
    		this.msg = msg;
    		this.code = code;
    	}
    
    	public RRException(ResultEnum resultEnum) {
    		super(resultEnum.getMessage());
    		this.msg = resultEnum.getMessage();
    		this.code = resultEnum.getCode();
    	}
    
    	public String getMsg() {
    		return msg;
    	}
    
    	public void setMsg(String msg) {
    		this.msg = msg;
    	}
    
    	public int getCode() {
    		return code;
    	}
    
    	public void setCode(int code) {
    		this.code = code;
    	}
    	
    }

import cc.sunni.sell.utils.R;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.dao.DataIntegrityViolationException;
    import org.springframework.dao.DuplicateKeyException;
    import org.springframework.jdbc.BadSqlGrammarException;
    import org.springframework.validation.BindException;
    import org.springframework.validation.FieldError;
    import org.springframework.web.bind.MethodArgumentNotValidException;
    import org.springframework.web.bind.annotation.ExceptionHandler;
    import org.springframework.web.bind.annotation.RestControllerAdvice;
    import org.springframework.web.method.annotation.MethodArgumentTypeMismatchException;
    import org.springframework.web.servlet.NoHandlerFoundException;
    
    import java.sql.SQLException;
    
    /**
     * 异常处理器
     */
    @RestControllerAdvice
    @Slf4j
    public class RRExceptionHandler {
    
        /**
         * 处理自定义异常
         */
        @ExceptionHandler(RRException.class)
        public R error(RRException e) {
            R r = new R();
            r.put("code", e.getCode());
            r.put("msg", e.getMessage());
            r.put("success", false);
            return r;
        }
    
        @ExceptionHandler(NoHandlerFoundException.class)
        public R error(NoHandlerFoundException e) {
            log.error(e.getMessage(), e);
            return R.error(404, "路径不存在，请检查路径是否正确");
        }
    
        /**
         * 参数合法性校验异常
         */
        @ExceptionHandler(MethodArgumentNotValidException.class)
        public R error(MethodArgumentNotValidException e) {
            FieldError fieldError = e.getBindingResult().getFieldError();
            assert fieldError != null;
            log.error("参数合法性校验异常---{}[{}]", fieldError.getField(), fieldError.getDefaultMessage());
            return R.error(fieldError.getDefaultMessage());
        }
    
        /**
         * 参数合法性校验异常-类型不匹配
         */
        @ExceptionHandler(MethodArgumentTypeMismatchException.class)
        public R error(MethodArgumentTypeMismatchException e) {
            log.error("参数合法性校验异常-类型不匹配---{}", e.getMessage());
            return R.error(e.getMessage());
        }
    
        /**
         * 参数绑定异常
         */
        @ExceptionHandler(BindException.class)
        public R error(BindException e) {
    		FieldError fieldError = e.getBindingResult().getFieldError();
    		assert fieldError != null;
            log.error("参数绑定异常---{}[{}]", fieldError.getField(), fieldError.getDefaultMessage());
    		return R.error(fieldError.getDefaultMessage());
        }
    
        /**
         * Sql语法错误
         */
        @ExceptionHandler(BadSqlGrammarException.class)
        public R error(BadSqlGrammarException e) {
            log.error(e.getMessage());
            return R.error("sql语法错误");
        }
    
        /**
         * Sql语法错误
         */
        @ExceptionHandler(SQLException.class)
        public R error(SQLException e) {
            log.error(e.getMessage());
            return R.error("sql语法错误");
        }
    
        @ExceptionHandler(DataIntegrityViolationException.class)
        public R error(DataIntegrityViolationException e) {
            log.error(e.getMessage());
            return R.error("sql语法错误");
        }
    
        @ExceptionHandler(DuplicateKeyException.class)
        public R error(DuplicateKeyException e) {
            log.error(e.getMessage(), e);
            return R.error("数据库中已存在该记录");
        }
    
        @ExceptionHandler(Exception.class)
        public R error(Exception e) {
            log.error(e.getMessage(), e);
            return R.error();
        }
    }

通过以上操作就能对接收到的参数进行校验了. 还可以自定义注解,添加自定义的校验逻辑

以验证身份证号码为例,自定义注解

import javax.validation.Constraint;
 import javax.validation.Payload;
 import java.lang.annotation.Documented;
 import java.lang.annotation.Retention;
 import java.lang.annotation.Target;
 
 import static java.lang.annotation.ElementType.*;
 import static java.lang.annotation.RetentionPolicy.RUNTIME;
 
 /**
 * @author jl
 * @since 2021/1/24 10:53
 */
 @Target({ METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER })
 @Retention(RUNTIME)
 @Documented
 @Constraint(validatedBy = {IsIdCardValidator.class })
 public @interface IsIdCard {
 
 boolean required() default true;
 
 String message() default "身份证号码格式错误";
 
 Class<?>[] groups() default { };
 
 Class<? extends Payload>[] payload() default { };
 }

自定义注解的校验规则

import cc.sunni.sell.utils.RegexUtils;
 import org.apache.commons.lang3.StringUtils;
 
 import javax.validation.ConstraintValidator;
 import javax.validation.ConstraintValidatorContext;
 
 /**
 * @author jl
 * @since 2021/1/24 10:55
 */
 public class IsIdCardValidator implements ConstraintValidator<IsIdCard, String> {
 
 private boolean required = false;
 
 @Override
 public void initialize(IsIdCard constraintAnnotation) {
 required = constraintAnnotation.required();
 }
 
 @Override
 public boolean isValid(String value, ConstraintValidatorContext constraintValidatorContext) {
 if(required) {
 return RegexUtils.checkMobile(value);
 }else {
 return StringUtils.isEmpty(value) || RegexUtils.checkIdCard(value);
 
 }
 }
 }

附上校验工具类

import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
 /**
 * @author jiangli
 * @since 2019/6/4 09:48
 */
 public class RegexUtils {
 
 	/**
 	 * 验证Email
 	 * 
 	 * @param email
 	 * email地址，格式：zhangsan@zuidaima.com，zhangsan@xxx.com.cn，
 	 * xxx代表邮件服务商
 	 * @return 验证成功返回true，验证失败返回false
 	 */
 	public static boolean checkEmail(String email) {
 		String regex = "\\w+@\\w+\\.[a-z]+(\\.[a-z]+)?";
 		return Pattern.matches(regex, email);
 	}
 
 	/**
 	 * 验证身份证号码
 	 * 
 	 * @param idCard
 	 * 居民身份证号码15位或18位，最后一位可能是数字或字母
 	 * @return 验证成功返回true，验证失败返回false
 	 */
 	public static boolean checkIdCard(String idCard) {
 		String regex = "[1-9]\\d{13,16}[a-zA-Z0-9]{1}";
 		return Pattern.matches(regex, idCard);
 	}
 
 	/**
 	 * 验证手机号码（支持国际格式，+86135xxxx...（中国内地），+00852137xxxx...（中国香港））
 	 * 
 	 * @param mobile
 	 * 移动、联通、电信运营商的号码段
 	 * 
 	 * 移动的号段：134(0-8)、135、136、137、138、139、147（预计用于TD上网卡）
 	 * 、150、151、152、157（TD专用）、158、159、187（未启用）、188（TD专用） 177 170 166
 	 * 开头
 	 * 
 	 * 
 	 * 联通的号段：130、131、132、155、156（世界风专用）、185（未启用）、186（3g）
 	 * 
 	 * 
 	 * 电信的号段：133、153、180（未启用）、189
 	 * 
 	 * @return 验证成功返回true，验证失败返回false
 	 */
 	public static boolean checkMobile(String mobile) {
 		String regex = "^(13[0-9]|14[579]|15[0-3,5-9]|16[6]|17[0135678]|18[0-9]|19[89])\\d{8}$";
 		return Pattern.matches(regex, mobile);
 	}
 
 	/**
 	 * 验证固定电话号码
 	 * 
 	 * @param phone
 	 * 电话号码，格式：国家（地区）电话代码 + 区号（城市代码） + 电话号码，如：+8602085588447
 	 * 
 	 * 国家（地区） 代码 ：标识电话号码的国家（地区）的标准国家（地区）代码。它包含从 0 到 9
 	 * 的一位或多位数字， 数字之后是空格分隔的国家（地区）代码。
 	 * 
 	 * 
 	 * 区号（城市代码）：这可能包含一个或多个从 0 到 9 的数字，地区或城市代码放在圆括号——
 	 * 对不使用地区或城市代码的国家（地区），则省略该组件。
 	 * 
 	 * 
 	 * 电话号码：这包含从 0 到 9 的一个或多个数字
 	 * 
 	 * @return 验证成功返回true，验证失败返回false
 	 */
 	public static boolean checkPhone(String phone) {
 		String regex = "(\\+\\d+)?(\\d{3,4}\\-?)?\\d{7,8}$";
 		return Pattern.matches(regex, phone);
 	}
 
 	/**
 	 * 验证整数（正整数和负整数）
 	 * 
 	 * @param digit
 	 * 一位或多位0-9之间的整数
 	 * @return 验证成功返回true，验证失败返回false
 	 */
 	public static boolean checkDigit(String digit) {
 		String regex = "\\-?[1-9]\\d+";
 		return Pattern.matches(regex, digit);
 	}
 
 	/**
 	 * 验证整数和浮点数（正负整数和正负浮点数）
 	 * 
 	 * @param decimals
 	 * 一位或多位0-9之间的浮点数，如：1.23，233.30
 	 * @return 验证成功返回true，验证失败返回false
 	 */
 	public static boolean checkDecimals(String decimals) {
 		String regex = "\\-?[1-9]\\d+(\\.\\d+)?";
 		return Pattern.matches(regex, decimals);
 	}
 
 	/**
 	 * 验证空白字符
 	 * 
 	 * @param blankSpace
 	 * 空白字符，包括：空格、\t、\n、\r、\f、\x0B
 	 * @return 验证成功返回true，验证失败返回false
 	 */
 	public static boolean checkBlankSpace(String blankSpace) {
 		String regex = "\\s+";
 		return Pattern.matches(regex, blankSpace);
 	}
 
 	/**
 	 * 验证中文
 	 * 
 	 * @param chinese
 	 * 中文字符
 	 * @return 验证成功返回true，验证失败返回false
 	 */
 	public static boolean checkChinese(String chinese) {
 		String regex = "^[\u4E00-\u9FA5]+$";
 		return Pattern.matches(regex, chinese);
 	}
 
 	/**
 	 * 验证日期（年月日）
 	 * 
 	 * @param birthday
 	 * 日期，格式：1992-09-03，或1992.09.03
 	 * @return 验证成功返回true，验证失败返回false
 	 */
 	public static boolean checkBirthday(String birthday) {
 		String regex = "[1-9]{4}([-./])\\d{1,2}\\1\\d{1,2}";
 		return Pattern.matches(regex, birthday);
 	}
 
 	/**
 	 * 验证URL地址
 	 * 
 	 * @param url
 	 * 格式：http://blog.csdn.net:80/xyang81/article/details/7705960? 或
 	 * http://www.csdn.net:80
 	 * @return 验证成功返回true，验证失败返回false
 	 */
 	public static boolean checkURL(String url) {
 		String regex = "(https?://(w{3}\\.)?)?\\w+\\.\\w+(\\.[a-zA-Z]+)*(:\\d{1,5})?(/\\w*)*(\\??(.+=.*)?(&.+=.*)?)?";
 		return Pattern.matches(regex, url);
 	}
 
 	/**
 	 * <pre>
 	 * 获取网址 URL 的一级域
 	 * </pre>
 	 * 
 	 * @param url
 	 * @return
 	 */
 	public static String getDomain(String url) {
 		Pattern p = Pattern.compile("(?<=http://|\\.)[^.]*?\\.(com|cn|net|org|biz|info|cc|tv)",
 				Pattern.CASE_INSENSITIVE);
 		// 获取完整的域名
 		// Pattern
 		// p=Pattern.compile("[^//]*?\\.(com|cn|net|org|biz|info|cc|tv)",
 		// Pattern.CASE_INSENSITIVE);
 		Matcher matcher = p.matcher(url);
 		matcher.find();
 		return matcher.group();
 	}
 
 	/**
 	 * 匹配中国邮政编码
 	 * 
 	 * @param postcode
 	 * 邮政编码
 	 * @return 验证成功返回true，验证失败返回false
 	 */
 	public static boolean checkPostcode(String postcode) {
 		String regex = "[1-9]\\d{5}";
 		return Pattern.matches(regex, postcode);
 	}
 
 	/**
 	 * 匹配IP地址(简单匹配，格式，如：192.168.1.1，127.0.0.1，没有匹配IP段的大小)
 	 * 
 	 * @param ipAddress
 	 * IPv4标准地址
 	 * @return 验证成功返回true，验证失败返回false
 	 */
 	public static boolean checkIpAddress(String ipAddress) {
 		String regex = "[1-9](\\d{1,2})?\\.(0|([1-9](\\d{1,2})?))\\.(0|([1-9](\\d{1,2})?))\\.(0|([1-9](\\d{1,2})?))";
 		return Pattern.matches(regex, ipAddress);
 	}
 }

使用

@NotEmpty(message = "身份证号码不能为空")
        @IsIdCard //自定义校验注解
        private String idCard;

![20210124111656576.png][]![20210124111717581.png][]

[20210124111656576.png]: https://img-blog.csdnimg.cn/20210124111656576.png
[20210124111717581.png]: /images/20221119/b2a74893e5b64e27ab6c5c4f90c29032.png