java后端做正则验证

最新推荐文章于 2025-04-18 08:30:00 发布
原创 最新推荐文章于 2025-04-18 08:30:00 发布 · 2.1k 阅读 · 8 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文分享了在SpringBoot项目中，后端如何进行正则验证和非空判断的经验，涉及结合注解进行正则校验的方法，以及正则验证手机号的技巧，主要应用于数据新增和修改场景。

前言

在项目中,前端要对特殊字段做正则验证,后端也要对特殊的字段做正则验证和非空判断,在做正则的时候遇到了很多坑,今天就和大家分享。主要有以下几种方式：

环境

springboot1.5.x
jpa
java8

1.结合注解来正则来校验

正则表达式

package com.test.util;

/**
 * 描述：正则表达式格式
 */
public class RegexpProperties {
    public static final String MOBILE_PATTERN = "^$|0?(13|14|15|18|17)[0-9]{9}$";//手机号
    public static final String EMAIL_PATTERN = "^$|(\\w)+(\\.\\w+)*@(\\w)+((\\.\\w+)+)$";//邮箱
    public static final String FAX_PATTERN = "^$|(\\d{3,4}-)?\\d{7,8}$";//传值
    public static final String CREDIT_CODE_PATTERN = "^$|[a-zA-Z0-9]{18}$";//社会信用代码
}

实体类

package com.test.entity;

import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import com.fasterxml.jackson.annotation.JsonInclude;
import lombok.Getter;
import lombok.Setter;
import org.hibernate.annotations.DynamicInsert;
import org.hibernate.annotations.DynamicUpdate;
import org.hibernate.validator.constraints.Length;
import org.hibernate.validator.constraints.NotBlank;
import org.springframework.data.annotation.CreatedDate;
import org.springframework.data.annotation.LastModifiedBy;
import org.springframework.data.annotation.LastModifiedDate;
import org.springframework.data.jpa.domain.support.AuditingEntityListener;

import javax.persistence.*;
import javax.validation.constraints.Max;
import javax.validation.constraints.Min;
import javax.validation.constraints.NotNull;
import javax.validation.constraints.Pattern;
import java.math.BigDecimal;
import java.sql.Timestamp;
import java.util.Date;

@Table(name = "company")
@Entity
@Getter
@Setter
@DynamicInsert//新增时空字段不去插入values
@DynamicUpdate//只跟新变化的字段,结合merge方法使用
@JsonInclude(JsonInclude.Include.NON_NULL)
@EntityListeners({AuditingEntityListener.class})
@JsonIgnoreProperties({"createDate", "modifyDate"})
public class Company implements BaseEntity{
    //BaseEntity 是实现序列化的,这个类我就不放进来了

    @Id
    @GeneratedValue
    private Integer id;
    @NotBlank(message = "企业名称不能为空")
    private String name;
    @NotBlank(message = "社会信用代码不能为空")
    @Pattern(regexp = RegexpProperties.CREDIT_CODE_PATTERN, message = "社会信用代码格式有误")
    private String creditCode;
    private String contactName;
    @Pattern(regexp = RegexpProperties.MOBILE_PATTERN, message = "电话格式有误")
    private String contactPhone;
    @Length(min = 0, max = 50, message = "企业法人长度不得超过50个字符")
    private String corporation;
    @Pattern(regexp = RegexpProperties.EMAIL_PATTERN, message = "邮箱格式有误")
    private String email;
    @Pattern(regexp = RegexpProperties.FAX_PATTERN, message = "传真格式有误")
    private String fax;
    private String address;
    @Min(value = 0, message = "占地面积不能小于0")
    private Double floorArea;
    private Integer attentionLevel;
    private Integer industryId;
    private String industryName;
    private Timestamp establishedDate;
    @Min(value = 0, message = "请输入正确的员工人数")
    private Integer staffNum;
    private Boolean isDeleted = false;
    
    @CreatedDate
    private Date createDate;
    @LastModifiedBy
    private Integer modifier;
    @LastModifiedDate
    private Date modifyDate;
}

