JAVA开发代码小工具集合

前言

        这些工具都是日常开发中能用到的，前后端都有，觉得好用就拿过来了…

编号生成工具

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.Random;
import java.math.BigDecimal;
import java.text.SimpleDateFormat;
import java.util.Calendar;

public class UniqueCodeGenerator {
    public static void main(String[] args) {
        // 示例调用
        System.out.println(generateUniqueCode("yyyyMMdd", 6)); // 20250318XXXXXX
        System.out.println(generateUniqueCode("yyyy-MM-dd", 8)); // 2025-03-18XXXXXXXX
        System.out.println(generateUniqueCode("yyyyMMddHHmmss", 4)); // 20250318123045XXXX
        for(long i=0;i<100;i++)
		{
			//String timestampPart = ""+(Math.random() * 10000) * (System.currentTimeMillis()/10000);
			//System.out.println(timestampPart);
			//System.out.println(generateOrderSn(i));
			System.out.println(generateUnionPaySn());
		}
    }

    /**
     * 生成唯一编码，格式为 日期 + 指定位数的随机数字
     * @param dateFormat 日期格式（如 "yyyyMMdd", "yyyy-MM-dd HH:mm:ss"）
     * @param randomDigits 生成的随机数字位数
     * @return 组合后的唯一编码字符串
     */
    public static String generateUniqueCode(String dateFormat, int randomDigits) {
        // 格式化当前日期
        String date = LocalDateTime.now().format(DateTimeFormatter.ofPattern(dateFormat));

        // 生成指定位数的随机数字
        String randomNumber = generateRandomNumber(randomDigits);

        // 拼接返回
        return date + randomNumber;
    }

    /**
     * 生成指定位数的随机数字字符串
     * @param length 随机数字的长度
     * @return 生成的随机数字字符串
     */
    private static String generateRandomNumber(int length) {
        Random random = new Random();
        StringBuilder sb = new StringBuilder();

        for (int i = 0; i < length; i++) {
            sb.append(random.nextInt(10)); // 生成 0-9 之间的随机数字
        }

        return sb.toString();
    }
/**
	 * 获取商品编码
	 * 商品编码规则：nanoTime(后5位)*5位随机数(10000~99999)
	 * @return
	 */
	public static String generateProductCode(){
		long nanoPart = System.nanoTime() % 100000L;
		if(nanoPart<10000L){
			nanoPart+=10000L;
		}
		long randomPart = (long)(Math.random()*(90000)+10000);
		String code = "0"+String.valueOf((new BigDecimal(nanoPart).multiply(new BigDecimal(randomPart))));
		return code.substring(code.length()-10);
	}
	
	/**
	 * @param id: 用户id
	 * 生成订单编号
	 * 订单编号规则：(10位)：(年末尾*月，取后2位)+（用户ID%3.33*日取整后2位）+(timestamp*10000以内随机数，取后6位)
	 * @return
	 */
	public static String generateOrderSn(long id){
		Calendar calendar = Calendar.getInstance();
		int year = calendar.get(Calendar.YEAR);
		year = year % 10;
		if(year == 0) year = 10;
		int month = calendar.get(Calendar.MONTH)+1;
		int yearMonth  =  year * month;
		String yearMonthPart = "0"+yearMonth;
		yearMonthPart = yearMonthPart.substring(yearMonthPart.length() - 2 );
		
		int day = calendar.get(Calendar.DAY_OF_MONTH);
		int dayNum = (int)((id % 3.33) * day);
		String dayPart = "0"+dayNum;
		dayPart = dayPart.substring(dayPart.length() - 2);
		
		String timestampPart = ""+(Math.random() * 10000) * (System.currentTimeMillis()/10000);
		timestampPart = timestampPart.replace(".", "").replace("E", "");
		timestampPart = timestampPart.substring(0,6);
		return yearMonthPart+dayPart+timestampPart;
	}
	
	/**
	 * 生成统一支付单号
	 * 规则：年(2)月(2)日(2)时(2)分(2)+timestamp*5位随机整数取后5位
	 * @return
	 */
	public static String generateUnionPaySn(){
		Calendar calendar = Calendar.getInstance();
		SimpleDateFormat dateFormat = new SimpleDateFormat("yyyyMMddhhmm");
		String dateTime = dateFormat.format(calendar.getTime());
		dateTime = dateTime.substring(2);
		String timestampPart = ""+(Math.random() * 10000) * (System.currentTimeMillis()/10000);
		timestampPart = timestampPart.replace(".", "").replace("E", "");
		timestampPart = timestampPart.substring(0,5);
		return dateTime+timestampPart;
	}
	
}

EasyExcel 工具

import com.alibaba.excel.EasyExcel;
import com.alibaba.excel.ExcelWriter;
import com.alibaba.excel.write.handler.WriteHandler;
import com.alibaba.excel.write.metadata.WriteSheet;
import com.alibaba.excel.write.metadata.fill.FillConfig;
import lombok.extern.slf4j.Slf4j;
import lombok.var;

import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.InputStream;
import java.net.URLEncoder;
import java.util.List;
import java.util.Map;

/**
 * @author huabin
 * @version 1.0.0
 * @createTime 2024-12-27
 */
@Slf4j
public class ExcelUtil {

