编写工具模块

1.新建模块

1.新建模块sun-common-tool

2.sun-dependencies指定依赖

            <freemarker.version>2.3.30</freemarker.version>
        		<pinyin4j.version>2.5.0</pinyin4j.version>
        		<commons.lang3.version>3.8</commons.lang3.version>



						<!-- freemarker -->
            <dependency>
                <groupId>org.freemarker</groupId>
                <artifactId>freemarker</artifactId>
                <version>${freemarker.version}</version>
            </dependency>
            <!-- pinyin4j -->
            <dependency>
                <groupId>com.belerweb</groupId>
                <artifactId>pinyin4j</artifactId>
                <version>${pinyin4j.version}</version>
            </dependency>
            <!-- commons-lang3 -->
            <dependency>
                <groupId>org.apache.commons</groupId>
                <artifactId>commons-lang3</artifactId>
                <version>${commons.lang3.version}</version>
            </dependency>

3.sun-common统一管理sun-common-tool子模块

4.sun-common-tool的pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <!-- 继承父模块的版本和通用依赖 -->
    <parent>
        <groupId>com.sunxiansheng</groupId>
        <artifactId>sun-common</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>

    <artifactId>sun-common-tool</artifactId>
    <!-- 子模块的version,如果不写就默认跟父模块的一样 -->
    <version>${children.version}</version>

    <!-- 自定义依赖,无需版本号 -->
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.freemarker</groupId>
            <artifactId>freemarker</artifactId>
        </dependency>
        <dependency>
            <groupId>com.belerweb</groupId>
            <artifactId>pinyin4j</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
        </dependency>
    </dependencies>

</project>

5.清除掉创建模块时默认sun-frame对sun-common-tool进行管理

2.常用工具类

1.DateUtils.java

package com.sunxiansheng.tool;

import lombok.extern.slf4j.Slf4j;

import java.text.SimpleDateFormat;
import java.util.*;

/**
 * 日期工具类
 * 提供了常用的日期操作方法，例如获取某日期的开始和结束时间，计算两个日期之间的天数等。
 */
@Slf4j
public class DateUtils {

    // 常用日期格式
    public static final String DATE_FORMAT = "yyyy-MM-dd";
    public static final String DATE_TIME_FORMAT = "yyyy-MM-dd HH:mm:ss";
    public static final String DATE_MINUTE_FORMAT = "yyyy-MM-dd HH:mm";
    public static final String MINUTE_FORMAT = "HH:mm";

    public DateUtils() {
    }

    /**
     * 获取指定日期当天的开始时间
     *
     * @param calendar 日历对象
     * @return 当天的开始时间
     */
    public static Date getStartDate(Calendar calendar) {
        calendar.set(Calendar.HOUR_OF_DAY, 0);
        calendar.set(Calendar.MINUTE, 0);
        calendar.set(Calendar.SECOND, 0);
        calendar.set(Calendar.MILLISECOND, 0);
        return calendar.getTime();
    }

    /**
     * 获取指定日期当天的结束时间
     *
     * @param calendar 日历对象
     * @return 当天的结束时间
     */
    public static Date getEndDate(Calendar calendar) {
        calendar.set(Calendar.HOUR_OF_DAY, 23);
        calendar.set(Calendar.MINUTE, 59);
        calendar.set(Calendar.SECOND, 59);
        calendar.set(Calendar.MILLISECOND, 999);
        return calendar.getTime();
    }

    /**
     * 在指定日期上加上或减去指定天数
     *
     * @param date 起始日期
     * @param day  要增加的天数（负数表示减去）
     * @return 新的日期
     */
    public static Date addDate(Date date, int day) {
        long millis = date.getTime() + day * 24L * 3600L * 1000L;
        Calendar calendar = Calendar.getInstance();
        calendar.setTimeInMillis(millis);
        return calendar.getTime();
    }