该方法在新增或者修改的时使用, 在controller层中,
在@RequestBody 前面加上@Validated 这种方能起作用.

1.2正则验证手机号的另外一种方式

package com.test.util;

import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.function.Function;
import java.util.function.Supplier;
import java.util.regex.Pattern;

/**
 * 请求参数验证器
 */
@Getter
public class Validator {
    public static final int SUCCESS = 0;
    public static final int ARGUMENT_NULL = 101;
    public static final int ARGUMENT_ERROR = 102;
    private static final Pattern EMAIL_PATTERN = Pattern.compile("^(\\w)+(\\.\\w+)*@(\\w)+((\\.\\w+)+)$");
    private static final Pattern MOBILE_PATTERN = Pattern.compile("1\\d{10}");
    public static final Pattern FAX_PATTERN = Pattern.compile("^(\\d{3,4}-)?\\d{7,8}$");
    private static final Pattern TEL_PATTERN = Pattern.compile("^((0\\d{2,3})-)(\\d{7,8})(-(\\d{3,}))?$");
    private static final Pattern SPACE_PATTERN = Pattern.compile("\\s*|\t|\r|\n", Pattern.CASE_INSENSITIVE);
    private static final Pattern DATE_PATTERN =
            Pattern.compile("^\\d{4}[./-]\\d{1,2}[./-]\\d{1,2}[\\d\\.\\:\\+ZT ]+$", Pattern.CASE_INSENSITIVE);
    private static final Pattern EMOJI_PATTERN =
            Pattern.compile("[\\uD800-\\uDBFF\\uDC00-\\uDFFF\\u2600-\\u27ff]",
                    Pattern.UNICODE_CASE | Pattern.CASE_INSENSITIVE);
    private static final Pattern IP_PATTERN =
            Pattern.compile("\\b((?!\\d\\d\\d)\\d+|1\\d\\d|2[0-4]\\d|25[0-5])"
                    + "\\.((?!\\d\\d\\d)\\d+|1\\d\\d|2[0-4]\\d|25[0-5])"
                    + "\\.((?!\\d\\d\\d)\\d+|1\\d\\d|2[0-4]\\d|25[0-5])"
                    + "\\.((?!\\d\\d\\d)\\d+|1\\d\\d|2[0-4]\\d|25[0-5])\\b");
    private static final Pattern ID_CARD_NO_PATTERN =
            Pattern.compile("^(^[1-9]\\d{7}((0\\d)|(1[0-2]))(([0|1|2]\\d)|3[0-1])\\d{3}$)|(^[1-9]\\d{5}[1-9]\\d{3}((0\\d)|(1[0-2]))(([0|1|2]\\d)|3[0-1])((\\d{4})|\\d{3}[Xx])$)$");
    private final List<Valid> expressions = new ArrayList<>();
    private int code;
    private String message;

    public static Validator create() {
        return new Validator();
    }

    public static Validator create(String appId) {
        return Validator.create().appId(appId);
    }

    public static boolean isNullOrEmpty(String string) {
        return string == null || string.length() == 0;
    }

    public static boolean isPhone(String phone) {
        return !isNullOrEmpty(phone) && (TEL_PATTERN.matcher(phone).matches() || isMobile(phone));
    }

    public static boolean isMobile(String mobile) {
        return hasMobile(mobile) && mobile.length() == 11;
    }

    public static boolean hasMobile(String content) {
        return !isNullOrEmpty(content) && MOBILE_PATTERN.matcher(content).find();
    }

    public static boolean hasFax(String content) {
        return !isNullOrEmpty(content) && FAX_PATTERN.matcher(content).find();
    }

    public static boolean isFax(String fax) {
        return hasFax(fax) && fax.length() >= 7;
    }

    public static boolean isEmail(String email) {
        return hasEmail(email) && email.length() > 4;
    }

    public static boolean hasEmail(String content) {
        return !isNullOrEmpty(content) && EMAIL_PATTERN.matcher(content).find();
    }

    public static boolean isIp(String ip) {
        return !isNullOrEmpty(ip) && IP_PATTERN.matcher(ip).matches();
    }

