Md5加密

/**
 * 功能：可 cache Consumer
 * <p>
 *
 * @author zlc
 * @see Supplier
 * @since 2023-11-14
 */
@FunctionalInterface
public interface CatchableSupplier<T> {
    /**
     * 包装 CatchableSupplier
     * <p>
     * CatchableSupplier => Supplier
     *
     * @param catchableSupplier CatchableSupplier
     * @param <T>               return Type
     * @return Supplier
     */
    static <T> Supplier<T> warp(CatchableSupplier<T> catchableSupplier) {
        return () -> {
            try {
                return catchableSupplier.get();
            } catch (Throwable ex) {
                throw new RuntimeException(ex);
            }
        };
    }

    /**
     * 获取对象
     *
     * @return 返回一个类型为 T 的对象
     * @throws Throwable 当获取对象发生异常时抛出此异常
     */
    T get() throws Throwable;
}

public class MD5Util {

    private MD5Util() {
        throw new AssertionError(MD5Util.class.getName());
    }

    private static final char[] HEX = "0123456789abcdef".toCharArray();

    static final byte[] DEF_SALT = "YT".getBytes();

    static final byte[] EMPTY = new byte[0];

    static final ThreadLocal<MessageDigest> MD5 = ThreadLocal.withInitial(
            CatchableSupplier.warp(() -> MessageDigest.getInstance("MD5"))
    );


    /**
     * 将字节数组编码为十六进制字符串
     *
     * @param bytes 要编码的字节数组
     * @return 编码后的十六进制字符串
     */
    static String encode2HexStr(byte[] bytes) {
        final int nBytes = bytes.length;
        char[] result = new char[2 * nBytes];
        int j = 0;
        for (byte aByte : bytes) {
            // Char for top 4 bits
            result[j++] = HEX[(0xF0 & aByte) >>> 4];
            // Bottom 4
            result[j++] = HEX[(0x0F & aByte)];
        }
        return new String(result);
    }

    /**
 
    /**
     * 对给定的字节数组进行 MD5 摘要计算
     * <p>
     * NOTE：此方法使用了一个预设的盐值（DEF_SALT），使用盐值可以增强哈希值的安全性，防止彩虹表攻击等
     *
     * @param bytes 要进行摘要计算的字节数组
     * @return 字节数组的 MD5 摘要结果
     */
    public static byte[] digest(byte[] bytes) {
        return digest(bytes, DEF_SALT);
    }

    /**
     * 对给定的字节数组进行 MD5 摘要计算，并使用提供的盐值（salt）进行加强
     *
     * @param bytes 要进行摘要计算的原始字节数组
     * @param salt  用于加强摘要计算的盐值字节数组
     * @return 包含原始数据和盐值的字节数组的MD5摘要结果
     */
    public static byte[] digest(byte[] bytes, byte[] salt) {
        MessageDigest md = MD5.get();
        if (bytes != null) {
            md.update(bytes);
        }
        if (salt != null) {
            md.update(salt);
        }
        return md.digest();
    }

    /**
     * 使用带有盐值的 MD5算法 对给定的字节数组进行哈希处理
     *
     * @param textBytes 要进行哈希处理的 字节数组
     * @param saltBytes 用于增强安全性的盐值 字节数组
     * @return 返回经过MD5哈希处理和盐值处理后的16进制字符串
     */
    public static String digest2Hex(byte[] textBytes, byte[] saltBytes) {
        byte[] digest = digest(textBytes, saltBytes);
        // 返回16进制字符串
        return encode2HexStr(digest);
    }

    /**
     * 使用带有盐值的MD5算法对给定的字符串进行哈希处理
     *
     * @param text 要进行哈希处理的原始字符串
     * @param salt 用于增强安全性的盐值字符串
     * @return 返回经过MD5哈希处理和盐值处理后的字符串
     */
    public static String digest2Hex(String text, String salt) {
        byte[] textBytes = text == null ? EMPTY : text.getBytes();
        byte[] saltBytes = salt == null ? DEF_SALT : salt.getBytes();
        return digest2Hex(textBytes, saltBytes);
    }

    /**
     * 使用预设的盐值对给定的字符串进行 MD5 哈希处理
     *
     * @param textBytes 要进行哈希处理的 字节数组
     * @return 返回经过MD5哈希处理后的字符串，其中包含了预设的盐值
     * <p>
     */
    public static String digest2Hex(byte[] textBytes) {
        return digest2Hex(textBytes, DEF_SALT);
    }

    /**
     * 使用预设的盐值对给定的字符串进行MD5哈希处理
     *
     * @param text 要进行哈希处理的原始字符串
     * @return 返回经过MD5哈希处理后的字符串，其中包含了预设的盐值
     * <p>
     */
    public static String digest2Hex(String text) {
        byte[] textBytes = text == null ? EMPTY : text.getBytes();
        return digest2Hex(textBytes);
    }
}