    /**
     * 获取指定日期当天的开始时间
     *
     * @param date 日期对象
     * @return 当天的开始时间
     */
    public static Date getStartDate(Date date) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.set(Calendar.HOUR_OF_DAY, 0);
        calendar.set(Calendar.MINUTE, 0);
        calendar.set(Calendar.SECOND, 0);
        calendar.set(Calendar.MILLISECOND, 0);
        return calendar.getTime();
    }

    /**
     * 获取指定日期当天的结束时间
     *
     * @param date 日期对象
     * @return 当天的结束时间
     */
    public static Date getEndDate(Date date) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.set(Calendar.HOUR_OF_DAY, 23);
        calendar.set(Calendar.MINUTE, 59);
        calendar.set(Calendar.SECOND, 59);
        calendar.set(Calendar.MILLISECOND, 999);
        return calendar.getTime();
    }

    /**
     * 计算两个日期之间的周数差
     *
     * @param startDate 开始日期
     * @param endDate   结束日期
     * @return 周数差
     */
    public static int weeksOfTwoDates(Date startDate, Date endDate) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(endDate);
        int i = 0;
        while (!endDate.before(startDate)) {
            i++;
            calendar.setFirstDayOfWeek(Calendar.MONDAY);
            calendar.add(Calendar.WEEK_OF_YEAR, -1);
            calendar.set(Calendar.DAY_OF_WEEK, calendar.getFirstDayOfWeek());
            calendar.add(Calendar.DAY_OF_MONTH, 6);
            endDate = calendar.getTime();
        }
        return i;
    }

    /**
     * 获取当前周的周一日期
     *
     * @return 当前周的周一日期
     */
    public static Date getCurrentMonday() {
        int mondayPlus = getMondayPlus();
        GregorianCalendar currentDate = new GregorianCalendar();
        currentDate.add(Calendar.DAY_OF_MONTH, mondayPlus);
        return currentDate.getTime();
    }

    /**
     * 获取上周日的日期
     *
     * @return 上周日的日期
     */
    public static Date getPreviousSunday() {
        int mondayPlus = getMondayPlus();
        GregorianCalendar currentDate = new GregorianCalendar();
        currentDate.add(Calendar.DAY_OF_MONTH, mondayPlus + 6);
        return currentDate.getTime();
    }

    /**
     * 获取当前日期到最近的周一的天数差
     *
     * @return 天数差
     */
    public static int getMondayPlus() {
        Calendar cd = Calendar.getInstance();
        int dayOfWeek = cd.get(Calendar.DAY_OF_WEEK);
        return dayOfWeek == 1 ? -6 : 2 - dayOfWeek;
    }

    /**
     * 获取当前月的第一天
     *
     * @return 当前月的第一天
     */
    public static Calendar getMinMonthDate() {
        Calendar calendar = Calendar.getInstance();
        calendar.set(5, calendar.getActualMinimum(5));
        return calendar;
    }

    /**
     * 获取当前月的最后一天
     *
     * @return 当前月的最后一天
     */
    public static Calendar getMaxMonthDate() {
        Calendar calendar = Calendar.getInstance();
        calendar.set(Calendar.DAY_OF_MONTH, calendar.getActualMaximum(Calendar.DAY_OF_MONTH));
        return calendar;
    }

    /**
     * 获取上周一的日期
     *
     * @return 上周一的日期
     */
    public static Calendar getLastMonday() {
        Calendar calendar = Calendar.getInstance();
        int dayOfWeek = calendar.get(Calendar.DAY_OF_WEEK) - 1;
        int offset = 1 - dayOfWeek;
        calendar.add(Calendar.DAY_OF_MONTH, offset - 7);
        return calendar;
    }

    /**
     * 获取上周日的日期
     *
     * @return 上周日的日期
     */
    public static Calendar getLastSunday() {
        Calendar calendar = Calendar.getInstance();
        int dayOfWeek = calendar.get(Calendar.DAY_OF_WEEK) - 1;
        int offset = Calendar.DAY_OF_WEEK - dayOfWeek;
        calendar.add(Calendar.DAY_OF_MONTH, offset - 7);
        return calendar;
    }

    /**
     * 获取上个月的第一天
     *
     * @return 上个月的第一天
     */
    public static Calendar getLastMonthFirstDay() {
        Calendar calendar = Calendar.getInstance();
        calendar.add(Calendar.MONTH, -1);
        calendar.set(Calendar.DAY_OF_MONTH, 1);
        return calendar;
    }

    /**
     * 获取上个月的最后一天
     *
     * @return 上个月的最后一天
     */
    public static Calendar getLastMonthEndDay() {
        Calendar calendar = Calendar.getInstance();
        calendar.set(Calendar.DAY_OF_MONTH, 0);
        return calendar;
    }

    /**
     * 将日期对象格式化为字符串
     *
     * @param date 日期对象
     * @return 格式化后的字符串
     */
    public static String getDateStr(Date date) {
        SimpleDateFormat sdf = new SimpleDateFormat(DATE_FORMAT);
        return date != null ? sdf.format(date) : "";
    }

    /**
     * 获取指定日期之前的若干天
     *
     * @param date 日期对象
     * @param num  天数
     * @return 指定日期之前的若干天
     */
    public static Date getPreDateStr(Date date, int num) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.add(Calendar.DAY_OF_MONTH, -num);
        Date time = calendar.getTime();
        return time;
    }

    /**
     * 获取当前周的周一日期
     *
     * @return 当前周的周一日期
     */
    public static Date getMondayStrOfWeek() {
        Calendar calendar = Calendar.getInstance();
        int dayWeek = calendar.get(Calendar.DAY_OF_WEEK);
        if (dayWeek == 1) {
            calendar.add(Calendar.DAY_OF_MONTH, -6);
        } else {
            calendar.add(Calendar.DAY_OF_MONTH, -(dayWeek - 2));
        }
        Date time = calendar.getTime();
        return time;
    }

    /**
     * 判断指定日期是否为当月的最后一天
     *
     * @param date 日期对象
     * @return true 表示是当月的最后一天，否则不是
     */
    public static boolean isLastDayOfMonth(Date date) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        int lastDay = calendar.getActualMaximum(Calendar.DAY_OF_MONTH);
        int now = calendar.get(Calendar.DAY_OF_MONTH);
        return now == lastDay;
    }
    /**
     * 计算两个日期之间的天数
     *
     * @param startDateStr 开始日期字符串
     * @param endDateStr   结束日期字符串
     * @return 两个日期之间的天数
     * @throws Exception 日期解析异常
     */
    public static int daysOfTwo(String startDateStr, String endDateStr) throws Exception {
        SimpleDateFormat sdf = new SimpleDateFormat(DATE_FORMAT);
        Date startDate = sdf.parse(startDateStr);
        Date endDate = sdf.parse(endDateStr);
        return (int) ((endDate.getTime() - startDate.getTime()) / 1000L / 60L / 60L / 24L);
    }

    /**
     * 获取最近12天的日期字符串列表
     *
     * @return 最近12天的日期字符串列表
     */
    public static List<String> getContinue12Days() {
        List<String> list = new ArrayList<>();
        Calendar calendar = Calendar.getInstance();
        calendar.add(Calendar.DAY_OF_MONTH, -11);
        SimpleDateFormat sdf = new SimpleDateFormat(DATE_FORMAT);
        for (int i = 0; i <= 11; ++i) {
            Date time = calendar.getTime();
            list.add(sdf.format(time));
            calendar.add(Calendar.DAY_OF_MONTH, 1);
        }
        return list;
    }

    /**
     * 获取指定日期的年份周次字符串
     *
     * @param dateStr 日期字符串
     * @return 年份周次字符串
     * @throws Exception 日期解析异常
     */
    public static String getWeeksOfYear(String dateStr) throws Exception {
        SimpleDateFormat sdf = new SimpleDateFormat(DATE_FORMAT);
        Date date = sdf.parse(dateStr);
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        int i = calendar.get(Calendar.WEEK_OF_YEAR);
        if (i >= 10) {
            return dateStr.substring(2, 4) + "-" + i;
        } else {
            return dateStr.substring(2, 4) + "-0" + i;
        }
    }

    /**
     * 将日期字符串解析为日期对象
     *
     * @param dateStr 日期字符串
     * @return 日期对象
     * @throws Exception 日期解析异常
     */
    public static Date getDateByStr(String dateStr) throws Exception {
        SimpleDateFormat sdf = new SimpleDateFormat(DATE_FORMAT);
        return sdf.parse(dateStr);
    }

    /**
     * 计算两个日期之间的天数
     *
     * @param startDate 开始日期
     * @param endDate   结束日期
     * @return 两个日期之间的天数
     */
    public static int daysOfTwoDates(Date startDate, Date endDate) {
        return (int) ((endDate.getTime() - startDate.getTime()) / 1000L / 60L / 60L / 24L);
    }

    /**
     * 获取指定日期的月份第一天
     *
     * @param date 日期对象
     * @return 月份第一天
     */
    public static Date getFirstDayOfMonth(Date date) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.set(Calendar.DATE, 1);
        calendar.set(Calendar.HOUR_OF_DAY, 0);
        calendar.set(Calendar.MINUTE, 0);
        calendar.set(Calendar.SECOND, 0);
        return calendar.getTime();
    }

    /**
     * 获取指定年份和月份的最后一天
     *
     * @param year  年份
     * @param month 月份
     * @return 月份最后一天
     */
    public static final Date getLastDayOfMonth(int year, int month) {
        Calendar calendar = Calendar.getInstance();
        calendar.set(Calendar.YEAR, year);
        calendar.set(Calendar.MONTH, month - 1);
        int lastDay = calendar.getActualMaximum(Calendar.DAY_OF_MONTH);
        calendar.set(Calendar.DAY_OF_MONTH, lastDay);
        return calendar.getTime();
    }

    /**
     * 判断指定日期是否是今天
     *
     * @param date 日期对象
     * @return true 表示是今天，否则不是
     */
    public static boolean isNow(Date date) {
        Date now = new Date();
        SimpleDateFormat sf = new SimpleDateFormat(DATE_FORMAT);
        String nowDay = sf.format(now);
        String day = sf.format(date);
        return day.equals(nowDay);
    }

    /**
     * 将日期对象格式化为指定格式的字符串
     *
     * @param date   日期对象
     * @param format 格式字符串
     * @return 格式化后的日期字符串
     */
    public static String format(Date date, String format) {
        SimpleDateFormat sdf = new SimpleDateFormat(format);
        return sdf.format(date);
    }

    /**
     * 将字符串解析为指定格式的日期对象
     *
     * @param str    日期字符串
     * @param format 格式字符串
     * @return 日期对象
     * @throws Exception 日期解析异常
     */
    public static Date parse(String str, String format) throws Exception {
        SimpleDateFormat sdf = new SimpleDateFormat(format);
        return sdf.parse(str);
    }

    /**
     * 判断当前时间是否在指定时间范围内
     *
     * @param nowTime   当前时间
     * @param startTime 开始时间
     * @param endTime   结束时间
     * @return true 表示在范围内，否则不在范围内
     */
    public static boolean isEffectiveDate(Date nowTime, Date startTime, Date endTime) {
        if (nowTime.getTime() == startTime.getTime() || nowTime.getTime() == endTime.getTime()) {
            return true;
        }
        Calendar date = Calendar.getInstance();
        date.setTime(nowTime);
        Calendar begin = Calendar.getInstance();
        begin.setTime(startTime);
        Calendar end = Calendar.getInstance();
        end.setTime(endTime);
        return date.after(begin) && date.before(end);
    }

    /**
     * 将时间戳格式化为指定格式的日期字符串
     *
     * @param dateTime 时间戳
     * @param format   格式字符串
     * @return 格式化后的日期字符串
     */
    public static String formatLongToDateStr(Long dateTime, String format) {
        SimpleDateFormat sdf = new SimpleDateFormat(format);
        return sdf.format(new Date(dateTime));
    }
}