    /**
     * 导出Excel(不指定模板，需要自定义Excel映射字段)
     *
     * @param fileName      文件名
     * @param data          数据
     * @param response      响应流
     * @param clazz         自定义Excel 映射类
     * @param writeHandlers 表头的样式策略 ：LongestMatchColumnWidthStyleStrategy 最长匹配列宽样式策略 ...
     * @param <T>           实体类
     */
    public static <T> void exportToExcel(String fileName, String sheetName, List<T> data, HttpServletResponse response, Class<T> clazz, WriteHandler... writeHandlers) {
        ServletOutputStream out = null;
        try {
            // 设置响应头
            response.setContentType("application/x-msdownload");
            response.setCharacterEncoding("utf-8");
            response.setHeader("Content-Disposition", "attachment;filename=" + URLEncoder
                    .encode(fileName + ".xlsx", "UTF-8").replaceAll("\\+", "%20"));

            out = response.getOutputStream();
            sheetName = "".equals(sheetName) ? "Sheet1" : sheetName;
            // 构建 EasyExcel 写入
            var writer = EasyExcel.write(out, clazz).autoCloseStream(true).sheet(sheetName);
            if (writeHandlers != null) {
                for (WriteHandler handler : writeHandlers) {
                    writer.registerWriteHandler(handler);
                }
            }

            writer.doWrite(data);

            out.flush();
        } catch (Exception e) {
            log.info("导出文件：{}，失败：{}", fileName, e.getMessage());
            sendErrorResponse(response, "导出失败");
        } finally {
            if (out != null) {
                try {
                    out.close();
                } catch (IOException ioException) {
                    log.error("关闭输出流失败: {}", ioException.getMessage());
                }
            }
        }
    }

    /**
     * 导出Excel文件基于模版的方式
     *
     * @param fileName    文件名
     * @param data        数据源 模板中的映射属性名  {.property}
     * @param response    响应流
     * @param inputStream 文件输入流
     * @param map         自定义行 key-value
     * @param <T>         类
     */
    public static <T> void exportExcelToTemplate(String fileName,
                                                 List<T> data,
                                                 HttpServletResponse response,
                                                 InputStream inputStream,
                                                 Map<String, Object> map) {
        ServletOutputStream out = null;
        try {
            response.reset();
            //设置响三件套
            response.setContentType("application/x-msdownload");
            response.setCharacterEncoding("utf-8");
            response.setHeader("Content-Disposition", "attachment;filename=" + URLEncoder
                    .encode(fileName + ".xlsx", "UTF-8").replaceAll("\\+", "%20"));

            out = response.getOutputStream();
            //写入数据
            ExcelWriter excelWriter = EasyExcel.write(out).withTemplate(inputStream).build();
            WriteSheet writeSheet = EasyExcel.writerSheet().build();

            //指定列表数据配置模式-基于模板填充数据
            FillConfig fillConfig = FillConfig.builder().forceNewRow(Boolean.TRUE).build();
            excelWriter.fill(map, writeSheet);
            // 填充集合 {.property}
            excelWriter.fill(data, fillConfig, writeSheet);
            excelWriter.finish();
            //关闭流
            out.flush();
        } catch (Exception e) {
            log.info("导出文件：{}，失败：{}", fileName, e.getMessage());
            throw new RuntimeException("导出 Excel 文件失败");
        }
    }


    private static void sendErrorResponse(HttpServletResponse response, String message) {
        try {
            response.reset();
            response.setContentType("application/json");
            response.setCharacterEncoding("utf-8");
            String errorResponse = String.format("{\"code\":-1,\"message\":\"%s\",\"data\":null}", message);
            response.getWriter().write(errorResponse);
        } catch (IOException ioException) {
            log.error("返回错误响应失败: {}", ioException.getMessage());
        }
    }

}

断言工具

import cn.hbcs.common.constants.Constants;
import cn.hbcs.common.exception.GlobalException;

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

//断言工具
public class AssertUtil {

    //手机的正则表达式
    public static void isPhone(String phone,String message){
        Pattern CHINA_PATTERN_PHONE = Pattern.compile( "^((13[0-9])|(14[0,1,4-9])|(15[0-3,5-9])|(16[2,5,6,7])|(17[0-8])|(18[0-9])|(19[0-3,5-9]))\\d{8}$");
        Matcher m = CHINA_PATTERN_PHONE.matcher(phone);
        if(!m.matches()){
            throw new GlobalException(message);
        }
    }


    //字符串不为空
    public static void isNotEmpty(String text, String message) {
        if (text == null || text.trim().length() == 0) {
            throw new GlobalException(message);
        }
    }

    //列表不为空
    public static void isNotEmpty(List list, String message) {
        if (list == null || list.size() == 0) {
            throw new GlobalException(message);
        }
    }

    //对象为空
    public static void isNull(Object obj , String message){
        if(obj != null){
            throw new GlobalException(message);
        }
    }
    //对象不为空
    public static void isNotNull(Object obj , String message){
        if(obj == null){
            throw new GlobalException(message);
        }
    }
    //断言为false
    public static void isFalse(boolean isFalse , String message){
        if(isFalse){
            throw new GlobalException(message);
        }
    }
    //断言为false
    public static void isTrue(boolean isTrue , String message){
        if(!isTrue){
            throw new GlobalException(message);
        }
    }
    //int值比较
    public static void isEquals(int s1,int s2 , String message){
        if(s1 != s2){
            throw new GlobalException(message);
        }
    }
    //是否包含
    public static void isIn(Integer s1,List<Integer> s2 , String message){
        if(!s2.contains(s1)){
            throw new GlobalException(message);
        }
    }
    //字符串比较
    public static void isEquals(String s1,String s2 , String message){
        isNotEmpty(s1, "不可为空");
        isNotEmpty(s2, "不可为空");
        if(!s1.equals(s2)){
            throw new GlobalException(message);
        }
    }
    //字符串去空格比较
    public static void isEqualsTrim(String s1,String s2 , String message){
        isNotEmpty(s1, "不可为空");
        isNotEmpty(s2, "不可为空");
        if(!s1.trim().equals(s2.trim())){
            throw new GlobalException(message);
        }
    }
    //字符串忽略大小写比较
    public static void isEqualsIgnoreCase(String s1,String s2 , String message){
        isNotEmpty(s1, "不可为空");
        isNotEmpty(s2, "不可为空");
        if(!s1.trim().equalsIgnoreCase(s2.trim())){
            throw new GlobalException(message);
        }
    }

}


public class GlobalException extends RuntimeException{
    public GlobalException(String message) {
        super(message);
    }
}

HTTP 工具

