1、正则表达式验证-工具类

  1. @Slf4j
  2. public class RegValidateUtils {
  4.     //匹配标准通配符
  5.     private static final String REGEXP = "\\$\\{\\w{0,}[-+]{0,}\\d{0,}\\}";
  7.     /**
  8.      * 解析字符串中yyyymmdd格式内容
  9.      */
  10.     private static final String PARSE_DATE = "[1-9]\\d{3}(0[1-9]|1[0-2])(0[1-9]|[1-2][0-9]|3[0-1])";
  12.     /**
  13.      * 匹配yyyymmdd格式
  14.      */
  15.     private static final String MATCHER_DATE = "^[2]\\d{3}[0|1][0-9][0-3]\\d$";
  17.     //标准日期格式yyyymmdd|yyyymm
  18.     private static final String STANDARDDATE = "^yyyymmdd$|^yyyymm$";
  20.     //匹配日期格式串yyyymm-+n/yyyymmdd-+n
  21.     private static final String DATAPARTERN = "^yyyymmdd[-+]\\d{1}$|^yyyymm[-+]\\d{1}$";
  23.     //匹配周时间格式，如：201911(2019年第11周)
  24.     private static final String WEEK = "^week$";
  26.     //匹配版本和adcode
  27.     private static final String DATAVERSION = "^data_version$";
  29.     private static final String ADCODE = "^adcode$";
  30.     /**
  31.      * 获取字符串中数字
  32.      */
  33.     private static final String NUMBER ="[^0-9]";
  35.     private static final String ISNUMBER = "^-?\\d+(\\.\\d+)?$";
  37.     /**
  38.      * 获取字符串中数字英文字母
  39.      */
  40.     private static final String NUMBERLETTER ="[^a-zA-Z0-9]";
  42.     //手机号码
  43.     public static final String REGEX_MOBILE = "^((17[0-9])|(14[0-9])|(13[0-9])|(15[^4,\\D])|(18[0,5-9]))\\d{8}$";
  44.     //邮箱
  45.     public static final String REGEX_EMAIL = "^([a-z0-9A-Z]+[-|\\.]?)+[a-z0-9A-Z]@([a-z0-9A-Z]+(-[a-z0-9A-Z]+)?\\.)+[a-zA-Z]{2,}$";
  46.     //url
  47.     public static final String REGEX_URL = "http(s)?://.*";
  48.     //日期
  49.     public static final String REGEX_SIMPLE_DATE1 = "\\d{4}-\\d{2}-\\d{2}";
  51.     /**
  52.      * 字符串匹配
  53.      * @param regex
  54.      * @param str
  55.      * @return
  56.      */
  57.     public static boolean match(String regex, String str) {
  58.         Pattern pattern = Pattern.compile(regex);
  59.         Matcher matcher = pattern.matcher(str);
  60.         return matcher.find();
  61.     }
  63.     /**
  64.      * 判断通配符中是否存在非法字符
  65.      * @param content
  66.      * @return
  67.      */
  68.     public static boolean validateLegalStr(String content) {
  70.         Pattern r = Pattern.compile(REGEXP);
  71.         Matcher m = r.matcher(content);
  73.         while(m.find()) {
  74.             if (!isDateFormat(m.group().replace("${","}").replace("}",""))){
  75.                 SQLParserUtils.catchError("通配符不合法");
  76.                 return false;
  77.             }
  78.         }
  80.         return true;
  81.     }
  83.     /**
  84.      * 校验通配符中字符格式是否为准确的日期格式
  85.      * @param content
  86.      */
  87.     public static boolean isDateFormat(String content){
  89.         if (match(STANDARDDATE,content)){
  90.             return true;
  91.         }
  92.         if (match(DATAPARTERN,content)){
  93.             return true;
  94.         }
  95.         if (match(DATAVERSION,content)){
  96.             return true;
  97.         }
  98.         if (match(ADCODE,content)){
  99.             return true;
  100.         }
  101.         if (match(WEEK,content)) {
  102.             return true;
  103.         }
  104.         return false;
  105.     }
  107.     /**
  108.      * 解析指标ID
  109.      * @param exp
  110.      * @return
  111.      */
  112.     public static List<String> getExpParse(String exp) {
  113.         if (Objects.isNull(exp)){
  114.             return null;
  115.         }
  116.         Pattern r = Pattern.compile(REGEXP);
  117.         Matcher m = r.matcher(exp);
  118.         List<String> indexs = new ArrayList<>();
  119.         while (m.find()) {
  120.             indexs.add(m.group().replace("${","}").replace("}",""));
  121.         }
  123.         return indexs;
  124.     }
  126.     /**
  127.      * 解析字符串中yyyymmdd格式内容
  128.      * @param date
  129.      * @return
  130.      */
  131.     public static String getDateParse(String date) {
  132.         if (Objects.isNull(date)){
  133.             return "";
  134.         }
  135.         Pattern r = Pattern.compile(PARSE_DATE);
  136.         Matcher m = r.matcher(date);
  137.         String indexs = "";
  138.         while (m.find()) {
  139.             indexs = m.group();
  140.         }
  141.         return indexs;
  142.     }
  144.     /**
  145.      * 获取解析出来当前天的日期
  146.      * @param date
  147.      * @return
  148.      */
  149.     public static String getCurDateParse(String date) {
  150.         if (Objects.isNull(date)){
  151.             return "";
  152.         }
  153.         Pattern r = Pattern.compile(PARSE_DATE);
  154.         Matcher m = r.matcher(date);
  155.         String curDate = DateUtils.getDate("yyyyMMdd");
  156.         while (m.find()) {
  157.             String indexs = m.group();
  158.             //判断通过正则表达式解析出的日期和当前日期相等
  159.             if(curDate.equals(indexs)){
  160.                 return indexs;
  161.             }
  162.         }
  163.         return "";
  164.     }
  166.     /**
  167.      * yyyyMMdd格式校验
  168.      * @param date
  169.      * @return
  170.      */
  171.     public static boolean checkDateStyle(String date){
  172.         boolean flag = false;
  173.         Pattern r = Pattern.compile(MATCHER_DATE);
  174.         Matcher m = r.matcher(date);
  175.         if(m.matches()){
  176.             flag = true;
  177.         }
  178.         return flag;
  179.     }
  181.     /**
  182.      * 获取字符串中数字
  183.      * @param str
  184.      * @return
  185.      */
  186.     public static int getStrNumber(String str){
  187.         Pattern r = Pattern.compile(NUMBER);
  188.         Matcher m = r.matcher(str);
  189.         if(isNumber(m.replaceAll("").trim())){
  190.             return Integer.valueOf(m.replaceAll("").trim());
  191.         }
  192.         return 0;
  193.     }
  195.     /**
  196.      * 判断是否数字
  197.      * @param str
  198.      * @return
  199.      */
  200.     public static boolean isNumber(String str){
  201.         if (str == null) {
  202.             return false;
  203.         }
  204.         Pattern pattern = Pattern.compile(ISNUMBER);
  205.         return pattern.matcher(str).matches();
  206.     }
  208.     /**
  209.      * 获取字符串中数字英文字母
  210.      * @param str
  211.      * @return
  212.      */
  213.     public static String getStrNumberLetter(String str){
  214.         Pattern r = Pattern.compile(NUMBERLETTER);
  215.         Matcher m = r.matcher(str);
  216.         String numberLetter = m.replaceAll("").trim();
  217.         return numberLetter;
  218.     }
  220.     /**
  221.      * 提取全局参数中时间参数
  222.      * @param params
  223.      * @return
  224.      */
  225.     public static String getDateParam(String params) {
  226.         if (StringUtils.isEmpty(params)) {
  227.             return null;
  228.         }
  229.         String reg = "\\r|\\n|\\\\s";
  230.         String str = params.replaceAll(reg, "");
  231.         String[] split = str.toLowerCase().split("and");
  232.         for (String param : split) {
  233.             if (param.contains("yyyymm")) {
  234.                 return param;
  235.             }
  236.             if (param.contains("yyyymmdd")) {
  237.                 return param;
  238.             }
  239.             if (param.contains("week")) {
  240.                 return param;
  241.             }
  242.         }
  243.         return params;
  244.     }
  246.     /**
  247.      * @Param: [email]
  248.      * @Desc: 校验是否是邮箱格式
  249.      **/
  250.     public static boolean isEmail(String email) {
  251.         return Pattern.matches(REGEX_EMAIL, email);
  252.     }
  253.     /**
  254.      * @Param: 校验是否是url格式
  255.      * @Desc: 
  256.      **/
  257.     public static boolean isUrl(String url) {
  258.         if(StringUtils.isEmpty(url)){
  259.             return false;
  260.         }
  261.         return Pattern.matches(REGEX_URL, url);
  262.     }
  263.     /**
  264.      * @Param: 校验是否是手机号
  265.      * @Desc:
  266.      **/
  267.     public static boolean isMobile(String mobileNum){
  268.         return Pattern.matches(REGEX_MOBILE,mobileNum);
  269.     }
  271.     public static boolean isDateStr1(String dateStr){
  272.         return Pattern.matches(REGEX_SIMPLE_DATE1,dateStr);
  273.     }
  274. }