2.EncodeUtils.java

package com.sunxiansheng.tool;

import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import java.net.URLEncoder;
import java.util.Base64;

/**
 * 编解码工具类，提供BASE64和URL的编解码功能
 */
public class EncodeUtils {

    // 默认的URL编码字符集
    private static final String DEFAULT_URL_ENCODING = "UTF-8";

    // BASE64编码器实例
    private static final Base64.Encoder BASE64_ENCODER = Base64.getEncoder();

    // BASE64解码器实例
    private static final Base64.Decoder BASE64_DECODER = Base64.getDecoder();

    /**
     * 对文本进行BASE64编码
     *
     * @param text 需要编码的文本
     * @return 编码后的字符串
     * @throws UnsupportedEncodingException 如果字符编码不被支持
     */
    public static String encode(String text) throws UnsupportedEncodingException {
        // 将文本按指定字符集转换为字节数组，再进行BASE64编码
        return BASE64_ENCODER.encodeToString(text.getBytes(DEFAULT_URL_ENCODING));
    }

    /**
     * 对BASE64编码的文本进行解码
     *
     * @param encodedText 需要解码的BASE64编码文本
     * @return 解码后的字符串
     * @throws UnsupportedEncodingException 如果字符编码不被支持
     */
    public static String decode(String encodedText) throws UnsupportedEncodingException {
        // 对BASE64编码的文本进行解码，再按指定字符集转换为字符串
        return new String(BASE64_DECODER.decode(encodedText), DEFAULT_URL_ENCODING);
    }