import org.apache.commons.httpclient.HttpClient;
import org.apache.commons.httpclient.NameValuePair;
import org.apache.commons.httpclient.methods.PostMethod;

import java.util.Iterator;
import java.util.Map;
import java.util.Set;

/**--------------------------------------------------------
Http工具类

<dependency>
    <groupId>commons-codec</groupId>
    <artifactId>commons-codec</artifactId>
    <version>1.4</version>
</dependency>

<dependency>
    <groupId>commons-httpclient</groupId>
    <artifactId>commons-httpclient</artifactId>
    <version>3.1</version>
</dependency>
--------------------------------------------------------**/
public class HttpUtil {

    /** 发送post请求
     * map.put("Uid" ,"xxx");
     * map.put("Key" ,"xxxxx");
     * **/
    public static String sendPost(String url,Map<String,String> param){

        //结果
        String result = null;

        try {
            //创建http客户端
            HttpClient client = new HttpClient();
            //创建Post请求
            PostMethod post = new PostMethod(url);
            //设置请求头
            //在头文件中设置转码
            post.addRequestHeader("Content-Type","application/x-www-form-urlencoded;charset=utf-8");

            //封装参数
            if(param != null && !param.isEmpty()){
                Set<String> keySet = param.keySet();

                //取出所有的key
                Iterator<String> iterator = keySet.iterator();

                //用来封装参数的数组
                NameValuePair[] data = new NameValuePair[keySet.size()];

                int index = 0 ;

                while (iterator.hasNext()){
                    String key = iterator.next();
                    String value = param.get(key);
                    data[index++] = new NameValuePair(key, value);
                }
                //把数据设置到请求体
                post.setRequestBody(data);
            }

            //执行发送
            client.executeMethod(post);

            //得到响应结果
            result = new String(post.getResponseBodyAsString().getBytes("utf-8"));

            post.releaseConnection();
        }catch (Exception e){
            e.printStackTrace();
            throw new RuntimeException("网络请求失败["+e.getMessage()+"]");
        }

        return result;
    }

}

字符串 工具

import org.springframework.util.StringUtils;

import java.net.URLDecoder;
import java.util.*;

/**
 * @author huabin
 * @date 2018/10/26-16:16
 */
public class StrUtils {

    //把参数转成map 如：  aa=bb&cc=xx
    //扩展参数
    public static Map<String,Object> params2Map(String passback_params){
        if(!StringUtils.hasLength(passback_params))return null;

        Map<String,Object> map = new HashMap<>();
        try{
            ///aaaa=bbb&ccc=1,2
            if(passback_params.indexOf("&") < 0){
                String[] params = passback_params.split("=");
                map.put(params[0],params[1]);
            }else{
                String[] params = passback_params.split("&");
                for (String param : params) {
                    String[] paramKeyValue = param.split("=");
                    map.put(paramKeyValue[0],paramKeyValue[1]);
                }
            }
        }catch (Exception e){
            e.printStackTrace();
        }
        return map;
    }


    /**
     * 把逗号分隔的字符串转换字符串数组
     *
     * @param str
     * @return
     */
    public static String[] splitStr2StrArr(String str,String split) {
        if (str != null && !str.equals("")) {
            return str.split(split);
        }
        return null;
    }


    /**
     * 把逗号分隔字符串转换List的Long
     *
     * @param str
     * @return
     */
    public static List<Long> splitStr2LongArr(String str) {
        String[] strings = splitStr2StrArr(str,",");
        if (strings == null) return null;

        List<Long> result = new ArrayList<>();
        for (String string : strings) {
            result.add(Long.parseLong(string));
        }

        return result;
    }
    /**
     * 把逗号分隔字符串转换List的Long
     *
     * @param str
     * @return
     */
    public static List<Long> splitStr2LongArr(String str,String split) {
        String[] strings = splitStr2StrArr(str,split);
        if (strings == null) return null;

        List<Long> result = new ArrayList<>();
        for (String string : strings) {
            result.add(Long.parseLong(string));
        }

        return result;
    }

    public static String getRandomString(int length) {
        String str = "0123456789";
        Random random = new Random();
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < length; i++) {
            int number = random.nextInt(10);
            sb.append(str.charAt(number));
        }
        return sb.toString();

    }

    public static String getComplexRandomString(int length) {
        String str = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
        Random random = new Random();
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < length; i++) {
            int number = random.nextInt(62);
            sb.append(str.charAt(number));
        }
        return sb.toString();
    }

    public static String convertPropertiesToHtml(String properties){
        //1:容量:6:32GB_4:样式:12:塑料壳
        StringBuilder sBuilder = new StringBuilder();
        String[] propArr = properties.split("_");
        for (String props : propArr) {
            String[] valueArr = props.split(":");
            sBuilder.append(valueArr[1]).append(":").append(valueArr[3]).append("<br>");
        }
        return sBuilder.toString();
    }

}

验证码生成工具

package cn.itsource.ymcc.util;

import sun.misc.BASE64Encoder;

import javax.imageio.ImageIO;
import java.awt.*;
import java.awt.geom.AffineTransform;
import java.awt.image.BufferedImage;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.util.Arrays;
import java.util.Random;
 
/**
 * Created by huabin
 * on 2018/5/11
 */
public class VerifyCodeUtils {

    //使用到Algerian字体，系统里没有的话需要安装字体，字体只显示大写，去掉了1,0,i,o几个容易混淆的字符
    public static final String VERIFY_CODES = "23456789ABCDEFGHJKLMNPQRSTUVWXYZ";
    private static Random random = new Random();
 
 
    /**
     * 使用系统默认字符源生成验证码
     *
     * @param verifySize 验证码长度
     * @return
     */
    public static String generateVerifyCode(int verifySize) {
        return generateVerifyCode(verifySize, VERIFY_CODES);
    }
 