    public static boolean hasEmoji(String text) {
        return !isNullOrEmpty(text) && EMOJI_PATTERN.matcher(text).matches();
    }

    /**
     * 是否身份证号
     */
    public static boolean isIdCardNO(String text) {
        return !isNullOrEmpty(text)
                && text.length() >= 15
                && ID_CARD_NO_PATTERN.matcher(text).matches();
    }
    
    public boolean valid() {
        for (Valid valid : expressions) {
            if (!valid.getExpression().get()) {
                this.code = valid.getCode();
                this.message = valid.getAlter();
                return false;
            }
        }
        return true;
    }

    public <T> T convert(Function<Validator, T> function) {
        return function.apply(this);
    }

    public Validator valid(int code, String alter, Supplier<Boolean> expression) {
        Valid valid = new Valid(code, alter, expression);
        this.expressions.add(valid);
        return this;
    }

    public Validator validNull(String name, Supplier<Boolean> valid) {
        String alert = "缺少必要的请求参数:" + name;
        return valid(ARGUMENT_NULL, alert, valid);
    }

    public Validator validError(String name, Supplier<Boolean> valid) {
        String alert = "请求参数格式错误:" + name;
        return valid(ARGUMENT_ERROR, alert, valid);
    }

    public Validator appId(String appId) {
        return valid(ARGUMENT_NULL, "缺少参数 _appId", () -> !isNullOrEmpty(appId));
    }

    public Validator notNull(String name, Object value) {
        return validNull(name, () -> value != null);
    }

    public Validator notEmpty(String name, String value) {
        return validNull(name, () -> !isNullOrEmpty(value));
    }

    public Validator notEmpty(String name, Collection value) {
        return validNull(name, () -> value != null && value.size() > 0);
    }

    public Validator greaterThanZero(String name, Number value) {
        return greaterThan(name, value, 0);
    }

    public Validator greaterThan(String name, Number value, Number min) {
        String alert = String.format("%s 值必须大于 %s", name, min);
        return valid(ARGUMENT_ERROR, alert, () -> value != null && value.doubleValue() > min.doubleValue());
    }

    public Validator greaterThanOrEqual(String name, Number value, Number min) {
        String alert = String.format("%s 值必须大于等于 %s", name, min);
        return valid(ARGUMENT_ERROR, alert, () -> value != null && value.doubleValue() >= min.doubleValue());
    }

    public Validator lessThan(String name, Number value, Number max) {
        String alert = String.format("%s值必须小于 %s", name, max);
        return valid(ARGUMENT_ERROR, alert, () -> value != null && value.doubleValue() < max.doubleValue());
    }

    public Validator lessThanOrEqual(String name, Number value, Number max) {
        String alert = String.format("%s 值必须小于等于 %s", name, max);
        return valid(ARGUMENT_ERROR, alert, () -> value != null && value.doubleValue() <= max.doubleValue());
    }

    public Validator range(String name, Number value, Number min, Number max) {
        String alert = String.format("%s值必须在 [%s~%s] 之间", name, min, max);
        return valid(ARGUMENT_ERROR, alert, () -> value.doubleValue() >= min.doubleValue()
                && value.doubleValue() <= max.doubleValue());
    }

    public Validator regexMatches(String name, String value, String pattern) {
        String alert = String.format("%s必须满足格式：%s", name, pattern);
        return valid(ARGUMENT_ERROR, alert, () -> Pattern.matches(pattern, value));
    }

    public Validator phone(String phone) {
        String alert = String.format("电话号码格式不正确，tel:[%s]", phone);
        return valid(ARGUMENT_ERROR, alert, () -> isPhone(phone));
    }

    public Validator mobile(String mobile) {
        String alert = String.format("手机号码格式不正确，mobile:[%s]", mobile);
        return valid(ARGUMENT_ERROR, alert, () -> isMobile(mobile));
    }

    public Validator email(String email) {
        String alert = String.format("邮箱格式不正确，email:[%s]", email);
        return valid(ARGUMENT_ERROR, alert, () -> isEmail(email));
    }