    /**
     * 对URL的部分文本进行编码
     *
     * @param part 需要编码的URL部分文本
     * @return 编码后的字符串
     * @throws UnsupportedEncodingException 如果字符编码不被支持
     */
    public static String urlEncode(String part) throws UnsupportedEncodingException {
        // 使用URLEncoder对文本进行URL编码
        return URLEncoder.encode(part, DEFAULT_URL_ENCODING);
    }

    /**
     * 对URL的部分文本进行解码
     *
     * @param part 需要解码的URL部分文本
     * @return 解码后的字符串
     * @throws UnsupportedEncodingException 如果字符编码不被支持
     */
    public static String urlDecode(String part) throws UnsupportedEncodingException {
        // 使用URLDecoder对URL编码的文本进行解码
        return URLDecoder.decode(part, DEFAULT_URL_ENCODING);
    }

}

3.IpUtils.java

package com.sunxiansheng.tool;

import lombok.extern.slf4j.Slf4j;
import org.springframework.util.StringUtils;

import javax.servlet.http.HttpServletRequest;
import java.net.InetAddress;

/**
 * IP工具类
 */
@Slf4j
public class IpUtils {

    private static final String DEFAULT_IP = "127.0.0.1";
    private static final String UN_KNOWN = "unknown";
    private static final int IP_MAX_LENGTH = 15;
    private static final String SPLIT = ",";

    /**
     * 获取本地IP地址
     *
     * @return 本地IP地址字符串
     */
    private static String getLocalIp() {
        try {
            InetAddress localHost = InetAddress.getLocalHost();
            String localIp = localHost.getHostAddress();
            log.info("IpUtils.getLocalIp:{}", localIp);
            return localIp;
        } catch (Exception e) {
            log.error("IpUtils.getLocalIp.error:{}", e.getMessage(), e);
            return DEFAULT_IP;
        }
    }

    /**
     * 从HttpServletRequest中获取客户端IP地址
     *
     * @param request HttpServletRequest对象
     * @return 客户端IP地址字符串
     */
    public static String getIp(HttpServletRequest request) {
        String ip = null;
        try {
            ip = request.getHeader("x-forwarded-for");
            if (StringUtils.isEmpty(ip) || UN_KNOWN.equalsIgnoreCase(ip)) {
                ip = request.getHeader("Proxy-Client-IP");
            }
            if (StringUtils.isEmpty(ip) || ip.length() == 0 || UN_KNOWN.equalsIgnoreCase(ip)) {
                ip = request.getHeader("WL-Proxy-Client-IP");
            }
            if (StringUtils.isEmpty(ip) || UN_KNOWN.equalsIgnoreCase(ip)) {
                ip = request.getHeader("HTTP_CLIENT_IP");
            }
            if (StringUtils.isEmpty(ip) || UN_KNOWN.equalsIgnoreCase(ip)) {
                ip = request.getHeader("HTTP_X_FORWARDED_FOR");
            }
            if (StringUtils.isEmpty(ip) || UN_KNOWN.equalsIgnoreCase(ip)) {
                ip = request.getRemoteAddr();
            }
        } catch (Exception e) {
            log.error("IpUtils.getIp.error:{}", e.getMessage(), e);
        }
        if (!StringUtils.isEmpty(ip) && ip.length() > IP_MAX_LENGTH) {
            if (ip.indexOf(SPLIT) > 0) {
                ip = ip.substring(0, ip.indexOf(SPLIT));
            }
        }
        return ip;
    }
}

4.LetterUtils.java

package com.sunxiansheng.tool;

import org.apache.commons.lang3.StringUtils;

import java.util.Arrays;
import java.util.List;

/**
 * 字母转换工具类
 */
public class LetterUtils {

    /**
     * 将字母转换为对应的数字。
     *
     * @param letter 要转换的字母字符串
     * @return 对应的数字值
     */
    public static long letterToNumber(String letter) {
        int length = letter.length();
        long number = 0;
        for (int i = 0; i < length; i++) {
            char ch = letter.charAt(length - i - 1);
            int num = ch - 'A' + 1;
            number += num;
        }
        return number;
    }