    /**
     * 使用指定源生成验证码
     *
     * @param verifySize 验证码长度
     * @param sources    验证码字符源
     * @return
     */
    public static String generateVerifyCode(int verifySize, String sources) {
        if (sources == null || sources.length() == 0) {
            sources = VERIFY_CODES;
        }
        int codesLen = sources.length();
        Random rand = new Random(System.currentTimeMillis());
        StringBuilder verifyCode = new StringBuilder(verifySize);
        for (int i = 0; i < verifySize; i++) {
            verifyCode.append(sources.charAt(rand.nextInt(codesLen - 1)));
        }
        return verifyCode.toString();
    }
 
    /**
     * 输出指定验证码图片流
     *
     */
    public static void outputImage(int w, int h, OutputStream os, String code) throws IOException {
        int verifySize = code.length();
        BufferedImage image = new BufferedImage(w, h, BufferedImage.TYPE_INT_RGB);
        Random rand = new Random();
        Graphics2D g2 = image.createGraphics();
        g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
        Color[] colors = new Color[5];
        Color[] colorSpaces = new Color[]{Color.WHITE, Color.CYAN,
                Color.GRAY, Color.LIGHT_GRAY, Color.MAGENTA, Color.ORANGE,
                Color.PINK, Color.YELLOW};
        float[] fractions = new float[colors.length];
        for (int i = 0; i < colors.length; i++) {
            colors[i] = colorSpaces[rand.nextInt(colorSpaces.length)];
            fractions[i] = rand.nextFloat();
        }
        Arrays.sort(fractions);
 
        g2.setColor(Color.GRAY);// 设置边框色
        g2.fillRect(0, 0, w, h);
 
        Color c = getRandColor(200, 250);
        g2.setColor(c);// 设置背景色
        g2.fillRect(0, 2, w, h - 4);
 
        //绘制干扰线
        Random random = new Random();
        g2.setColor(getRandColor(160, 200));// 设置线条的颜色
        for (int i = 0; i < 20; i++) {
            int x = random.nextInt(w - 1);
            int y = random.nextInt(h - 1);
            int xl = random.nextInt(6) + 1;
            int yl = random.nextInt(12) + 1;
            g2.drawLine(x, y, x + xl + 40, y + yl + 20);
        }
 
        // 添加噪点
        float yawpRate = 0.05f;// 噪声率
        int area = (int) (yawpRate * w * h);
        for (int i = 0; i < area; i++) {
            int x = random.nextInt(w);
            int y = random.nextInt(h);
            int rgb = getRandomIntColor();
            image.setRGB(x, y, rgb);
        }
 
        shear(g2, w, h, c);// 使图片扭曲
 
        g2.setColor(getRandColor(100, 160));
        int fontSize = h - 4;
        Font font = new Font("Algerian", Font.ITALIC, fontSize);
        g2.setFont(font);
        char[] chars = code.toCharArray();
        for (int i = 0; i < verifySize; i++) {
            AffineTransform affine = new AffineTransform();
            affine.setToRotation(Math.PI / 4 * rand.nextDouble() * (rand.nextBoolean() ? 1 : -1), (w / verifySize) * i + fontSize / 2, h / 2);
            g2.setTransform(affine);
            g2.drawChars(chars, i, 1, ((w - 10) / verifySize) * i + 5, h / 2 + fontSize / 2 - 10);
        }
 
        g2.dispose();
        ImageIO.write(image, "jpg", os);
    }
 
    private static Color getRandColor(int fc, int bc) {
        if (fc > 255)
            fc = 255;
        if (bc > 255)
            bc = 255;
        int r = fc + random.nextInt(bc - fc);
        int g = fc + random.nextInt(bc - fc);
        int b = fc + random.nextInt(bc - fc);
        return new Color(r, g, b);
    }
 
    private static int getRandomIntColor() {
        int[] rgb = getRandomRgb();
        int color = 0;
        for (int c : rgb) {
            color = color << 8;
            color = color | c;
        }
        return color;
    }
 
    private static int[] getRandomRgb() {
        int[] rgb = new int[3];
        for (int i = 0; i < 3; i++) {
            rgb[i] = random.nextInt(255);
        }
        return rgb;
    }
 
    private static void shear(Graphics g, int w1, int h1, Color color) {
        shearX(g, w1, h1, color);
        shearY(g, w1, h1, color);
    }
 
    private static void shearX(Graphics g, int w1, int h1, Color color) {
 
        int period = random.nextInt(2);
 
        boolean borderGap = true;
        int frames = 1;
        int phase = random.nextInt(2);
 
        for (int i = 0; i < h1; i++) {
            double d = (double) (period >> 1)
                    * Math.sin((double) i / (double) period
                    + (6.2831853071795862D * (double) phase)
                    / (double) frames);
            g.copyArea(0, i, w1, 1, (int) d, 0);
            if (borderGap) {
                g.setColor(color);
                g.drawLine((int) d, i, 0, i);
                g.drawLine((int) d + w1, i, w1, i);
            }
        }
 
    }
 
    private static void shearY(Graphics g, int w1, int h1, Color color) {
 
        int period = random.nextInt(40) + 10; // 50;
 
        boolean borderGap = true;
        int frames = 20;
        int phase = 7;
        for (int i = 0; i < w1; i++) {
            double d = (double) (period >> 1)
                    * Math.sin((double) i / (double) period
                    + (6.2831853071795862D * (double) phase)
                    / (double) frames);
            g.copyArea(i, 0, 1, h1, 0, (int) d);
            if (borderGap) {
                g.setColor(color);
                g.drawLine(i, (int) d, i, 0);
                g.drawLine(i, (int) d + h1, i, h1);
            }
 
        }
 
    }
 
    /**
     * 获取随机验证码及其加密图片
     *
     */
    public static String verifyCode(int w, int h, String code)  {
        //创建一个 BASE64编码器
        BASE64Encoder encoder = new BASE64Encoder();
        //二进制输出流，用来装图片的
        ByteArrayOutputStream data = new ByteArrayOutputStream();
        //画一个w宽，h高的图片，把code画上去，然后把图片写入 data
        try {
            outputImage(w, h, data, code);
        } catch (IOException e) {
            e.printStackTrace();
            throw new RuntimeException("图验证码创建失败");
        }
        //把data(图片）进行base64编码
        return encoder.encode(data.toByteArray());
    }
}

