实体类的非空等校验

最新推荐文章于 2023-05-25 17:41:14 发布
最新推荐文章于 2023-05-25 17:41:14 发布
阅读量2.6k 收藏 13
点赞数 4
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39940205/article/details/113070732
版权

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

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
	 *            移动、联通、电信运营商的号码段
	 *            <p>
	 *            移动的号段：134(0-8)、135、136、137、138、139、147（预计用于TD上网卡）
	 *            、150、151、152、157（TD专用）、158、159、187（未启用）、188（TD专用） 177 170 166
	 *            开头
	 *            </p>
	 *            <p>
	 *            联通的号段：130、131、132、155、156（世界风专用）、185（未启用）、186（3g）
	 *            </p>
	 *            <p>
	 *            电信的号段：133、153、180（未启用）、189
	 *            </p>
	 * @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
	 *            <p>
	 *            <b>国家（地区） 代码 ：</b>标识电话号码的国家（地区）的标准国家（地区）代码。它包含从 0 到 9
	 *            的一位或多位数字， 数字之后是空格分隔的国家（地区）代码。
	 *            </p>
	 *            <p>
	 *            <b>区号（城市代码）：</b>这可能包含一个或多个从 0 到 9 的数字，地区或城市代码放在圆括号——
	 *            对不使用地区或城市代码的国家（地区），则省略该组件。
	 *            </p>
	 *            <p>
	 *            <b>电话号码：</b>这包含从 0 到 9 的一个或多个数字
	 *            </p>
	 * @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;