    /**
     * 将字符串数组按照指定的分隔符拼接成一个字符串。
     *
     * @param splitChar 分隔字符
     * @param args 字符串数组
     * @return 拼接后的字符串
     */
    public static String assembleHandler(char splitChar, String... args) {
        List<String> strList = Arrays.asList(args);
        return StringUtils.join(strList, splitChar);
    }

}

5.MaskUtils.java

package com.sunxiansheng.tool;

import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * 掩码工具类，用于隐藏敏感信息如手机号码、邮箱地址、昵称等
 */
@Slf4j
public class MaskUtils {

    /**
     * 隐藏手机号码中间的数字，仅保留前3位和后3位
     *
     * @param mobile 手机号码
     * @return 掩码后的手机号码
     */
    public static String maskMobile(String mobile) {
        if (StringUtils.isBlank(mobile)) {
            return null;
        }
        int length = mobile.length();
        char[] mobileChars = mobile.toCharArray();
        char[] resultChars = new char[mobile.length()];
        for (int i = 0; i < length; i++) {
            if (i >= 3 && i < length - 3) {
                resultChars[i] = '*';
            } else {
                resultChars[i] = mobileChars[i];
            }
        }
        return new String(resultChars);
    }

    /**
     * 隐藏邮箱地址中间的字符，仅保留@前后的字符
     *
     * @param email 邮箱地址
     * @return 掩码后的邮箱地址
     */
    public static String maskEmail(String email) {
        if (StringUtils.isBlank(email)) {
            return null;
        }
        int length = email.length();
        char[] emailChars = email.toCharArray();
        char[] resultChars = new char[email.length()];
        int atIndex = email.indexOf('@');
        for (int i = 0; i < length; i++) {
            if (i > 0 && i < atIndex - 1) {
                resultChars[i] = '*';
            } else {
                resultChars[i] = emailChars[i];
            }
        }
        return new String(resultChars);
    }

    /**
     * 过滤xml标签，提取标签中的内容
     *
     * @param html 包含xml标签的字符串
     * @return 提取出的标签内容
     */
    public static String getContext(String html) {
        String result = html;
        if (StringUtils.isBlank(html)) {
            return null;
        }
        Pattern p = Pattern.compile(">([^</]+)</");
        Matcher m = p.matcher(html);
        if (m.find()) {
            result = m.group(1);
        }
        return result;
    }

    /**
     * 隐藏昵称中间的字符，仅保留首尾字符
     *
     * @param nickName 昵称
     * @return 掩码后的昵称
     */
    public static String maskNickName(String nickName) {
        if (StringUtils.isBlank(nickName)) {
            return "";
        }
        int length = nickName.length();
        char[] nickNameChars = nickName.toCharArray();
        char[] resultChars = new char[nickName.length()];
        for (int i = 0; i < length; i++) {
            if (i > 0 && i < length - 1) {
                resultChars[i] = '*';
            } else if (i == 1 && length == 2) {
                resultChars[i] = '*';
            } else {
                resultChars[i] = nickNameChars[i];
            }
        }
        return new String(resultChars);
    }
}

6.Md5Utils.java

package com.sunxiansheng.tool;

import java.security.MessageDigest;

/**
 * MD5 加密工具类
 */
public class Md5Utils {

    /**
     * 对输入的文本进行MD5加密
     *
     * @param text 要加密的文本
     * @return 加密后的十六进制字符串
     */
    public static String encode(String text) {
        try {
            // 获取MD5消息摘要实例
            MessageDigest md = MessageDigest.getInstance("MD5");
            // 更新摘要，使用指定的字节数组
            md.update(text.getBytes());
            // 计算摘要并返回字节数组
            byte[] digest = md.digest();
            // 将字节数组转换为十六进制字符串
            StringBuilder result = new StringBuilder();
            for (byte b : digest) {
                result.append(String.format("%02x", b & 0xff));
            }
            return result.toString();
        } catch (Exception e) {
            // 捕获异常并打印堆栈信息
            e.printStackTrace();
            return null;
        }
    }

}

7.PinYin4jUtils.java

package com.sunxiansheng.tool;

import net.sourceforge.pinyin4j.PinyinHelper;
import net.sourceforge.pinyin4j.format.HanyuPinyinCaseType;
import net.sourceforge.pinyin4j.format.HanyuPinyinOutputFormat;
import net.sourceforge.pinyin4j.format.HanyuPinyinToneType;
import net.sourceforge.pinyin4j.format.HanyuPinyinVCharType;
import net.sourceforge.pinyin4j.format.exception.BadHanyuPinyinOutputFormatCombination;

/**
 * 拼音工具类，用于将汉字转换为拼音
 */
public class PinYin4jUtils {

    /**
     * 将汉字转换为全拼
     *
     * @param src 要转换的汉字字符串
     * @return 转换后的拼音字符串
     */
    public static String getPinYin(String src) {
        char[] hz = src.toCharArray();
        String[] py;
        HanyuPinyinOutputFormat format = new HanyuPinyinOutputFormat();
        format.setCaseType(HanyuPinyinCaseType.LOWERCASE);
        format.setToneType(HanyuPinyinToneType.WITHOUT_TONE);
        format.setVCharType(HanyuPinyinVCharType.WITH_V);
        StringBuilder pys = new StringBuilder();
        int len = hz.length;
        try {
            for (int i = 0; i < len; i++) {
                // 先判断是否为汉字字符
                if (Character.toString(hz[i]).matches("[\\u4E00-\\u9FA5]+")) {
                    // 将汉字的几种全拼都存到py数组中
                    py = PinyinHelper.toHanyuPinyinStringArray(hz[i], format);
                    // 取出该汉字全拼的第一种读音，并存放到字符串pys后
                    pys.append(py[0]);
                } else {
                    // 如果不是汉字字符，间接取出字符并连接到pys后
                    pys.append(hz[i]);
                }
            }
        } catch (BadHanyuPinyinOutputFormatCombination e) {
            e.printStackTrace();
        }
        return pys.toString();
    }