Excel 工具

import cn.hb.ycmm.common.exception.ExcelException;
import com.alibaba.excel.EasyExcel;
import com.alibaba.excel.read.builder.ExcelReaderBuilder;
import com.alibaba.excel.read.listener.ReadListener;
import com.alibaba.excel.util.DateUtils;
import com.google.common.base.Charsets;
import lombok.SneakyThrows;
import org.springframework.util.StringUtils;
import org.springframework.web.multipart.MultipartFile;

import javax.servlet.http.HttpServletResponse;
import java.io.BufferedInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.URLEncoder;
import java.util.Date;
import java.util.List;

/**
 * Excel工具类
 *
 * @author huabin
 * @apiNote https://www.yuque.com/easyexcel/doc/easyexcel
 */
public class ExcelUtil {

   /**
    * 读取excel的所有sheet数据
    *
    * @param excel excel文件
    * @return List<Object>
    */
   public static <T> List<T> read(MultipartFile excel, Class<T> clazz) {
      DataListener<T> dataListener = new DataListener<>();
      ExcelReaderBuilder builder = getReaderBuilder(excel, dataListener, clazz);
      if (builder == null) {
         return null;
      }
      builder.doReadAll();
      return dataListener.getDataList();
   }

   /**
    * 读取excel的指定sheet数据
    *
    * @param excel   excel文件
    * @param sheetNo sheet序号(从0开始)
    * @return List<Object>
    */
   public static <T> List<T> read(MultipartFile excel, int sheetNo, Class<T> clazz) {
      return read(excel, sheetNo, 1, clazz);
   }

   /**
    * 读取excel的指定sheet数据
    *
    * @param excel         excel文件
    * @param sheetNo       sheet序号(从0开始)
    * @param headRowNumber 表头行数
    * @return List<Object>
    */
   public static <T> List<T> read(MultipartFile excel, int sheetNo, int headRowNumber, Class<T> clazz) {
      DataListener<T> dataListener = new DataListener<>();
      ExcelReaderBuilder builder = getReaderBuilder(excel, dataListener, clazz);
      if (builder == null) {
         return null;
      }
      builder.sheet(sheetNo).headRowNumber(headRowNumber).doRead();
      return dataListener.getDataList();
   }

   /**
    * 读取并导入数据
    *
    * @param excel    excel文件
    * @param importer 导入逻辑类
    * @param <T>      泛型
    */
   public static <T> void save(MultipartFile excel, ExcelImporter<T> importer, Class<T> clazz) {
      ImportListener<T> importListener = new ImportListener<>(importer);
      ExcelReaderBuilder builder = getReaderBuilder(excel, importListener, clazz);
      if (builder != null) {
         builder.doReadAll();
      }
   }

   /**
    * 导出excel
    *
    * @param response 响应类
    * @param dataList 数据列表
    * @param clazz    class类
    * @param <T>      泛型
    */
   @SneakyThrows
   public static <T> void export(HttpServletResponse response, List<T> dataList, Class<T> clazz) {
      export(response, DateUtils.format(new Date(), DateUtils.DATE_FORMAT_14), "导出数据", dataList, clazz);
   }

   /**
    * 导出excel
    *
    * @param response  响应类
    * @param fileName  文件名
    * @param sheetName sheet名
    * @param dataList  数据列表
    * @param clazz     class类
    * @param <T>       泛型
    */
   @SneakyThrows
   public static <T> void export(HttpServletResponse response, String fileName, String sheetName, List<T> dataList, Class<T> clazz) {
      response.setContentType("application/vnd.ms-excel");
      response.setCharacterEncoding(Charsets.UTF_8.name());
      fileName = URLEncoder.encode(fileName, Charsets.UTF_8.name());
      response.setHeader("Content-disposition", "attachment;filename=" + fileName + ".xlsx");
      EasyExcel.write(response.getOutputStream(), clazz).sheet(sheetName).doWrite(dataList);
   }

   /**
    * 获取构建类
    *
    * @param excel        excel文件
    * @param readListener excel监听类
    * @return ExcelReaderBuilder
    */
   public static <T> ExcelReaderBuilder getReaderBuilder(MultipartFile excel, ReadListener<T> readListener, Class<T> clazz) {
      String filename = excel.getOriginalFilename();
      if (StringUtils.isEmpty(filename)) {
         throw new ExcelException("请上传文件!");
      }
      if ((!StringUtils.endsWithIgnoreCase(filename, ".xls") && !StringUtils.endsWithIgnoreCase(filename, ".xlsx"))) {
         throw new ExcelException("请上传正确的excel文件!");
      }
      InputStream inputStream;
      try {
         inputStream = new BufferedInputStream(excel.getInputStream());
         return EasyExcel.read(inputStream, clazz, readListener);
      } catch (IOException e) {
         e.printStackTrace();
      }
      return null;
   }

}

Class 工具

import java.io.File;
import java.io.FileFilter;
import java.io.IOException;
import java.net.JarURLConnection;
import java.net.URL;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.List;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;

/**
 * 用于获取指定包名下的所有类名（包含jar包）.<br/>
 * 并可设置是否遍历该包名下的子包的类名.<br/>
 */