    public Validator idCardNo(String idCardNo) {
        String alert = String.format("身份证号格式不正确，number:[%s]", idCardNo);
        return valid(ARGUMENT_ERROR, alert, () -> isIdCardNO(idCardNo));
    }

    public Validator ip(String ip) {
        String alert = "ip地址格式不正确";
        return valid(ARGUMENT_ERROR, alert, () -> isIp(ip));
    }

    @Getter
    @Setter
    @NoArgsConstructor
    @AllArgsConstructor
    private class Valid {
        private int code;
        private String alter;
        private Supplier<Boolean> expression;
    }
}

 /**
     * 验证手机号
     *
     * @param str 手机号
     * @return
     */
    public static boolean isMobile(String str) {
        boolean b = false;
        String s2 = "^$|0?(13|14|15|18|17)[0-9]{9}$";// 验证手机号
        if (Helpers.isNotNullAndEmpty(str)) {
            Pattern p = Pattern.compile(s2);
            Matcher m = p.matcher(str);
            b = m.matches();
        }
        return b;
    }

/**
     * 验证不为空
     *
     *
     */
  Validator validator = Validator.create()
                    .notEmpty("用户名", user.getUserName())
                    .notEmpty("密码", user.getPassword())
                    .notEmpty("验证码", user.getCode())
                    .mobile(user.getMobile());