    /**
     * 提取每个汉字的首字母
     *
     * @param str 要转换的汉字字符串
     * @return 转换后的拼音首字母字符串
     */
    public static String getPinYinHeadChar(String str) {
        StringBuilder convert = new StringBuilder();
        for (int i = 0; i < str.length(); i++) {
            char word = str.charAt(i);
            // 提取汉字的首字母
            String[] pinyinArray = PinyinHelper.toHanyuPinyinStringArray(word);
            if (pinyinArray != null) {
                convert.append(pinyinArray[0].charAt(0));
            } else {
                convert.append(word);
            }
        }
        return convert.toString().toUpperCase();
    }

    /**
     * 提取首个汉字的首字母
     *
     * @param str 要转换的汉字字符串
     * @return 转换后的首字母
     */
    public static String getPinYinFirstHeadChar(String str) {
        String convert = "";
        String reg = "[^\u4e00-\u9fa5]";
        str = str.replaceAll(reg, "").replace(" ", "");
        if (str.length() > 0) {
            char word = str.charAt(0);
            // 提取汉字的首字母
            String[] pinyinArray = PinyinHelper.toHanyuPinyinStringArray(word);
            if (pinyinArray != null) {
                convert += pinyinArray[0].charAt(0);
            } else {
                convert += word;
            }
            return convert.toUpperCase();
        } else {
            return "";
        }
    }

    /**
     * 将字符串转换为ASCII码
     *
     * @param str 要转换的字符串
     * @return 转换后的ASCII码字符串
     */
    public static String getCnASCII(String str) {
        StringBuilder buf = new StringBuilder();
        // 将字符串转换成字节序列
        byte[] bGBK = str.getBytes();
        for (byte b : bGBK) {
            // 将每个字符转换成ASCII码
            buf.append(Integer.toHexString(b & 0xff));
        }
        return buf.toString();
    }
}

8.PropertiesUtils.java

package com.sunxiansheng.tool;

import lombok.extern.slf4j.Slf4j;

import java.io.File;
import java.io.FileInputStream;
import java.net.URISyntaxException;
import java.net.URL;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;

/**
 * 属性文件读取工具类
 * 用于读取属性文件（properties）的工具类
 */
@Slf4j
public class PropertiesUtils {

    /**
     * 属性文件与属性集合的关系
     * Map 用于存储每个属性文件的属性键值对
     */
    private Map<String, Properties> propertiesMap = new HashMap<>();

    /**
     * 属性文件与修改时间的关系
     * Map 用于存储每个属性文件的最后修改时间
     */
    private Map<String, Long> modifyTimeMap = new HashMap<>();

    /**
     * 指定的属性文件的目录路径
     */
    private String configPath = "";

    /**
     * 单例模式构造方法私有化
     */
    private PropertiesUtils() {
    }

    /**
     * 静态内部类单例模式
     */
    private static class SingleHolder {
        private static final PropertiesUtils INSTANCE = new PropertiesUtils();
    }

    /**
     * 获取 PropertiesUtils 实例
     *
     * @return PropertiesUtils 实例
     */
    public static PropertiesUtils getInstance() {
        return SingleHolder.INSTANCE;
    }

    /**
     * 配置属性文件目录路径
     *
     * @param path 属性文件目录路径
     */
    public void configure(String path) {
        this.configPath = path;
    }

    /**
     * 获取指定属性的值
     *
     * @param propertyFileName 属性文件名
     * @param key 属性键
     * @return 属性值
     */
    public String getPropertyValue(String propertyFileName, String key) {
        String fileName = convertPropertiesFileName(propertyFileName);
        try {
            if (propertiesMap.get(fileName) == null) {
                loadProperties(fileName);
            } else {
                checkPropertiesFileModified(fileName);
            }
            return propertiesMap.get(fileName).getProperty(key);
        } catch (Exception e) {
            log.error("PropertiesUtils.getPropertyValue.error:{}", e.getMessage(), e);
        }
        return "";
    }

    /**
     * 对传入的属性文件名称进行处理，如果包含.properties后缀则去掉
     *
     * @param propertyFileName 属性文件名
     * @return 处理后的属性文件名
     */
    private String convertPropertiesFileName(String propertyFileName) {
        String fileName = propertyFileName;
        if (fileName.endsWith(".properties")) {
            int index = fileName.lastIndexOf(".");
            fileName = fileName.substring(0, index);
        }
        return fileName;
    }

