• 项目常用工具类

    Java本身自带了许多非常好用的工具类，但有时我们的业务千奇百怪，自带的工具类又无法满足业务需求，需要在这些工具类的基础上进行二次封装改造。以下是在实际工作中，可能会使用到的工具类。

    一、对象的序列化和反序列化

    对象的序列化和反序列化有很多方式，这里介绍一下最常用的Jackson。

    Jackson 是一个简单基于 Java 应用库，Jackson 可以轻松的将 Java 对象转换成 json 对象和 xml 文档，同样也可以将 json、xml 转换成 Java 对象。并且Jackson是开源免费的，源代码托管在 GitHub 上。

    1.1 Jackson注解

    Jackson 类库包含了很多注解，可以让我们快速建立 Java 类与 JSON 之间的关系。常用的注解如下所示：

    • @JsonProperty：用来修改序列化后的 JSON 属性名，默认情况下 JSON 属性名取对象中的属性名，也可以通过 value 属性指定 JSON 属性名。如果需要的话，该注解还有一个 index 属性指定生成 JSON 属性的顺序。
    • @JsonIgnore：用于排除某个属性，这样该属性就不会被 Jackson 序列化和反序列化。
    • @JsonIgnoreProperties：这个注解定义在类上的，用来排除对象中的某些属性。比如在序列化 JSON 的时候，@JsonIgnoreProperties({"prop1", "prop2"}) 会忽略 pro1 和 pro2 两个属性。在从 JSON 反序列化为 Java 类的时候，@JsonIgnoreProperties(ignoreUnknown=true) 会忽略所有没有 Getter 和 Setter 的属性。该注解在 Java 类和 JSON 不完全匹配的时候很有用。
    • @JsonIgnoreType：也是定义在类上的，会排除所有指定类型的属性。
    • @JsonPropertyOrder：@JsonPropertyOrder 和 @JsonProperty 的 index 属性类似，用来指定属性序列化时的顺序。
    • @JsonRootName：用于指定 JSON 根属性的名称。
    • @JsonInclude：@JsonInclude(JsonInclude.Include.NON_NULL)：对值为 null 的属性不进行序列化
    • @JsonFormat：添加到需要指定格式的日期属性上,指定日期属性序列化与反序列化时的格式。timezone = “GMT+8” 设置时区，表示 +8 小时，否则会少8小时。ObjectMapper 序列化 POJO 对象为 json 字符串时，Date 日期类型默认会转为 long 长整型，json 字符串反序列化为 POJO 时自动将长整型的日期转为 Date 类型。

    1.2 Jackson 的使用

    第一步：导入依赖

    jackson-databind 内部依赖了 jackson-annotations 与 jackson-core，所以 Maven 应用时，只要导入 databind 一个，则同时也导入了 annotations 与 core 依赖。

    2. <dependency>
    3.   <groupId>com.fasterxml.jackson.coregroupId>
    4.   <artifactId>jackson-databindartifactId>
    5.   <version>2.11.0version>
    6. dependency>

    如果是 springboot 项目，它内部已经包含了 Jackson，只需要引入 web 模块即可

    二、时间相关

    1. import com.google.common.collect.Lists;
    2. import lombok.extern.slf4j.Slf4j;
    3. import org.apache.commons.lang3.time.DateFormatUtils;
    4. import org.apache.commons.lang3.time.DateUtils;
    5.  
    6. import java.text.ParseException;
    7. import java.text.SimpleDateFormat;
    8. import java.time.Instant;
    9. import java.time.LocalDateTime;
    10. import java.time.LocalTime;
    11. import java.time.ZoneId;
    12. import java.time.format.DateTimeFormatter;
    13. import java.util.*;
    14.  
    15. /**
    16.  * 时间工具类
    17.  */
    18. @Slf4j
    19. public class DateUtil {
    20.  
    21.     /*** 常用的时间模型常量*/
    22.     public static final String PATTERN_DATE_TIME_MONTH = "yyyy-MM-dd";
    23.     private static final String PATTERN_DATE_TIME = "yyyy-MM-dd HH:mm:ss";
    24.     public static final String PATTERN_DATE_TIME_MILLISECOND = "yyyy-MM-dd HH:mm:ss.SSS";
    25.     private static final String EXPORT_FORMAT_DATE_TIME = "yyyyMMdd-hhmmss";
    26.  
    27.     /*** 周末*/
    28.     public static List holidays = Lists.newArrayList(6, 7);
    29.     /*** 工作日*/
    30.     public static List workdays = Lists.newArrayList(1, 2, 3, 4, 5);
    31.  
    32.     /**
    33.      * 获取指定的format，每次重建避免线程安全问题 yyyy-MM-dd HH:mm:ss
    34.      */
    35.     public static SimpleDateFormat getYyyyMmDdHhMmSs() {
    36.         return new SimpleDateFormat(PATTERN_DATE_TIME);
    37.     }
    38.  
    39.     /**
    40.      * LocalDateTime转为String，格式为："2023-10-13 15:40:23"
    41.      */
    42.     public static String formatDateTime(LocalDateTime dateTime) {
    43.         if (Objects.isNull(dateTime)) {
    44.             return "";
    45.         }
    46.         DateTimeFormatter formatter = DateTimeFormatter.ofPattern(PATTERN_DATE_TIME);
    47.         return dateTime.format(formatter);
    48.     }
    49.  
    50.     /**
    51.      * LocalDateTime转为String，格式为："2023-10-13"
    52.      */
    53.     public static String formatDateTimeOfMonth(LocalDateTime dateTime) {
    54.         if (Objects.isNull(dateTime)) {
    55.             return "";
    56.         }
    57.         DateTimeFormatter formatter = DateTimeFormatter.ofPattern(PATTERN_DATE_TIME_MONTH);
    58.         return dateTime.format(formatter);
    59.     }
    60.  
    61.     /**
    62.      * LocalDateTime转为Date
    63.      */
    64.     public static Date localDateTimeToDate(LocalDateTime localDateTime) {
    65.         return Date.from(localDateTime.atZone(ZoneId.systemDefault()).toInstant());
    66.     }
    67.  
    68.     /**
    69.      * LocalDateTime转为时间戳
    70.      */
    71.     public static String dateTimestamp(LocalDateTime date) {
    72.         return DateTimeFormatter.ofPattern("yyMMddHHmmssSSS").format(date);
    73.     }
    74.  
    75.     /**
    76.      * LocalDateTime转为String,自定义时间格式
    77.      *
    78.      * @param dateTime LocalDateTime类型的时间
    79.      * @param pattern  自定义的时间格式
    80.      */
    81.     public static String formatDateTime(LocalDateTime dateTime, String pattern) {
    82.         if (Objects.isNull(dateTime)) {
    83.             return "";
    84.         }
    85.         DateTimeFormatter formatter = DateTimeFormatter.ofPattern(pattern);
    86.         return dateTime.format(formatter);
    87.     }
    88.  
    89.     /**
    90.      * Date转为String，格式为：“2023-01-01”
    91.      */
    92.     public static String formatDateTime(Date dateTime) {
    93.         if (Objects.nonNull(dateTime)) {
    94.             return DateFormatUtils.format(dateTime, PATTERN_DATE_TIME_MONTH);
    95.         }
    96.         return "";
    97.     }
    98.  
    99.     /**
    100.      * Date转为String，格式为：“2023-01-01 12:10:50”
    101.      */
    102.     public static String formatDateOfDate(Date dateTime) {
    103.         if (Objects.nonNull(dateTime)) {
    104.             return DateFormatUtils.format(dateTime, PATTERN_DATE_TIME);
    105.         }
    106.         return "";
    107.     }
    108.  
    109.     /**
    110.      * Date转为String，格式为：“20230101-121050”
    111.      */
    112.     public static String exportFormatDateTime(Date dateTime) {
    113.         if (Objects.nonNull(dateTime)) {
    114.             return DateFormatUtils.format(dateTime, EXPORT_FORMAT_DATE_TIME);
    115.         }
    116.         return "";
    117.     }
    118.  
    119.     /**
    120.      * Date转为String，格式为：“2023.01.01”
    121.      */
    122.     public static String formatDate(Date dateTime) {
    123.         if (Objects.nonNull(dateTime)) {
    124.             return DateFormatUtils.format(dateTime, "yyyy.MM.dd");
    125.         }
    126.         return "";
    127.     }
    128.  
    129.     /**
    130.      * Date转为String时间，自定义时间格式
    131.      *
    132.      * @param dateTime Date时间
    133.      * @param pattern  自定义的时间格式
    134.      */
    135.     public static String formatDateTime(Date dateTime, String pattern) {
    136.         if (Objects.nonNull(dateTime)) {
    137.             return DateFormatUtils.format(dateTime, pattern);
    138.         }
    139.         return "";
    140.     }
    141.  
    142.     /**
    143.      * 字符串时间转为Date，格式为："Sun Oct 01 00:00:00 CST 2023"
    144.      */
    145.     public static Date strToDateTimeOfMonth(String strDate) {
    146.         try {
    147.             strDate = strDate.substring(0, 10);
    148.             return DateUtils.parseDate(strDate, PATTERN_DATE_TIME_MONTH);
    149.         } catch (ParseException e) {
    150.             log.error("时间转换异常：{}", e.getMessage());
    151.             throw new RuntimeException(e);
    152.         }
    153.     }
    154.  
    155.     /**
    156.      * 字符串时间转为Date，格式为："Sun Oct 01 02:56:20 CST 2023"
    157.      */
    158.     public static Date strToDateTime(String strDate) {
    159.         if (strDate.length() != 19) {
    160.             throw new RuntimeException("入参时间格式不正确");
    161.         }
    162.         try {
    163.  
    164.             return DateUtils.parseDate(strDate, PATTERN_DATE_TIME);
    165.         } catch (ParseException e) {
    166.             log.error("时间转换异常：{}", e.getMessage());
    167.             throw new RuntimeException(e);
    168.         }
    169.     }
    170.  
    171.     /**
    172.      * 将Date对象转化为指定格式dateFormat的字符串
    173.      *
    174.      * @return String
    175.      */
    176.     public static String getDate(Date date, String dateFormat) {
    177.         SimpleDateFormat format = new SimpleDateFormat(dateFormat);
    178.         return format.format(date);
    179.     }
    180.  
    181.     /**
    182.      * 将指定格式fromFormat的Date字符串转化为Date对象
    183.      */
    184.     public static Date getDate(String date) {
    185.         SimpleDateFormat sdf = getYyyyMmDdHhMmSs();
    186.         try {
    187.             return sdf.parse(date);
    188.         } catch (Exception e) {
    189.             e.printStackTrace();
    190.         }
    191.         return null;
    192.     }
    193.  
    194.     /**
    195.      * 将指定格式fromFormat的Date字符串转化为Date对象
    196.      *
    197.      * @return Date
    198.      */
    199.     public static Date getDate(String date, String fromFormat) {
    200.         try {
    201.             SimpleDateFormat fromSimpleDateFormat = new SimpleDateFormat(fromFormat);
    202.             return fromSimpleDateFormat.parse(date);
    203.         } catch (Exception e) {
    204.             e.printStackTrace();
    205.         }
    206.         return null;
    207.     }
    208.  
    209.     /**
    210.      * 字符串时间转为LocalDateTime，格式为："2023-10-01T02:56:20"
    211.      */
    212.     public static LocalDateTime strToLocalDateTime(String strDate) {
    213.         if (strDate.length() != 19) {
    214.             throw new RuntimeException("入参时间格式不正确");
    215.         }
    216.         try {
    217.             Date date = DateUtils.parseDate(strDate, "yyyy-MM-dd HH:mm:ss");
    218.             return date.toInstant().atZone(ZoneId.systemDefault()).toLocalDateTime();
    219.         } catch (ParseException e) {
    220.             log.error("时间转换异常：{}", e.getMessage());
    221.             throw new RuntimeException(e);
    222.         }
    223.     }
    224.  
    225.     /**
    226.      * 字符串时间转为LocalDateTime，格式为："2023-10-01T02:56:20.001"
    227.      */
    228.     public static LocalDateTime strToLocalDateTimeMillisecond(String strDate) {
    229.         try {
    230.             if (strDate.length() != 23) {
    231.                 throw new RuntimeException("入参时间格式不正确");
    232.             }
    233.             Date date = DateUtils.parseDate(strDate, PATTERN_DATE_TIME_MILLISECOND);
    234.             return date.toInstant().atZone(ZoneId.systemDefault()).toLocalDateTime();
    235.         } catch (ParseException e) {
    236.             log.error("时间转换异常：{}", e.getMessage());
    237.             throw new RuntimeException(e);
    238.         }
    239.     }
    240.  
    241.     /**
    242.      * 计算两个时间差
    243.      */
    244.     public static String getDatePoor(Date endDate, Date nowDate) {
    245.         long nd = 1000 * 24 * 60 * 60;
    246.         long nh = 1000 * 60 * 60;
    247.         long nm = 1000 * 60;
    248.         // long ns = 1000;
    249.         // 获得两个时间的毫秒时间差异
    250.         long diff = Math.abs(endDate.getTime() - nowDate.getTime());
    251.         // 计算差多少天
    252.         long day = diff / nd;
    253.         // 计算差多少小时
    254.         long hour = diff % nd / nh;
    255.         // 计算差多少分钟
    256.         long min = diff % nd % nh / nm;
    257.         // 计算差多少秒//输出结果
    258.         // long sec = diff % nd % nh % nm / ns;
    259.         return day + "天" + hour + "小时" + min + "分钟";
    260.     }
    261.  
    262.     /**
    263.      * 计算两个时间相差天数
    264.      */
    265.     public static int differentDaysByMillisecond(Date date1, Date date2) {
    266.         return Math.abs((int) ((date2.getTime() - date1.getTime()) / (1000 * 3600 * 24)));
    267.     }
    268.  
    269.     /**
    270.      * 计算两个时间相差小时
    271.      */
    272.     public static int differentHourByMillisecond(Date date1, Date date2) {
    273.         return Math.abs((int) ((date2.getTime() - date1.getTime()) / (1000 * 3600)));
    274.     }
    275.  
    276.     /**
    277.      * 计算两个时间相差分钟
    278.      */
    279.     public static int differentMinByMillisecond(Date date1, Date date2) {
    280.         return Math.abs((int) ((date2.getTime() - date1.getTime()) / (1000 * 60)));
    281.     }
    282.  
    283.     /**
    284.      * 获得某天最大时间，例如：Wed Nov 29 23:59:59 CST 2023
    285.      */
    286.     public static Date getEndOfDay(Date date) {
    287.         LocalDateTime localDateTime = LocalDateTime.ofInstant(Instant.ofEpochMilli(date.getTime()), ZoneId.systemDefault());
    288.         LocalDateTime endOfDay = localDateTime.with(LocalTime.MAX);
    289.         return Date.from(endOfDay.atZone(ZoneId.systemDefault()).toInstant());
    290.     }
    291.  
    292.     /**
    293.      * 获得某天最小时间，例如：Wed Nov 29 00:00:00 CST 2023
    294.      */
    295.     public static Date getStartOfDay(Date date) {
    296.         LocalDateTime localDateTime = LocalDateTime.ofInstant(Instant.ofEpochMilli(date.getTime()), ZoneId.systemDefault());
    297.         LocalDateTime startOfDay = localDateTime.with(LocalTime.MIN);
    298.         return Date.from(startOfDay.atZone(ZoneId.systemDefault()).toInstant());
    299.     }
    300.  
    301.     /**
    302.      * 获取相对于date前后的某一天
    303.      */
    304.     public static Date anotherDay(Date date, int i) {
    305.         Calendar cal = Calendar.getInstance();
    306.         cal.setTime(date);
    307.         cal.add(Calendar.DATE, i);
    308.         return cal.getTime();
    309.     }
    310.  
    311.     /**
    312.      * 给定值向后加月份
    313.      */
    314.     public static Date stepMonth(Date sourceDate, int month) {
    315.         Calendar c = Calendar.getInstance();
    316.         c.setTime(sourceDate);
    317.         c.add(Calendar.MONTH, month);
    318.         return c.getTime();
    319.     }
    320.  
    321.     /**
    322.      * 给定值向后加年份
    323.      */
    324.     public static Date stepYear(Date sourceDate, int year) {
    325.         Calendar c = Calendar.getInstance();
    326.         c.setTime(sourceDate);
    327.         c.add(Calendar.YEAR, year);
    328.         return c.getTime();
    329.     }
    330.  
    331.     /**
    332.      * 该年最后一天的 时、分、秒以23:59:59结尾
    333.      */
    334.     public static Date dateTimeYearEndWidth(Date dateTime) {
    335.         String dateTimeString = getDate(dateTime, PATTERN_DATE_TIME);
    336.         return getDate(dateTimeString.substring(0, 4) + "-12-31 23:59:59");
    337.     }
    338.  
    339.     /**
    340.      * 获取过去N天内的日期数组（不包含今天）返回的时间类型为：yyyy-MM-dd
    341.      */
    342.     public static ArrayList getLastDays(int intervals) {
    343.         ArrayList pastDaysList = new ArrayList<>();
    344.         for (int i = intervals; i > 0; i--) {
    345.             Calendar calendar = Calendar.getInstance();
    346.             calendar.set(Calendar.DAY_OF_YEAR, calendar.get(Calendar.DAY_OF_YEAR) - i);
    347.             Date today = calendar.getTime();
    348.             SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
    349.             pastDaysList.add(format.format(today));
    350.         }
    351.         return pastDaysList;
    352.     }
    353.  
    354. }

    三、正则校验

    1. import java.util.ArrayList;
    2. import java.util.List;
    3. import java.util.regex.Matcher;
    4. import java.util.regex.Pattern;
    5.  
    6. /**
    7.  * 正则相关工具类
    8.  */
    9. public class ValidateUtil {
    10.  
    11.     /*** 手机号（简单），以1开头的11位纯数字*/
    12.     public static final String REGEX_MOBILE_SIMPLE = "^[1]\\d{10}$";
    13.  
    14.     /**
    15.      * 手机号（精确）
    16.      * 
      移动：134(0-8)、135、136、137、138、139、147、150、151、152、157、158、159、178、182、183、184、187、188
    17.      * 
      联通：130、131、132、145、155、156、175、176、185、186
    18.      * 
      电信：133、153、173、177、180、181、189
    19.      * 
      全球星：1349
    20.      * 
      虚拟运营商：170
    21.      */
    22.     public static final String REGEX_MOBILE_EXACT = "^((13[0-9])|(14[5,7])|(15[0-3,5-9])|(17[0,3,5-8])|(18[0-9])|(147))\\d{8}$";
    23.  
    24.     /*** 固定电话号码*/
    25.     public static final String REGEX_TEL = "^0\\d{2,3}[- ]?\\d{7,8}";
    26.  
    27.     /*** 身份证号（15位身份证号）*/
    28.     public static final String REGEX_ID_CARD15 = "^[1-9]\\d{7}((0\\d)|(1[0-2]))(([0|1|2]\\d)|3[0-1])\\d{3}$";
    29.  
    30.     /*** 身份证号（18位身份证号）*/
    31.     public static final String REGEX_ID_CARD18 = "^[1-9]\\d{5}[1-9]\\d{3}((0\\d)|(1[0-2]))(([0|1|2]\\d)|3[0-1])\\d{3}([0-9Xx])$";
    32.  
    33.     /*** 身份证号（15和18位）*/
    34.     public static final String REGEX_ID_CARD15AND18 = "(^\\d{8}(0\\d|10|11|12)([0-2]\\d|30|31)\\d{3}$)|(^\\d{6}(18|19|20)\\d{2}(0\\d|10|11|12)([0-2]\\d|30|31)\\d{3}(\\d|X|x)$)";
    35.  
    36.     /*** 邮箱*/
    37.     public static final String REGEX_EMAIL = "^\\w+([-+.]\\w+)*@\\w+([-.]\\w+)*\\.\\w+([-.]\\w+)*$";
    38.  
    39.     /*** 网址URL*/
    40.     public static final String REGEX_URL = "[a-zA-z]+://[^\\s]*";
    41.  
    42.     /*** 汉字*/
    43.     public static final String REGEX_ZH = "^[\\u4e00-\\u9fa5]+$";
    44.  
    45.     /*** 用户名（取值范围为a-z,A-Z,0-9,"_",汉字，不能以"_"结尾,用户名必须是6-20位）*/
    46.     public static final String REGEX_USERNAME = "^[\\w\\u4e00-\\u9fa5]{6,20}(?;
    47.  
    48.     /*** yyyy-MM-dd格式的日期校验，已考虑平闰年*/
    49.     public static final String REGEX_DATE = "^(?:(?!0000)[0-9]{4}-(?:(?:0[1-9]|1[0-2])-(?:0[1-9]|1[0-9]|2[0-8])|(?:0[13-9]|1[0-2])-(?:29|30)|(?:0[13578]|1[02])-31)|(?:[0-9]{2}(?:0[48]|[2468][048]|[13579][26])|(?:0[48]|[2468][048]|[13579][26])00)-02-29)$";
    50.  
    51.     /*** IP地址*/
    52.     public static final String REGEX_IP = "((2[0-4]\\d|25[0-5]|[01]?\\d\\d?)\\.){3}(2[0-4]\\d|25[0-5]|[01]?\\d\\d?)";
    53.  
    54.     /*** 双字节字符（包括汉字在内）*/
    55.     public static final String REGEX_DOUBLE_BYTE_CHAR = "[^\\x00-\\xff]";
    56.  
    57.     /*** 空白行*/
    58.     public static final String REGEX_BLANK_LINE = "\\n\\s*\\r";
    59.  
    60.     /*** QQ号*/
    61.     public static final String REGEX_TENCENT_NUM = "[1-9][0-9]{4,}";
    62.  
    63.     /*** 中国邮政编码*/
    64.     public static final String REGEX_ZIP_CODE = "[1-9]\\d{5}(?!\\d)";
    65.  
    66.     /*** 正整数*/
    67.     public static final String REGEX_POSITIVE_INTEGER = "^[1-9]\\d*$";
    68.  
    69.     /*** 负整数*/
    70.     public static final String REGEX_NEGATIVE_INTEGER = "^-[1-9]\\d*$";
    71.  
    72.     /*** 整数*/
    73.     public static final String REGEX_INTEGER = "^-?[1-9]\\d*$";
    74.  
    75.     /*** 非负整数（正整数 + 0）*/
    76.     public static final String REGEX_NOT_NEGATIVE_INTEGER = "^[1-9]\\d*|0$";
    77.  
    78.     /*** 非正整数（负整数 + 0）*/
    79.     public static final String REGEX_NOT_POSITIVE_INTEGER = "^-[1-9]\\d*|0$";
    80.  
    81.     /*** 正浮点数*/
    82.     public static final String REGEX_POSITIVE_FLOAT = "^[1-9]\\d*\\.\\d*|0\\.\\d*[1-9]\\d*$";
    83.  
    84.     /*** 负浮点数*/
    85.     public static final String REGEX_NEGATIVE_FLOAT = "^-[1-9]\\d*\\.\\d*|-0\\.\\d*[1-9]\\d*$";
    86.  
    87.     /**
    88.      * 验证手机号（简单）
    89.      *
    90.      * @param input 待验证文本
    91.      * @return true: 匹配 
       false: 不匹配
    92.      */
    93.     public static boolean isMobileSimple(CharSequence input) {
    94.         return isMatch(REGEX_MOBILE_SIMPLE, input);
    95.     }
    96.  
    97.     /**
    98.      * 验证手机号（精确）
    99.      *
    100.      * @param input 待验证文本
    101.      * @return true: 匹配 
       false: 不匹配
    102.      */
    103.     public static boolean isMobileExact(CharSequence input) {
    104.         return isMatch(REGEX_MOBILE_EXACT, input);
    105.     }
    106.  
    107.     /**
    108.      * 验证固定电话号码
    109.      *
    110.      * @param input 待验证文本
    111.      * @return true: 匹配 
       false: 不匹配
    112.      */
    113.     public static boolean isTel(CharSequence input) {
    114.         return isMatch(REGEX_TEL, input);
    115.     }
    116.  
    117.     /**
    118.      * 验证身份证号码（15位）
    119.      *
    120.      * @param input 待验证文本
    121.      * @return true: 匹配 
       false: 不匹配
    122.      */
    123.     public static boolean isIdCard15(CharSequence input) {
    124.         return isMatch(REGEX_ID_CARD15, input);
    125.     }
    126.  
    127.     /**
    128.      * 验证身份证号码（18位）
    129.      *
    130.      * @param input 待验证文本
    131.      * @return true: 匹配 
       false: 不匹配
    132.      */
    133.     public static boolean isIdCard18(CharSequence input) {
    134.         return isMatch(REGEX_ID_CARD18, input);
    135.     }
    136.  
    137.     /**
    138.      * 验证身份证号码（15/18位）
    139.      *
    140.      * @param input 待验证文本
    141.      * @return true: 匹配 
       false: 不匹配
    142.      */
    143.     public static boolean isIdCard15and18(CharSequence input) {
    144.         return isMatch(REGEX_ID_CARD15AND18, input);
    145.     }
    146.  
    147.     /**
    148.      * 验证邮箱
    149.      *
    150.      * @param input 待验证文本
    151.      * @return true: 匹配 
       false: 不匹配
    152.      */
    153.     public static boolean isEmail(CharSequence input) {
    154.         return isMatch(REGEX_EMAIL, input);
    155.     }
    156.  
    157.     /**
    158.      * 验证网址URL
    159.      *
    160.      * @param input 待验证文本
    161.      * @return true: 匹配 
       false: 不匹配
    162.      */
    163.     public static boolean isUrl(CharSequence input) {
    164.         return isMatch(REGEX_URL, input);
    165.     }
    166.  
    167.     /**
    168.      * 验证汉字
    169.      *
    170.      * @param input 待验证文本
    171.      * @return true: 匹配 
       false: 不匹配
    172.      */
    173.     public static boolean isZh(CharSequence input) {
    174.         return isMatch(REGEX_ZH, input);
    175.     }
    176.  
    177.     /**
    178.      * 验证用户名（取值范围为a-z,A-Z,0-9,"_",汉字，不能以"_"结尾,用户名必须是6-20位）
    179.      *
    180.      * @param input 待验证文本
    181.      * @return true: 匹配 
       false: 不匹配
    182.      */
    183.     public static boolean isUsername(CharSequence input) {
    184.         return isMatch(REGEX_USERNAME, input);
    185.     }
    186.  
    187.     /**
    188.      * 验证yyyy-MM-dd格式的日期校验，已考虑平闰年
    189.      *
    190.      * @param input 待验证文本
    191.      * @return true: 匹配 
       false: 不匹配
    192.      */
    193.     public static boolean isDate(CharSequence input) {
    194.         return isMatch(REGEX_DATE, input);
    195.     }
    196.  
    197.     /**
    198.      * 验证IP地址
    199.      *
    200.      * @param input 待验证文本
    201.      * @return true: 匹配 
       false: 不匹配
    202.      */
    203.     public static boolean isIp(CharSequence input) {
    204.         return isMatch(REGEX_IP, input);
    205.     }
    206.  
    207.     /**
    208.      * 判断是否匹配正则
    209.      *
    210.      * @param regex 正则表达式
    211.      * @param input 要匹配的字符串
    212.      * @return true: 匹配 
       false: 不匹配
    213.      */
    214.     public static boolean isMatch(String regex, CharSequence input) {
    215.         return input != null && input.length() > 0 && Pattern.matches(regex, input);
    216.     }
    217.  
    218.     /**
    219.      * 获取正则匹配的部分
    220.      *
    221.      * @param regex 正则表达式
    222.      * @param input 要匹配的字符串
    223.      * @return 正则匹配的部分
    224.      */
    225.     public static List getMatches(String regex, CharSequence input) {
    226.         if (input == null) {
    227.             return null;
    228.         }
    229.         List matches = new ArrayList<>();
    230.         Pattern pattern = Pattern.compile(regex);
    231.         Matcher matcher = pattern.matcher(input);
    232.         while (matcher.find()) {
    233.             matches.add(matcher.group());
    234.         }
    235.         return matches;
    236.     }
    237.  
    238.     /**
    239.      * 获取正则匹配分组
    240.      *
    241.      * @param input 要分组的字符串
    242.      * @param regex 正则表达式
    243.      * @return 正则匹配分组
    244.      */
    245.     public static String[] getSplits(String input, String regex) {
    246.         if (input == null) {
    247.             return null;
    248.         }
    249.         return input.split(regex);
    250.     }
    251.  
    252.     /**
    253.      * 替换正则匹配的第一部分
    254.      *
    255.      * @param input       要替换的字符串
    256.      * @param regex       正则表达式
    257.      * @param replacement 代替者
    258.      * @return 替换正则匹配的第一部分
    259.      */
    260.     public static String getReplaceFirst(String input, String regex, String replacement) {
    261.         if (input == null) {
    262.             return null;
    263.         }
    264.         return Pattern.compile(regex).matcher(input).replaceFirst(replacement);
    265.     }
    266.  
    267.     /**
    268.      * 替换所有正则匹配的部分
    269.      *
    270.      * @param input       要替换的字符串
    271.      * @param regex       正则表达式
    272.      * @param replacement 代替者
    273.      * @return 替换所有正则匹配的部分
    274.      */
    275.     public static String getReplaceAll(String input, String regex, String replacement) {
    276.         if (input == null) {
    277.             return null;
    278.         }
    279.         return Pattern.compile(regex).matcher(input).replaceAll(replacement);
    280.     }
    281.  
    282. }

    四、JWT

    第一步：导入坐标

    1. <dependency>
    2.   <groupId>io.jsonwebtokengroupId>
    3.   <artifactId>jjwtartifactId>
    4.   <version>0.9.1version>
    5. dependency>

    第二步：在项目导入jwt工具类

    1. import com.auth0.jwt.JWT;
    2. import com.auth0.jwt.algorithms.Algorithm;
    3. import com.auth0.jwt.interfaces.Claim;
    4. import com.auth0.jwt.interfaces.DecodedJWT;
    5. import com.auth0.jwt.interfaces.JWTVerifier;
    6. import lombok.extern.slf4j.Slf4j;
    7. import org.apache.commons.lang3.StringUtils;
    8. import org.springframework.beans.factory.annotation.Value;
    9. import org.springframework.stereotype.Component;
    10.  
    11. import java.util.Date;
    12. import java.util.Map;
    13. import java.util.Optional;
    14.  
    15. /**
    16.  * jwt的token生成与解析
    17.  */
    18. @Slf4j
    19. @Component
    20. public class JwtUtils {
    21.  
    22.     /**
    23.      * token秘钥，请勿泄露，请勿随便修改
    24.      */
    25.     @Value("${mallchat.jwt.secret}")
    26.     private String secret;
    27.  
    28.     private static final String UID_CLAIM = "uid";
    29.     private static final String CREATE_TIME = "createTime";
    30.  
    31.     /**
    32.      * JWT生成Token
    33.      * JWT构成: header, payload, signature
    34.      */
    35.     public String createToken(Long uid) {
    36.         String token = JWT.create()
    37.         .withClaim(UID_CLAIM, uid) //只存一个uid信息，其他的自己去redis查
    38.         .withClaim(CREATE_TIME, new Date())
    39.         .sign(Algorithm.HMAC256(secret)); //signature
    40.         return token;
    41.     }
    42.  
    43.     /**
    44.      * 解密Token
    45.      */
    46.     public Map verifyToken(String token) {
    47.         if (StringUtils.isEmpty(token)) {
    48.             return null;
    49.         }
    50.         try {
    51.             JWTVerifier verifier = JWT.require(Algorithm.HMAC256(secret)).build();
    52.             DecodedJWT jwt = verifier.verify(token);
    53.             return jwt.getClaims();
    54.         } catch (Exception e) {
    55.             log.error("decode error,token:{}", token, e);
    56.         }
    57.         return null;
    58.     }
    59.  
    60.     /**
    61.      * 根据Token获取uid
    62.      */
    63.     public Long getUidOrNull(String token) {
    64.         return Optional.ofNullable(verifyToken(token))
    65.         .map(map -> map.get(UID_CLAIM))
    66.         .map(Claim::asLong)
    67.         .orElse(null);
    68.     }
    69.  
    70. }

  • 相关阅读:
    Python3 OS 文件/目录方法
    css 10-13
    （附源码）计算机毕业设计SSM基于框架的旅游管理系统
    24、DAPlink仿真器-STM32F103C8T6
    基于人工大猩猩部队算法优化概率神经网络PNN的分类预测 - 附代码
    Go Web---上
    【JAVA并发】二、JAVA是如何解决并发问题的
    java验证码的实现
    使用go开发的小tips
    ts 分发
  • 原文地址：https://blog.csdn.net/m0_59749089/article/details/137976898