java数据校验类_详解Java后端优雅验证参数合法性
weixin_31925745的博客
02-25 1423
1、首先创建一个测试实体类Person，并携带如上注解，其注解的作用描述在messagepackage com.clickpaas.pojo;import com.fasterxml.jackson.annotation.JsonFormat;import lombok.Data;import org.hibernate.validator.constraints.Length;import or...
各大厂800道Java后端经典面试题合集
weixin_70730532的博客
08-30 2299
另外，面试题答案的话，可以私信我， 希望大家都能找到自己理想的offer呀。
java后台正则验证
四戒哥特
09-12 745
package com.fsti.icop.util.regexp; import java.util.regex.Matcher; import java.util.regex.Pattern; public final class RegExpValidatorUtils { /** * 验证邮箱 *  * @param 待验证的字符串 * @return 如果
后台正则校验工具Java后端
weixin_44797037的博客
10-30 380
正则校验工具 RegularCheckUtil /** * 正则校验工具 * @param value 需校验的值 * @param regularCheckEnum 正则表达式 * @return */ public static Boolean checkValue(String value, RegularCheckEnum regu...
后端参数校验：通过正则表达式做参数校验
monica1_1的博客
12-19 5279
故事的开始： 前端进行校验，这个概念应该是没有问题的吧？比如：前端输入手机号的、链接的、邮箱地址的，我们是不是web端传入参数的时候，要对用户填入的格式进行校验。OK，这个概念大家都懂。但是，一般情况下，后端我们也要进行校验。 为什么？后端为什么校验？ 我目前听到的两种说法：1、“客户端传来的参数都是不可信的”我大boss说的，具体原因不知道，就是说是行业的一种说法；2、“后端进行参数校验，...
java后端校验
txwy12的博客
07-26 2072
当我们想提供可靠的 API 接口，对参数的校验，以保证最终数据入库的正确性，是 必不可少 的活。比如下图就是 我们一个项目里 新增一个菜单校验 参数的函数，写了一大堆的 if else 进行校验，非常的不优雅，比起枯燥的 CRUD 来说，参数校验更是枯燥。这只是一个创建菜单的校验，只需要判断菜单，菜单 url 以及菜单的父类 id 是否为空，上级菜单是否挂载正确，这样已经消耗掉了 30，40 行代码了，更不要说，管理后台这种参数贼多的接口。估计要写几百行校验代码了。
Java String类正则操作示例
08-25
Java String类正则操作示例主要介绍了Java String类正则操作，结合实例形式分析了java针对数字的正则验证、过滤及邮箱正则验证相关操作技巧。下面将详细说明标题和描述中所说的知识点。 一、应用正则表达式 应用...
java后端手机号正则校验
07-23
在Java后端进行手机号码的正则校验通常是为了验证输入是否符合中国大陆手机号的基本格式。中国大陆手机号一般是由11位数字组成，可以分为两种格式： 1. 13、14、15、17、18开头的移动电话号码：前三位固定，剩余七...
汽车VIN码校验工具类-Java
03-31
VIN码校验工具类-Java语言
后端常规正则效验
羽
05-27 598
【账户】 长度3到15个中文字符、英文大小写字母、数字、下划线类型的字符串 （数字、下划线不能开头） ^([\u4e00-\u9fa5]|[a-zA-Z])([\u4e00-\u9fa5]|[a-zA-Z0-9_]){2,14}$ 【名称、昵称等】 不超过20位的中文、英文（大小写）字符串 ^([\u4e00-\u9fa5]|[a-zA-Z]){1,20} 【企业名称、开户银行等】 不超过30位的任何类型字符串 .{0,30} 【电话号码】 中国大陆：11位纯数字，并且只能以13(0-9.
java正则后台校验
qq_40614968的博客
09-17 492
Pattern与Matcher一起合作.Matcher类提供了对正则表达式的分组支持,以及对正则表达式的多次匹配支持. 单独用Pattern只能使用Pattern.matches(String regex,CharSequence input)一种最基础最简单的匹配。
后端参数校验
Little___Turtle的博客
01-30 2044
快速入门版
java 的正则表达式校验
qq_44296193的博客
07-25 306
1、使用步骤： 1、String reg = "正则表达式"; 2、String empName = "需要校验的字符串"; 3、empName.matches(reg ); true：匹配。 false：不匹配。 2、示例： @Controller("employeeController") public class EmployeeController { @Autowired ...
后端---正则表达式基础简介
Nagile-zhou博客
10-14 1645
正则表达式  正则表达式(Regular Expression)是一种文本模式，包括普通字符（例如，a 到 z 之间的字母）和特殊字符（称为"元字符"）。 正则表达式使用单个字符串来描述、匹配一系列匹配某个句法规则的字符串。 正则表达式是繁琐的，但它是强大的，学会之后的应用会让你除了提高效率外，会给你带来绝对的成就感。只要认真阅读本教程，加上应用的时候进行一定的参考，掌握正则表达式不是问题。...
Java后端正则表达式使用
最新发布
weixin_52578852的博客
04-18 1035
正则表达式(Regular Expression)是处理字符串的强大工具，Java提供了强大的正则表达式支持。下面详细介绍Java后端开发中正则表达式的使用方法。
java后台常用正则表达式
ShiHe_
08-08 4236
只能输入数字："^[0-9]*$"。 只能输入n位的数字："^\d{n}$"。 只能输入至少n位的数字："^\d{n,}$"。 只能输入m~n位的数字：。"^\d{m,n}$" 只能输入零和非零开头的数字："^(0|[1-9][0-9]*)$"。 只能输入有两位小数的正实数："^[0-9]+(.[0-9]{2})?$"。 只能输入有1~3位小数的正实数："^[0-9]+(.[0-9]{
java 正则表达式验证
2301_79987255的博客
04-26 3174
@param 待验证的字符串* @return 如果是符合格式的字符串,返回true,否则为false*/\\d{6,8}$”;/*** 验证输入密码条件(字符与数据同时出现)* @param 待验证的字符串* @return 如果是符合格式的字符串,返回true,否则为false*//*** 验证输入密码长度 (6-18位)* @param 待验证的字符串* @return 如果是符合格式的字符串,返回true,否则为false*//**
java校验正整数正则
weixin_36024829的博客
08-05 789
Java 校验正整数的正则表达式实现指南 在开发过程中，我们常常需要验证输入的有效性。特别是在处理用户输入时，校验数据的格式是必不可少的一环。本文将指导你如何使用 Java 通过正则表达式来校验一个正整数。对于刚入行的小白来说，学习正则表达式的使用可能有些挑战，但掌握了它，你将会在数据验证上获得极大的便利。 整体流程 解决...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值