    /**
     * 加载指定名称的属性文件
     *
     * @param shortPropertyFileName 属性文件短名（不包含路径和扩展名）
     * @throws URISyntaxException URI语法异常
     */
    private void loadProperties(String shortPropertyFileName) throws URISyntaxException {
        File file = getPropertiesFile(shortPropertyFileName);
        Long newTime = file.lastModified();
        if (propertiesMap.get(shortPropertyFileName) != null) {
            propertiesMap.remove(shortPropertyFileName);
        }
        Properties props = new Properties();
        try {
            props.load(new FileInputStream(file));
        } catch (Exception e) {
            log.error("PropertiesUtils.loadProperties.error:{}", e.getMessage(), e);
        }
        propertiesMap.put(shortPropertyFileName, props);
        modifyTimeMap.put(shortPropertyFileName, newTime);
    }

    /**
     * 检查属性文件有无更新，若更新则重新加载
     *
     * @param shortPropertyFileName 属性文件短名（不包含路径和扩展名）
     * @throws URISyntaxException URI语法异常
     */
    private void checkPropertiesFileModified(String shortPropertyFileName) throws URISyntaxException {
        File file = getPropertiesFile(shortPropertyFileName);
        Long newTime = file.lastModified();
        Long lastModifiedTime = modifyTimeMap.get(shortPropertyFileName);
        if (newTime == 0) {
            if (lastModifiedTime == null) {
                log.error(shortPropertyFileName + ".properties file does not exist!");
            }
        } else if (newTime > lastModifiedTime) {
            loadProperties(shortPropertyFileName);
        }
    }

    /**
     * 获取属性文件的绝对路径
     *
     * @param shortPropertyFileName 属性文件短名（不包含路径和扩展名）
     * @return 属性文件对象
     * @throws URISyntaxException URI语法异常
     */
    private File getPropertiesFile(String shortPropertyFileName) throws URISyntaxException {
        File propertiesFile;
        if (this.configPath != null && !this.configPath.trim().isEmpty()) {
            return new File(this.configPath + File.separator + shortPropertyFileName + ".properties");
        }
        String dir = System.getProperty("user.dir") + File.separator + shortPropertyFileName + ".properties";
        propertiesFile = new File(dir);
        if (!propertiesFile.exists()) {
            URL url = PropertiesUtils.class.getResource("/" + shortPropertyFileName + ".properties");
            if (url == null) {
                propertiesFile = null;
            } else {
                propertiesFile = new File(url.toURI());
            }
        }
        return propertiesFile;
    }
}

9.SimpleDateFormatUtils.java

package com.sunxiansheng.tool;

import java.text.SimpleDateFormat;

/**
 * SimpleDateFormat 工具类
 * 用于提供线程安全的 SimpleDateFormat 实例
 */
public class SimpleDateFormatUtils {

    // 使用 ThreadLocal 提供线程安全的 SimpleDateFormat 实例
    private static final ThreadLocal<SimpleDateFormat> THREAD_LOCAL = new ThreadLocal<SimpleDateFormat>() {
        /**
         * 初始化 SimpleDateFormat 实例
         * @return SimpleDateFormat 实例，格式为 "yyyy-MM-dd HH:mm:ss"
         */
        @Override
        protected SimpleDateFormat initialValue() {
            return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        }
    };

    /**
     * 获取时间格式化实例
     * @return SimpleDateFormat 实例，格式为 "yyyy-MM-dd HH:mm:ss"
     */
    public static SimpleDateFormat getTime() {
        SimpleDateFormat simpleDateFormat = THREAD_LOCAL.get();
        // 如果 THREAD_LOCAL 中没有 SimpleDateFormat 实例，则创建新的实例
        if (simpleDateFormat == null) {
            return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        }
        return simpleDateFormat;
    }

}

10.SpringContextUtils.java

package com.sunxiansheng.tool;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.NoSuchBeanDefinitionException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.util.Map;

/**
 * Spring上下文工具类，用于获取Spring容器中的Bean及HTTP请求、响应、会话对象。
 * 实现ApplicationContextAware接口，以便自动注入ApplicationContext。
 * 通过Spring的@Component注解注册为Spring Bean。
 */
@Component
public class SpringContextUtils implements ApplicationContextAware {

    // Spring应用上下文环境
    private static ApplicationContext applicationContext;