public class ClassUtils {
	public static List<Class<?>> getClassList(String pkgName , boolean isRecursive) {
		List<Class<?>> classList = new ArrayList<Class<?>>();
		ClassLoader loader = Thread.currentThread().getContextClassLoader();
		try {
			String strFile = pkgName.replaceAll("\\.", "/");
			Enumeration<URL> urls = loader.getResources(strFile);
			while (urls.hasMoreElements()) {
				URL url = urls.nextElement();
                if (url != null) {
                	String protocol = url.getProtocol();
                	String pkgPath = url.getPath();
                    if ("file".equals(protocol)) {
						findClassName(classList, pkgName, pkgPath, isRecursive);
					} else if ("jar".equals(protocol)) {
						findClassName(classList, pkgName, url, isRecursive);
                    }
                }
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
		return classList;
	}
	
	public static void findClassName(List<Class<?>> clazzList, String pkgName, String pkgPath, boolean isRecursive) {
		if(clazzList == null){
			return;
		}
		File[] files = filterClassFiles(pkgPath);
		if(files != null){
			for (File f : files) {
				String fileName = f.getName();
				if (f.isFile()) {
					String clazzName = getClassName(pkgName, fileName);
					addClassName(clazzList, clazzName);
				} else {
					if(isRecursive){
						String subPkgName = pkgName +"."+ fileName;
						String subPkgPath = pkgPath +"/"+ fileName;
						findClassName(clazzList, subPkgName, subPkgPath, true);
					}
				}
			}
		}
	}
	
	public static void findClassName(List<Class<?>> clazzList, String pkgName, URL url, boolean isRecursive) throws IOException {
		JarURLConnection jarURLConnection = (JarURLConnection) url.openConnection();
		JarFile jarFile = jarURLConnection.getJarFile();
		Enumeration<JarEntry> jarEntries = jarFile.entries();
		while (jarEntries.hasMoreElements()) {
			JarEntry jarEntry = jarEntries.nextElement();
			String jarEntryName = jarEntry.getName(); 
			String clazzName = jarEntryName.replace("/", ".");
			int endIndex = clazzName.lastIndexOf(".");
			String prefix = null;
			if (endIndex > 0) {
				clazzName = clazzName.substring(0, endIndex);
				endIndex = clazzName.lastIndexOf(".");
				if(endIndex > 0){
					prefix = clazzName.substring(0, endIndex);
				}
			}
			if (prefix != null && jarEntryName.endsWith(".class")) {
				if(prefix.equals(pkgName)){
					addClassName(clazzList, clazzName);
				} else if(isRecursive && prefix.startsWith(pkgName)){
					addClassName(clazzList, clazzName);
				}
			}
		}
	}
	
	private static File[] filterClassFiles(String pkgPath) {
		if(pkgPath == null){
			return null;
		}
		return new File(pkgPath).listFiles(new FileFilter() {
			public boolean accept(File file) {
				return (file.isFile() && file.getName().endsWith(".class")) || file.isDirectory();
			}
		});
    }
	
	private static String getClassName(String pkgName, String fileName) {
		int endIndex = fileName.lastIndexOf(".");
		String clazz = null;
		if (endIndex >= 0) {
			clazz = fileName.substring(0, endIndex);
		}
		String clazzName = null;
		if (clazz != null) {
			clazzName = pkgName + "." + clazz;
		}
		return clazzName;
	}
	
	private static void addClassName(List<Class<?>> clazzList, String clazzName) {
		if (clazzList != null && clazzName != null) {
			Class<?> clazz = null;
			try {
				//Thread.currentThread().getContextClassLoader()
				ClassLoader contextClassLoader = Thread.currentThread().getContextClassLoader();
				clazz = Class.forName(clazzName,false,contextClassLoader);
				
			} catch (ClassNotFoundException e) {
				e.printStackTrace();
			}
			if (clazz != null) {
					clazzList.add(clazz);
			}
		}
	}
}

Enum 工具

        需要先建立一个枚举接口，之后建立的枚举去实现这个枚举接口，在调用工具传入枚举类；

public interface Enumerator {
	Object value();

	String description();

}

        枚举：

import lombok.AllArgsConstructor;
import lombok.Getter;

/**
 * 错误码
 */
@Getter
@AllArgsConstructor
public enum ErrorCodeEnum implements Enumerator {
    SUCCESS("2000", "成功"),
    FAIL("2001", "失败");

    private final String val;

    private final String desc;

    @Override
    public String value() {
        return val;
    }

    @Override
    public String description() {
        return desc;
    }
}

       枚举工具

package cn.hb.ycmm.common.utils;



import cn.hb.ycmm.common.enums.Enumerator;

import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import java.util.stream.Stream;

/**
 * @version V1.0
 * @Title: 枚举工具类
 * @ClassName: EnumUtils.java
 * @Description:
 * @author: huabin
 * @date: 2021/6/10 22:19
 */
public final class EnumUtils {

    private EnumUtils() {
    }

    /**
     * 对implement com.sany.business.qap.global.enums.Enumerator的枚举进行转换成下拉列表
     *
     * @param clazz
     * @param <E>
     * @return
     */
    public static <E extends Enum<?> & Enumerator> Map<String, String> enumToMap(Class<E> clazz) {
        E[] enumConstants = clazz.getEnumConstants();
        Map<String, String> map = new LinkedHashMap<>();
        for (E e : enumConstants) {
            map.put(e.value(), e.description());
        }
        return map;
    }

    /**
     * 根据value找到枚举
     *
     * @param enumClazz
     * @param value
     * @param <E>
     * @return
     */
    public static <E extends Enum<?> & Enumerator> Optional<E> getEnumByValue(Class<E> enumClazz, final String value) {

        return Stream.of(enumClazz.getEnumConstants())
                .filter(enumerator -> Objects.equals(enumerator.value(), value))
                .findAny();
    }

    /**
     * 根据desc找到枚举
     *
     * @param enumClazz
     * @param desc
     * @param <E>
     * @return
     */
    public static <E extends Enum<?> & Enumerator> Optional<E> getEnumByDesc(Class<E> enumClazz, final String desc) {

        return Stream.of(enumClazz.getEnumConstants())
                .filter(enumerator -> Objects.equals(enumerator.description(), desc))
                .findAny();
    }
}

分页工具

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.bean.copier.CopyOptions;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.google.common.collect.Lists;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

public final class PageUtil {

    private PageUtil() {
    }


	/**
	 * @description 集合转分页对象
	 * @param
	 * @return
	 */
    public static <T> IPage pageListToIPage(List<T> data, IPage page) {
        IPage iPage = new com.baomidou.mybatisplus.extension.plugins.pagination.Page();
        BeanUtil.copyProperties(page, iPage, CopyOptions.create().setIgnoreNullValue(true));
        iPage.setRecords(data);
        return iPage;
    }



    /**
     * 逻辑分页
     *
     * @currPageNo 页面传入的页号，从一开始
     * @pageSize 每页记录数
     */
    public static  <T> Map<String, Object> getPagingResultMap(List<T> list, Integer currPageNo, Integer pageSize) {
        Map<String, Object> retMap = new HashMap<>();

        if (list.isEmpty()) {
            retMap.put("result", Lists.newArrayList());
            retMap.put("pageNo", 0);
            retMap.put("pageRowNum", 0);
            retMap.put("totalRowNum", 0);
            retMap.put("totalPageNum", 0);

            return retMap;
        }
        if (currPageNo <= 0) {
            retMap.put("result", list);
            retMap.put("pageNo", 0);
            retMap.put("pageRowNum", 0);
            retMap.put("totalRowNum", 0);
            retMap.put("totalPageNum", 0);

            return retMap;
        }

        int totalRowNum = list.size();
        int totalPageNum = (totalRowNum - 1) / pageSize + 1;

        int realPageNo = currPageNo;
        if (currPageNo > totalPageNum) {
            realPageNo = totalPageNum;
        } else if (currPageNo < 1) {
            realPageNo = 1;
        }

        int fromIdx = (realPageNo - 1) * pageSize;
        int toIdx = realPageNo * pageSize > totalRowNum ? totalRowNum : realPageNo * pageSize;

        List<T> result = list.subList(fromIdx, toIdx);

        retMap.put("result", result);
        retMap.put("pageNo", realPageNo);
        retMap.put("pageRowNum", result.size());
        retMap.put("totalRowNum", totalRowNum);
        retMap.put("totalPageNum", totalPageNum);

        return retMap;
    }

}

断言工具2

需要先建立一个异常提示类

public class CommonException extends RuntimeException {
	public CommonException(String message) {
		super(message);
	}

	public CommonException(Throwable e) {
		super(e);
	}

	public static CommonException throwCommonException(String msg) {
		throw new CommonException(msg);
	}
}

断言工具

package cn.hb.ycmm.common.utils;

import cn.hb.ycmm.common.exception.CommonException;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;

import java.util.List;
import java.util.Objects;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.regex.PatternSyntaxException;
import java.util.stream.Collectors;

/**
 * @author huabin
 * @version 1.0.0
 * @ClassName ValidUtils.java
 * @Description 参数校验工具
 * @createTime 2019-12-31 23:59:59
 */
public class ValidUtils {
    //大陆电话常量验证
    public static final String REGEXP_PHONE_CHINA = "^((13[0-9])|(15[^4])|(18[0,2,3,5-9])|(17[0-8])|(147))\\d{8}$";

	//大陆电话常量验证简易
	public static final String REGEXP_PHONE_CHINA_EASY = "^1[0-9]{10}$";

    //港澳电话常量验证
    public static final String REGEXP_PHONE_CHINA_HK = "^(5|6|8|9)\\d{7}$";
    //邮箱格式常量
    public static final String REGEXP_EMAIL = "^([a-z0-9A-Z]+[-|\\.]?)+[a-z0-9A-Z]@([a-z0-9A-Z]+(-[a-z0-9A-Z]+)?\\.)+[a-zA-Z]{2,}$";

    /**
     * 邮箱验证
     */
    public static boolean isEmail(String str)throws PatternSyntaxException {
        Pattern p = Pattern.compile(REGEXP_EMAIL);
        Matcher m = p.matcher(str);
        return m.matches();
    }
    /**
     * 大陆号码或香港号码均可
     */
    public static boolean isPhone(String str)throws PatternSyntaxException {
        return isChinaPhoneLegal(str) || isHKPhoneLegal(str);
    }

    /**
     * 大陆手机号码11位数，匹配格式：前三位固定格式+后8位任意数
     * 此方法中前三位格式有：
     * 13+任意数
     * 15+除4的任意数
     * 18+除1和4的任意数
     * 17+除9的任意数
     * 147
     */
    public static boolean isChinaPhoneLegal(String str) throws PatternSyntaxException {
        Pattern p = Pattern.compile(REGEXP_PHONE_CHINA);
        Matcher m = p.matcher(str);
        return m.matches();
    }

    /**
     * 香港手机号码8位数，5|6|8|9开头+7位任意数
     */
    public static boolean isHKPhoneLegal(String str)throws PatternSyntaxException {
        Pattern p = Pattern.compile(REGEXP_PHONE_CHINA_HK);
        Matcher m = p.matcher(str);
        return m.matches();
    }

    //断言对象和字符串 ，为空  ，如果为空，或者是空字符串，报错
    public static void isNull(Object str, String message) {
        //判断对象
        if(Objects.isNull(str)){
            throw CommonException.throwCommonException(message);
        }
        //判断字符串
        if( (str instanceof String) && StringUtils.isEmpty((CharSequence) str)){
            throw CommonException.throwCommonException(message);
        }
    }

    //断言两个int值相等
    public static void isEquals(int n1,int n2, String message) {
        if(n1 != n2){
            throw CommonException.throwCommonException(message);
        }
    }

    //断言一个对象不为空，不为空，报错，不针对Str
    public static void isNotNull(Object obj, String message) {
        //判断对象
        if(Objects.nonNull(obj)){
            throw CommonException.throwCommonException(message);
        }
    }

	//断言一个集合不为空，不为空，报错
	public static <T> void isNotNull(List<T> data, String message){
    	if (CollectionUtils.isNotEmpty(data)){
			throw CommonException.throwCommonException(message);
		}
	}

	//断言一个集合为空，为空，报错
	public static <T> void isNull(List<T> data, String message){
		if (CollectionUtils.isEmpty(data)){
			throw CommonException.throwCommonException(message);
		}
	}


    //断言手机号
    public static void isPhone(String phone, String message) {
        //判断手机号格式
        if(!isPhone(phone)){
            throw CommonException.throwCommonException(message);
        }
    }

    //断言邮箱
    public static void isEmail(String email, String message) {
        //判断邮箱格式
        if(!isEmail(email)){
            throw CommonException.throwCommonException(message);
        }
    }
    //断言TRUE 是ture就运行 false报错
    public static void isTrue(boolean success, String message) {
        if(!success){
            throw CommonException.throwCommonException(message);
        }
    }

    //断言TRUE OR FALSE
    public static void booleanEquals(boolean success, boolean success2,String message) {
        if(success != success2){
            throw CommonException.throwCommonException(message);
        }
    }

    //断言空值
    public static void isEquals(String str1, String str2, String message) {
        isNull(str1,"比较的内容不能为空");
        isNull(str2,"比较的内容不能为空");
        if(!str1.equals(str2)){
            throw CommonException.throwCommonException(message);
        }
    }
    //忽略大小写断言空值
    public static void isEqualsIgnoreCase(String str1, String str2, String message) {
        isNull(str1,"比较的内容不能为空");
        isNull(str2,"比较的内容不能为空");
        if(!str1.equalsIgnoreCase(str2)){
            throw CommonException.throwCommonException(message);
        }
    }

    //断言集合数据（String对象）是否重复
    public static void isRepeatToStr(String str1,String str2,String str3,String message){
       if (StringUtils.isNotBlank(str1) && StringUtils.isNotBlank(str2)){
           if (str1.equals(str2)){
               throw CommonException.throwCommonException(message);
           }
       }
        if (StringUtils.isNotBlank(str1) && StringUtils.isNotBlank(str3)){
            if (str1.equals(str3)){
                throw CommonException.throwCommonException(message);
            }
        }
        if (StringUtils.isNotBlank(str2) && StringUtils.isNotBlank(str3)){
            if (str2.equals(str3)){
                throw CommonException.throwCommonException(message);
            }
        }

    }
    public static void isRepeatToStr(List<String> strings,String message){
        List<String> list1 = strings.stream().distinct().collect(Collectors.toList());
        if (list1.size() != strings.size()){
            throw CommonException.throwCommonException(message);
        }
    }
    //断言集合数据是否重复
    public static void isRepeat(List<Object>objects,String message){
        objects.forEach(object ->{
            if (objects.contains(object)){
                throw CommonException.throwCommonException(message);
            }
        });
    }
}

IP 地址工具

package com.axin.management.common.util;

import java.net.InetAddress;
import java.net.NetworkInterface;
import java.net.SocketException;
import java.net.UnknownHostException;

/**
 * @author huabin
 * @date 2023/7/21
 */

public final class IpAddressUtils {

    private IpAddressUtils() {
    }

    /**
     * 获取ip地址
     *
     * @return ip地址
     */
    public static String getIpAddress() {
        try {
            return InetAddress.getLocalHost().getHostAddress();
        } catch (UnknownHostException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 获取mac地址
     *
     * @return mac地址
     */
    public static String getMacAddress() {
        //获取网卡，获取地址
        byte[] mac;
        try {
            mac = NetworkInterface.getByInetAddress(InetAddress.getLocalHost()).getHardwareAddress();
        } catch (SocketException | UnknownHostException e) {
            throw new RuntimeException(e);
        }
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < mac.length; i++) {
            if (i != 0) {
                //每2位用“-”拼接
                sb.append("-");
            }
            // 字节转换为整数
            int temp = mac[i] & 0xff;
            String str = Integer.toHexString(temp);
            if (str.length() == 1) {
                // 十位补0
                sb.append("0").append(str);
            } else {
                sb.append(str);
            }
        }
        return sb.toString();
    }

}

Map 工具

package com.axin.management.common.util;

import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import org.springframework.util.CollectionUtils;

import java.util.Collections;
import java.util.List;
import java.util.Map;

/**
 * @author huabin
 * @date 2023/8/09
 */

public final class MapUtils {

    private MapUtils() {
    }

    /**
     * 默认分组大小
     */
    private final static int DEFAULT_GROUP_SIZE = 10;


    /**
     * Map拆分 (指定数组大小)
     *
     * @param maps 待分组map
     * @param <K>  key
     * @param <V>  value
     * @return 子map集合
     */
    public static <K, V> List<Map<K, V>> mapGroup(Map<K, V> maps) {
        return mapGroup(maps, DEFAULT_GROUP_SIZE);
    }


    /**
     * Map拆分 (指定数组大小)
     *
     * @param maps      待分组map
     * @param groupSize 每个分组的大小
     * @param <K>       key
     * @param <V>       value
     * @return 子map集合
     */
    public static <K, V> List<Map<K, V>> mapGroup(Map<K, V> maps, int groupSize) {
        if (CollectionUtils.isEmpty(maps) || groupSize < 1) {
            return Collections.emptyList();
        }
        int mapSize = maps.size();
        int mapGroup = mapSize / groupSize + (mapSize % groupSize == 0 ? 0 : 1);
        List<Map<K, V>> results = Lists.newArrayListWithCapacity(mapGroup);
        if (mapSize <= groupSize) {
            results.add(maps);
            return results;
        }
        int count = 0;
        Map<K, V> subMap = Maps.newHashMapWithExpectedSize(groupSize);
        for (Map.Entry<K, V> entry : maps.entrySet()) {
            if (count < groupSize) {
                subMap.put(entry.getKey(), entry.getValue());
                count++;
            } else {
                results.add(subMap);
                subMap = Maps.newHashMapWithExpectedSize(groupSize);
                subMap.put(entry.getKey(), entry.getValue());
                count = 1;
            }
        }
        // 添加最后一个分组
        results.add(subMap);
        return results;
    }

}