阿花落知多少
关注
  • 4
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java实体非空判断_java基础之----非空判断
weixin_42351520的博客
02-26 875
大家好，第一次写博客，一直想写博客，用于自我总结，也用于帮助新同学成长。平常我们开发的时候，用到很多非空判断，但是很多同学用到的地方不是很准确，这里，我把自己平时遇到的坑跟大家说说。我废话不多，只想写干货，希望大家喜欢。情景一：字符串的非空判断对于字符串的判断，比如字符串str,其实我们很多同学直接 str != null 去判断，这样是极其不准确的，因为str ==" "的时候，我们这行判断就没...
Framework.Validate通用实体校验组件
11-03
在实际使用中，开发者可以通过引入"MS.Framework.Validate"库，定义实体类，并在实体属性上添加对应的校验注解，然后调用校验方法进行验证。如果所有校验规则都通过，那么数据就可以安全地保存或处理；如果有任何一...
判断实体类对象不等于空
技术老鸟
07-02 1496
判断实体类对象不等于空
java实体类属性非空判断
sunshine8080的博客
04-29 5897
1.当后端接口一个实体类之前未进行非空判断时，如果我们对其属性值一个一个进行 非空判断显得冗余和重复，如下： public R addFileInfo(@RequestBody User user){ if(StringUtils.isBlank(user.getId())){ return R.error("id不能为空"); } ...
java校验实体类只校验非空的字段
ss_Tina的博客
03-30 768
Validator 校验跳过空字段的校验。第三方调用接口，传参。某些值只接收固定的枚举值，为空的字段就不做判断。 自定义校验，校验字段只能是具体的枚举值，当有字段为空的时候也会被校验住，这时可以在工具类增加判断，跳过对空字段校验的错误信息的处理。 校验代码: 返回了错误信息表示校验不过，空字段的错误信息不会拼在后面，因此跳过了空字段的校验
spring boot 实体类字段非空校验
zzp1224的博客
12-14 6761
方案一： //手机号 if(StringUtils.isEmpty(user.getMobile())){ return Result.fail("添加用户时，手机号不能为空"); } //角色 if(CollectionUtils.isEmpty(user.getRoles())) { return Result.fail("添加用户时，角色信息不能为空"); } 方案二： 1、实体类注解添加 /* @NotNull 验证对象是否不为null, 无法查检长
java 实体类属性过多 利用反射机制进行非空判断
qq_35011890的博客
06-10 597
在工作业务中 经常遇到需要上传属性30种的实体类，针对于其中必填项进行非空判断，大量属性，使用StringUtils进行非空判断，代码冗余， 且毫无复用性，因此利用反射机制获取相应的属性 循环每个属性，再通过Field获得属性值来进行判断 参考...
Spring boot进行参数校验的方法实例详解
08-27
我们需要对 Controller 层传过来的参数进行一些基本的校验，如非空、整数值的范围、字符串的长度、日期、邮箱等等。Spring 框架提供了多种方法来实现参数校验，本文将介绍其中的一些方法实例。 使用 JSR-303 Bean ...
注解+AOP优雅的实现java项目的接口参数校验(含源码)
01-17
基于Spring boot + maven，以注解+AOP方式实现的java后端项目接口参数校验框架。迄今为止使用最简单、最容易理解的参数校验方案。博客地址：https://blog.csdn.net/weixin_42686388/article/details/104009771
Spring Boot实现通用的接口参数校验
08-27
通过自定义注解实现了参数校验，解决了实体类上添加注解的限制，实现了方法级别的参数校验。 知识点： 1. Spring Boot 实现 AOP AOP（Aspect-Oriented Programming）是一种编程范式，它将关注点分离的思想应用于...
SpringBoot2.X Kotlin系列之数据校验和异常处理详解
08-26
例如，在`StudentForm`实体类中，我们使用了`@NotNull`、`@NotBlank`、`@NotEmpty`、`@Email`等注解对字段进行约束。`@NotNull`检查对象是否为null，`@NotBlank`确保字符串非空且不包含空白字符，`@NotEmpty`用于...
java实体非空判断
sinat_36256286的博客
02-01 2961
java实体非空判断 判断实体里的所有属性值，只要有一个不为空，则返回true，都为空则返回false。 package com.test.utils; import org.apache.commons.lang.StringUtils; import java.lang.reflect.Field; import java.lang.reflect.Method; public class EntityIsNotEmpty { /** * 判断实体对象是否为空 * @
Java —— 实体属性入参非空校验
看了就会暴富的博客！
06-28 5227
问题 在接口入参为实体时，实体的有些属性是必传的，不能为空，如何在controller层校验，对非法入参进行拦截呢？ 解决 使用validation包中的注解在实体中进行配置。 import javax.validation.constraints.*; 示例 以key、value不能为空举例。 实体定义 在不能为空的属性上增加@NotNull注解 import lombok.Builder; import lombok.Data; import javax.validation.
Java 实体类中对字段添加非空注解判断传入的参数是否为空
热门推荐
weixin_47056195的博客
04-01 1万+
pom文件添加依赖 <dependency> <groupId>org.hibernate.validator</groupId> <artifactId>hibernate-validator</artifactId> <version>6.0.17.Final</version> </dependency> 1. 创建实体类并且添加非空注解 在此说明 lomboo
jsr303 参考表
weixin_34321753的博客
03-06 214
下面是主要的验证注解及说明： 注解 适用的数据类型 说明 @AssertFalse Boolean, boolean 验证注解的元素值是false @AssertTrue Boolean, boolean 验证注解的元素值是true @DecimalMax（value...
优雅的判断实体不为null
m0_47905795的博客
05-25 3593
Optional类是Java 8中新增加的一个类，它可以用来解决空指针异常问题，同时也可以用来优雅地判断一个实体对象是否为null。Assert是JUnit框架中提供的一种断言方式，它可以用来判断某个条件是否为true，如果不为true则会抛出异常。这是最简单也是最普遍的判断方式，只需使用if语句判断实体对象是否为null，如果不为null，则执行相应处理逻辑。在实际开发中，使用哪种方式来判断实体对象是否为null，要根据具体情况来决定。，则可以使用Assert断言来判断。
@RequestBody入参字段判空校验,后端@Valid参数校验，内部类参数校验
L9009121314的博客
01-04 5288
@RequestBody入参字段判空校验,后端@Valid参数校验，内部类参数判空校验
判断实体类对象所有参数不能为空
Hearthuhu的博客
04-03 715
实体类对象参数不为空
validation校验包常用校验注解@NotEmpty，@NotBlank，@NotNull等注解
普通人一枚
07-21 8879
validation校验包常用校验注解@NotEmpty，@NotBlank，@NotNull等注解
easyexcel导入数据非空校验
最新发布
10-12
可以通过EasyExcel提供的@NotEmpty注解来实现非空校验。具体步骤如下： 1. 在实体类中添加@NotEmpty注解，如下所示： ``` public class User { @NotEmpty(message = "用户名不能为空") private String username; @NotEmpty(message = "密码不能为空") private String password; // 省略getter和setter方法 } ``` 2. 在读取Excel文件时，使用EasyExcel提供的read方法，并传入自定义的校验器，如下所示： ``` public void readExcel() { String fileName = "test.xlsx"; InputStream inputStream = null; try { inputStream = new FileInputStream(fileName); EasyExcel.read(inputStream, User.class, new UserValidator()).sheet().doRead(); } catch (FileNotFoundException e) { e.printStackTrace(); } finally { if (inputStream != null) { try { inputStream.close(); } catch (IOException e) { e.printStackTrace(); } } } } public class UserValidator extends AbstractSheetReadValidator<User> { @Override public void customValidate(User user, AnalysisContext context) { if (StringUtils.isEmpty(user.getUsername())) { String errorMsg = "第" + context.readRowHolder().getRowIndex() + "行用户名不能为空"; addErrorMsg(errorMsg); } if (StringUtils.isEmpty(user.getPassword())) { String errorMsg = "第" + context.readRowHolder().getRowIndex() + "行密码不能为空"; addErrorMsg(errorMsg); } } } ``` 在自定义的校验器中，通过判断实体类中的属性是否为空来进行校验，并通过addErrorMsg方法将错误信息添加到错误列表中。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值