    /**
     * 实现ApplicationContextAware接口的setApplicationContext方法，用于注入ApplicationContext。
     * @param applicationContext Spring应用上下文
     * @throws BeansException Beans异常
     */
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }

    /**
     * 获取Spring应用上下文。
     * @return Spring应用上下文
     */
    public static ApplicationContext getApplicationContext() {
        return applicationContext;
    }

    /**
     * 根据名称获取Bean。
     * @param name Bean名称
     * @return Bean实例
     * @throws BeansException Beans异常
     */
    public static Object getBean(String name) throws BeansException {
        return applicationContext.getBean(name);
    }

    /**
     * 根据名称和类型获取Bean。
     * @param name Bean名称
     * @param requiredType Bean类型
     * @return Bean实例
     * @throws BeansException Beans异常
     */
    public static Object getBean(String name, Class requiredType) throws BeansException {
        return applicationContext.getBean(name, requiredType);
    }

    /**
     * 根据类型获取Bean。
     * @param requiredType Bean类型
     * @return Bean实例
     * @throws BeansException Beans异常
     */
    public static Object getBean(Class requiredType) throws BeansException {
        return applicationContext.getBean(requiredType);
    }

    /**
     * 根据类型获取Bean，返回指定类型的实例。
     * @param <T> Bean类型
     * @param clazz Bean类
     * @return Bean实例
     */
    public static <T> T getBeanByType(Class<T> clazz) {
        return applicationContext.getBean(clazz);
    }

    /**
     * 判断是否包含指定名称的Bean。
     * @param name Bean名称
     * @return 是否包含指定名称的Bean
     */
    public static boolean containsBean(String name) {
        return applicationContext.containsBean(name);
    }

    /**
     * 判断指定名称的Bean是否为单例。
     * @param name Bean名称
     * @return 是否为单例
     * @throws NoSuchBeanDefinitionException 没有找到指定名称的Bean异常
     */
    public static boolean isSingleton(String name) throws NoSuchBeanDefinitionException {
        return applicationContext.isSingleton(name);
    }

    /**
     * 获取指定名称的Bean的类型。
     * @param name Bean名称
     * @return Bean类型
     * @throws NoSuchBeanDefinitionException 没有找到指定名称的Bean异常
     */
    public static Class getType(String name) throws NoSuchBeanDefinitionException {
        return applicationContext.getType(name);
    }

    /**
     * 获取指定类型的所有Bean。
     * @param <T> Bean类型
     * @param clazz Bean类
     * @return Bean实例Map
     * @throws NoSuchBeanDefinitionException 没有找到指定名称的Bean异常
     */
    public static <T> Map<String, T> getBeanOfType(Class<T> clazz) throws NoSuchBeanDefinitionException {
        return applicationContext.getBeansOfType(clazz);
    }

    /**
     * 获取指定名称的Bean的别名。
     * @param name Bean名称
     * @return Bean别名数组
     * @throws NoSuchBeanDefinitionException 没有找到指定名称的Bean异常
     */
    public static String[] getAliases(String name) throws NoSuchBeanDefinitionException {
        return applicationContext.getAliases(name);
    }

    /**
     * 获取当前HTTP请求对象。
     * @return 当前HTTP请求对象
     */
    public static HttpServletRequest getHttpServletRequest() {
        return ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
    }

    /**
     * 获取当前HTTP响应对象。
     * @return 当前HTTP响应对象
     */
    public static HttpServletResponse getHttpServletResponse() {
        return ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getResponse();
    }

    /**
     * 获取当前HTTP会话对象。
     * @return 当前HTTP会话对象
     */
    public static HttpSession getHttpSession() {
        HttpServletRequest request = getHttpServletRequest();
        return request.getSession();
    }
}

11.ThreadPoolUtils.java

package com.sunxiansheng.tool;

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.TimeUnit;

/**
 * 线程池工具类
 */
@Slf4j
public class ThreadPoolUtils {

    /**
     * 私有构造方法，防止实例化该工具类。
     */
    private ThreadPoolUtils() {
    }

    /**
     * 优雅地关闭线程池
     *
     * @param pool 需要关闭的线程池
     * @param shutdownTimeout 调用shutdown后等待线程池终止的时间
     * @param shutdownNowTimeout 调用shutdownNow后等待线程池终止的时间
     * @param timeUnit 时间单位
     */
    public static void shutdownPool(ExecutorService pool, int shutdownTimeout, int shutdownNowTimeout, TimeUnit timeUnit) {
        // 调用shutdown以开始优雅地关闭线程池
        pool.shutdown();
        try {
            // 等待所有任务完成或超时
            if (!pool.awaitTermination(shutdownTimeout, timeUnit)) {
                // 调用shutdownNow强制关闭线程池
                pool.shutdownNow();
                // 再次等待所有任务完成或超时
                if (!pool.awaitTermination(shutdownNowTimeout, timeUnit)) {
                    log.error("ThreadPoolUtils.shutdownPool.error");
                }
            }
        } catch (InterruptedException ie) {
            // 捕获中断异常并记录错误信息
            log.error("ThreadPoolUtils.shutdownPool.interrupted.error:{}", ie.getMessage(), ie);
            // 再次调用shutdownNow强制关闭线程池
            pool.shutdownNow();
            // 设置当前线程中断状态
            Thread.currentThread().interrupt();
        }
    }
}

12.UuidUtils.java

package com.sunxiansheng.tool;

import java.util.UUID;

/**
 * UUID工具类
 */
public class UuidUtils {

    // 字符集，用于生成短UUID
    public static String[] chars = new String[]{
            "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u",
            "v", "w", "x", "y", "z", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C", "D", "E", "F",
            "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z"};

    /**
     * 生成标准的UUID字符串
     *
     * @return UUID字符串
     */
    public static String getUuid() {
        return UUID.randomUUID().toString();
    }

    /**
     * 生成去除“-”的32位UUID字符串
     *
     * @return 去除“-”的UUID字符串
     */
    public static String getUuid32() {
        return UUID.randomUUID().toString().replace("-", "");
    }

    /**
     * 生成8位短UUID字符串
     *
     * @return 8位短UUID字符串
     */
    public static String getUuid8() {
        StringBuilder shortBuffer = new StringBuilder();
        // 生成UUID，并去除“-”
        String uuid = UUID.randomUUID().toString().replace("-", "");
        // 将UUID分为8组，每组4位
        for (int i = 0; i < 8; i++) {
            // 取出每组的4位字符串
            String str = uuid.substring(i * 4, i * 4 + 4);
            // 将4位字符串转换为16进制表示的int类型
            int x = Integer.parseInt(str, 16);
            // 取模62，将结果作为索引取出字符集中的字符
            shortBuffer.append(chars[x % 62]);
        }
        return shortBuffer.toString();
    }
}