类型转换、字符串、浮点数运算、文件目录、文件上传、客户端工具类

柔光的暖阳◎ 2024-03-31 01:25 13阅读 0赞

#### 文章目录 ####

*   *  BigDecimalUtils
     *  ConvertUtils
     *  StringUtils
     *  ServletUtils
     *  FileDirectoryUtils
     *  CharsetUtils
     *  媒体类型工具类
     *  文件处理工具类
     *  Md5加密方法
     *  文件上传工具类

### BigDecimalUtils ###

package com.yolo.springboot.kaptcha.util;
 
 import java.math.BigDecimal;
 import java.math.RoundingMode;
 
 /**
 * @ClassName BigDecimalUtils
 * @Description 精确地浮点数运算
 * @Author hl
 * @Date 2022/12/7 10:55
 * @Version 1.0
 */
 public class BigDecimalUtils {
 
 /**
 * 默认除法运算精度
 */
 private static final int DEF_DIV_SCALE = 2;
 
 /**
 * 这个类不能实例化
 */
 private BigDecimalUtils() {
 
 }
 
 /**
 * 提供精确的加法运算。
 *
 * @param v1 被加数
 * @param v2 加数
 * @return 两个参数的和
 */
 public static double add(double v1, double v2) {
 
 BigDecimal b1 = new BigDecimal(Double.toString(v1));
 BigDecimal b2 = new BigDecimal(Double.toString(v2));
 return b1.add(b2).doubleValue();
 }
 
 /**
 * 提供精确的减法运算。
 *
 * @param v1 被减数
 * @param v2 减数
 * @return 两个参数的差
 */
 public static double sub(double v1, double v2) {
 
 BigDecimal b1 = new BigDecimal(Double.toString(v1));
 BigDecimal b2 = new BigDecimal(Double.toString(v2));
 return b1.subtract(b2).doubleValue();
 }
 
 /**
 * 提供精确的乘法运算。
 *
 * @param v1 被乘数
 * @param v2 乘数
 * @return 两个参数的积
 */
 public static double mul(double v1, double v2) {
 
 BigDecimal b1 = new BigDecimal(Double.toString(v1));
 BigDecimal b2 = new BigDecimal(Double.toString(v2));
 return b1.multiply(b2).doubleValue();
 }
 
 /**
 * 提供（相对）精确的除法运算，当发生除不尽的情况时，精确到
 * 小数点以后10位，以后的数字四舍五入。
 *
 * @param v1 被除数
 * @param v2 除数
 * @return 两个参数的商
 */
 public static double div(double v1, double v2) {
 
 return div(v1, v2, DEF_DIV_SCALE);
 }
 
 /**
 * 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指
 * 定精度，以后的数字四舍五入。
 *
 * @param v1 被除数
 * @param v2 除数
 * @param scale 表示表示需要精确到小数点以后几位。
 * @return 两个参数的商
 */
 public static double div(double v1, double v2, int scale) {
 
 if (scale < 0) {
 
 throw new IllegalArgumentException(
 "The scale must be a positive integer or zero");
 }
 BigDecimal b1 = new BigDecimal(Double.toString(v1));
 BigDecimal b2 = new BigDecimal(Double.toString(v2));
 if (b1.compareTo(BigDecimal.ZERO) == 0) {
 
 return BigDecimal.ZERO.doubleValue();
 }
 return b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP).doubleValue();
 }
 
 /**
 * 提供精确的小数位四舍五入处理。
 *
 * @param v 需要四舍五入的数字
 * @param scale 小数点后保留几位
 * @return 四舍五入后的结果
 */
 public static double round(double v, int scale) {
 
 if (scale < 0) {
 
 throw new IllegalArgumentException(
 "The scale must be a positive integer or zero");
 }
 BigDecimal b = new BigDecimal(Double.toString(v));
 BigDecimal one = new BigDecimal("1");
 return b.divide(one, scale, RoundingMode.HALF_UP).doubleValue();
 }
 }

### ConvertUtils ###

package com.yolo.springboot.kaptcha.util;
 
 import org.apache.commons.lang3.StringUtils;
 
 import java.math.BigDecimal;
 import java.math.BigInteger;
 import java.nio.ByteBuffer;
 import java.nio.charset.Charset;
 import java.text.NumberFormat;
 import java.util.Set;
 
 /**
 * 类型转换器
 */
 public class ConvertUtils {
 
 /**
 * 转换为字符串 
 * 如果给定的值为null，或者转换失败，返回默认值 
 * 转换失败不会报错
 *
 * @param value 被转换的值
 * @param defaultValue 转换错误时的默认值
 * @return 结果
 */
 public static String toStr(Object value, String defaultValue) {
 
 if (null == value) {
 
 return defaultValue;
 }
 if (value instanceof String) {
 
 return (String) value;
 }
 return value.toString();
 }
 
 /**
 * 转换为字符串 
 * 如果给定的值为<code>null</code>，或者转换失败，返回默认值<code>null</code> 
 * 转换失败不会报错
 *
 * @param value 被转换的值
 * @return 结果
 */
 public static String toStr(Object value) {
 
 return toStr(value, null);
 }
 
 /**
 * 转换为字符 
 * 如果给定的值为null，或者转换失败，返回默认值 
 * 转换失败不会报错
 *
 * @param value 被转换的值
 * @param defaultValue 转换错误时的默认值
 * @return 结果
 */
 public static Character toChar(Object value, Character defaultValue) {
 
 if (null == value) {
 
 return defaultValue;
 }
 if (value instanceof Character) {
 
 return (Character) value;
 }
 
 final String valueStr = toStr(value, null);
 return StringUtils.isEmpty(valueStr) ? defaultValue : valueStr.charAt(0);
 }
 
 /**
 * 转换为字符 
 * 如果给定的值为<code>null</code>，或者转换失败，返回默认值<code>null</code> 
 * 转换失败不会报错
 *
 * @param value 被转换的值
 * @return 结果
 */
 public static Character toChar(Object value) {
 
 return toChar(value, null);
 }
 
 /**
 * 转换为byte 
 * 如果给定的值为<code>null</code>，或者转换失败，返回默认值 
 * 转换失败不会报错
 *
 * @param value 被转换的值
 * @param defaultValue 转换错误时的默认值
 * @return 结果
 */
 public static Byte toByte(Object value, Byte defaultValue) {
 
 if (value == null) {
 
 return defaultValue;
 }
 if (value instanceof Byte) {
 
 return (Byte) value;
 }
 if (value instanceof Number) {
 
 return ((Number) value).byteValue();
 }
 final String valueStr = toStr(value, null);
 if (StringUtils.isEmpty(valueStr)) {
 
 return defaultValue;
 }
 try {
 
 return Byte.parseByte(valueStr);
 } catch (Exception e) {
 
 return defaultValue;
 }
 }
 
 /**
 * 转换为byte 
 * 如果给定的值为<code>null</code>，或者转换失败，返回默认值<code>null</code> 
 * 转换失败不会报错
 *
 * @param value 被转换的值
 * @return 结果
 */
 public static Byte toByte(Object value) {
 
 return toByte(value, null);
 }
 
 /**
 * 转换为Short 
 * 如果给定的值为<code>null</code>，或者转换失败，返回默认值 
 * 转换失败不会报错
 *
 * @param value 被转换的值
 * @param defaultValue 转换错误时的默认值
 * @return 结果
 */
 public static Short toShort(Object value, Short defaultValue) {
 
 if (value == null) {
 
 return defaultValue;
 }
 if (value instanceof Short) {
 
 return (Short) value;
 }
 if (value instanceof Number) {
 
 return ((Number) value).shortValue();
 }
 final String valueStr = toStr(value, null);
 if (StringUtils.isEmpty(valueStr)) {
 
 return defaultValue;
 }
 try {
 
 return Short.parseShort(valueStr.trim());
 } catch (Exception e) {
 
 return defaultValue;
 }
 }
 
 /**
 * 转换为Short 
 * 如果给定的值为<code>null</code>，或者转换失败，返回默认值<code>null</code> 
 * 转换失败不会报错
 *
 * @param value 被转换的值
 * @return 结果
 */
 public static Short toShort(Object value) {
 
 return toShort(value, null);
 }
 
 /**
 * 转换为Number 
 * 如果给定的值为空，或者转换失败，返回默认值 
 * 转换失败不会报错
 *
 * @param value 被转换的值
 * @param defaultValue 转换错误时的默认值
 * @return 结果
 */
 public static Number toNumber(Object value, Number defaultValue) {
 
 if (value == null) {
 
 return defaultValue;
 }
 if (value instanceof Number) {
 
 return (Number) value;
 }
 final String valueStr = toStr(value, null);
 if (StringUtils.isEmpty(valueStr)) {
 
 return defaultValue;
 }
 try {
 
 return NumberFormat.getInstance().parse(valueStr);
 } catch (Exception e) {
 
 return defaultValue;
 }
 }
 
 /**
 * 转换为Number 
 * 如果给定的值为空，或者转换失败，返回默认值<code>null</code> 
 * 转换失败不会报错
 *
 * @param value 被转换的值
 * @return 结果
 */
 public static Number toNumber(Object value) {
 
 return toNumber(value, null);
 }
 
 /**
 * 转换为int 
 * 如果给定的值为空，或者转换失败，返回默认值 
 * 转换失败不会报错
 *
 * @param value 被转换的值
 * @param defaultValue 转换错误时的默认值
 * @return 结果
 */
 public static Integer toInt(Object value, Integer defaultValue) {
 
 if (value == null) {
 
 return defaultValue;
 }
 if (value instanceof Integer) {
 
 return (Integer) value;
 }
 if (value instanceof Number) {
 
 return ((Number) value).intValue();
 }
 final String valueStr = toStr(value, null);
 if (StringUtils.isEmpty(valueStr)) {
 
 return defaultValue;
 }
 try {
 
 return Integer.parseInt(valueStr.trim());
 } catch (Exception e) {
 
 return defaultValue;
 }
 }
 
 /**
 * 转换为int 
 * 如果给定的值为<code>null</code>，或者转换失败，返回默认值<code>null</code> 
 * 转换失败不会报错
 *
 * @param value 被转换的值
 * @return 结果
 */
 public static Integer toInt(Object value) {
 
 return toInt(value, null);
 }
 
 /**
 * 转换为Integer数组 
 *
 * @param str 被转换的值
 * @return 结果
 */
 public static Integer[] toIntArray(String str) {
 
 return toIntArray(",", str);
 }
 
 /**
 * 转换为Long数组 
 *
 * @param str 被转换的值
 * @return 结果
 */
 public static Long[] toLongArray(String str) {
 
 return toLongArray(",", str);
 }
 
 /**
 * 转换为Integer数组 
 *
 * @param split 分隔符
 * @param split 被转换的值
 * @return 结果
 */
 public static Integer[] toIntArray(String split, String str) {
 
 if (StringUtils.isEmpty(str)) {
 
 return new Integer[]{
 };
 }
 String[] arr = str.split(split);
 final Integer[] ints = new Integer[arr.length];
 for (int i = 0; i < arr.length; i++) {
 
 final Integer v = toInt(arr[i], 0);
 ints[i] = v;
 }
 return ints;
 }
 
 /**
 * 转换为Long数组 
 *
 * @param split 分隔符
 * @param str 被转换的值
 * @return 结果
 */
 public static Long[] toLongArray(String split, String str) {
 
 if (StringUtils.isEmpty(str)) {
 
 return new Long[]{
 };
 }
 String[] arr = str.split(split);
 final Long[] longs = new Long[arr.length];
 for (int i = 0; i < arr.length; i++) {
 
 final Long v = toLong(arr[i], null);
 longs[i] = v;
 }
 return longs;
 }
 
 /**
 * 转换为String数组 
 *
 * @param str 被转换的值
 * @return 结果
 */
 public static String[] toStrArray(String str) {
 
 return toStrArray(",", str);
 }
 
 /**
 * 转换为String数组 
 *
 * @param split 分隔符
 * @param split 被转换的值
 * @return 结果
 */
 public static String[] toStrArray(String split, String str) {
 
 return str.split(split);
 }
 
 /**
 * 转换为long 
 * 如果给定的值为空，或者转换失败，返回默认值 
 * 转换失败不会报错
 *
 * @param value 被转换的值
 * @param defaultValue 转换错误时的默认值
 * @return 结果
 */
 public static Long toLong(Object value, Long defaultValue) {
 
 if (value == null) {
 
 return defaultValue;
 }
 if (value instanceof Long) {
 
 return (Long) value;
 }
 if (value instanceof Number) {
 
 return ((Number) value).longValue();
 }
 final String valueStr = toStr(value, null);
 if (StringUtils.isEmpty(valueStr)) {
 
 return defaultValue;
 }
 try {
 
 // 支持科学计数法
 return new BigDecimal(valueStr.trim()).longValue();
 } catch (Exception e) {
 
 return defaultValue;
 }
 }
 
 /**
 * 转换为long 
 * 如果给定的值为<code>null</code>，或者转换失败，返回默认值<code>null</code> 
 * 转换失败不会报错
 *
 * @param value 被转换的值
 * @return 结果
 */
 public static Long toLong(Object value) {
 
 return toLong(value, null);
 }
 
 /**
 * 转换为double 
 * 如果给定的值为空，或者转换失败，返回默认值 
 * 转换失败不会报错
 *
 * @param value 被转换的值
 * @param defaultValue 转换错误时的默认值
 * @return 结果
 */
 public static Double toDouble(Object value, Double defaultValue) {
 
 if (value == null) {
 
 return defaultValue;
 }
 if (value instanceof Double) {
 
 return (Double) value;
 }
 if (value instanceof Number) {
 
 return ((Number) value).doubleValue();
 }
 final String valueStr = toStr(value, null);
 if (StringUtils.isEmpty(valueStr)) {
 
 return defaultValue;
 }
 try {
 
 // 支持科学计数法
 return new BigDecimal(valueStr.trim()).doubleValue();
 } catch (Exception e) {
 
 return defaultValue;
 }
 }
 
 /**
 * 转换为double 
 * 如果给定的值为空，或者转换失败，返回默认值<code>null</code> 
 * 转换失败不会报错
 *
 * @param value 被转换的值
 * @return 结果
 */
 public static Double toDouble(Object value) {
 
 return toDouble(value, null);
 }
 
 /**
 * 转换为Float 
 * 如果给定的值为空，或者转换失败，返回默认值 
 * 转换失败不会报错
 *
 * @param value 被转换的值
 * @param defaultValue 转换错误时的默认值
 * @return 结果
 */
 public static Float toFloat(Object value, Float defaultValue) {
 
 if (value == null) {
 
 return defaultValue;
 }
 if (value instanceof Float) {
 
 return (Float) value;
 }
 if (value instanceof Number) {
 
 return ((Number) value).floatValue();
 }
 final String valueStr = toStr(value, null);
 if (StringUtils.isEmpty(valueStr)) {
 
 return defaultValue;
 }
 try {
 
 return Float.parseFloat(valueStr.trim());
 } catch (Exception e) {
 
 return defaultValue;
 }
 }
 
 /**
 * 转换为Float 
 * 如果给定的值为空，或者转换失败，返回默认值<code>null</code> 
 * 转换失败不会报错
 *
 * @param value 被转换的值
 * @return 结果
 */
 public static Float toFloat(Object value) {
 
 return toFloat(value, null);
 }
 
 /**
 * 转换为boolean 
 * String支持的值为：true、false、yes、ok、no，1,0 如果给定的值为空，或者转换失败，返回默认值 
 * 转换失败不会报错
 *
 * @param value 被转换的值
 * @param defaultValue 转换错误时的默认值
 * @return 结果
 */
 public static Boolean toBool(Object value, Boolean defaultValue) {
 
 if (value == null) {
 
 return defaultValue;
 }
 if (value instanceof Boolean) {
 
 return (Boolean) value;
 }
 String valueStr = toStr(value, null);
 if (StringUtils.isEmpty(valueStr)) {
 
 return defaultValue;
 }
 valueStr = valueStr.trim().toLowerCase();
 switch (valueStr) {
 
 case "true":
 return true;
 case "false":
 return false;
 case "yes":
 return true;
 case "ok":
 return true;
 case "no":
 return false;
 case "1":
 return true;
 case "0":
 return false;
 default:
 return defaultValue;
 }
 }
 
 /**
 * 转换为boolean 
 * 如果给定的值为空，或者转换失败，返回默认值<code>null</code> 
 * 转换失败不会报错
 *
 * @param value 被转换的值
 * @return 结果
 */
 public static Boolean toBool(Object value) {
 
 return toBool(value, null);
 }
 
 /**
 * 转换为Enum对象 
 * 如果给定的值为空，或者转换失败，返回默认值 
 *
 * @param clazz Enum的Class
 * @param value 值
 * @param defaultValue 默认值
 * @return Enum
 */
 public static <E extends Enum<E>> E toEnum(Class<E> clazz, Object value, E defaultValue) {
 
 if (value == null) {
 
 return defaultValue;
 }
 if (clazz.isAssignableFrom(value.getClass())) {
 
 @SuppressWarnings("unchecked")
 E myE = (E) value;
 return myE;
 }
 final String valueStr = toStr(value, null);
 if (StringUtils.isEmpty(valueStr)) {
 
 return defaultValue;
 }
 try {
 
 return Enum.valueOf(clazz, valueStr);
 } catch (Exception e) {
 
 return defaultValue;
 }
 }
 
 /**
 * 转换为Enum对象 
 * 如果给定的值为空，或者转换失败，返回默认值<code>null</code> 
 *
 * @param clazz Enum的Class
 * @param value 值
 * @return Enum
 */
 public static <E extends Enum<E>> E toEnum(Class<E> clazz, Object value) {
 
 return toEnum(clazz, value, null);
 }
 
 /**
 * 转换为BigInteger 
 * 如果给定的值为空，或者转换失败，返回默认值 
 * 转换失败不会报错
 *
 * @param value 被转换的值
 * @param defaultValue 转换错误时的默认值
 * @return 结果
 */
 public static BigInteger toBigInteger(Object value, BigInteger defaultValue) {
 
 if (value == null) {
 
 return defaultValue;
 }
 if (value instanceof BigInteger) {
 
 return (BigInteger) value;
 }
 if (value instanceof Long) {
 
 return BigInteger.valueOf((Long) value);
 }
 final String valueStr = toStr(value, null);
 if (StringUtils.isEmpty(valueStr)) {
 
 return defaultValue;
 }
 try {
 
 return new BigInteger(valueStr);
 } catch (Exception e) {
 
 return defaultValue;
 }
 }
 
 /**
 * 转换为BigInteger 
 * 如果给定的值为空，或者转换失败，返回默认值<code>null</code> 
 * 转换失败不会报错
 *
 * @param value 被转换的值
 * @return 结果
 */
 public static BigInteger toBigInteger(Object value) {
 
 return toBigInteger(value, null);
 }
 
 /**
 * 转换为BigDecimal 
 * 如果给定的值为空，或者转换失败，返回默认值 
 * 转换失败不会报错
 *
 * @param value 被转换的值
 * @param defaultValue 转换错误时的默认值
 * @return 结果
 */
 public static BigDecimal toBigDecimal(Object value, BigDecimal defaultValue) {
 
 if (value == null) {
 
 return defaultValue;
 }
 if (value instanceof BigDecimal) {
 
 return (BigDecimal) value;
 }
 if (value instanceof Long) {
 
 return new BigDecimal((Long) value);
 }
 if (value instanceof Double) {
 
 return BigDecimal.valueOf((Double) value);
 }
 if (value instanceof Integer) {
 
 return new BigDecimal((Integer) value);
 }
 final String valueStr = toStr(value, null);
 if (StringUtils.isEmpty(valueStr)) {
 
 return defaultValue;
 }
 try {
 
 return new BigDecimal(valueStr);
 } catch (Exception e) {
 
 return defaultValue;
 }
 }
 
 /**
 * 转换为BigDecimal 
 * 如果给定的值为空，或者转换失败，返回默认值 
 * 转换失败不会报错
 *
 * @param value 被转换的值
 * @return 结果
 */
 public static BigDecimal toBigDecimal(Object value) {
 
 return toBigDecimal(value, null);
 }
 
 /**
 * 将对象转为字符串 
 * 1、Byte数组和ByteBuffer会被转换为对应字符串的数组 2、对象数组会调用Arrays.toString方法
 *
 * @param obj 对象
 * @return 字符串
 */
 public static String utf8Str(Object obj) {
 
 return str(obj, CharsetUtils.CHARSET_UTF_8);
 }
 
 /**
 * 将对象转为字符串 
 * 1、Byte数组和ByteBuffer会被转换为对应字符串的数组 2、对象数组会调用Arrays.toString方法
 *
 * @param obj 对象
 * @param charsetName 字符集
 * @return 字符串
 */
 public static String str(Object obj, String charsetName) {
 
 return str(obj, Charset.forName(charsetName));
 }
 
 /**
 * 将对象转为字符串 
 * 1、Byte数组和ByteBuffer会被转换为对应字符串的数组 2、对象数组会调用Arrays.toString方法
 *
 * @param obj 对象
 * @param charset 字符集
 * @return 字符串
 */
 public static String str(Object obj, Charset charset) {
 
 if (null == obj) {
 
 return null;
 }
 
 if (obj instanceof String) {
 
 return (String) obj;
 } else if (obj instanceof byte[] || obj instanceof Byte[]) {
 
 return str((Byte[]) obj, charset);
 } else if (obj instanceof ByteBuffer) {
 
 return str((ByteBuffer) obj, charset);
 }
 return obj.toString();
 }
 
 /**
 * 将byte数组转为字符串
 *
 * @param bytes byte数组
 * @param charset 字符集
 * @return 字符串
 */
 public static String str(byte[] bytes, String charset) {
 
 return str(bytes, StringUtils.isEmpty(charset) ? Charset.defaultCharset() : Charset.forName(charset));
 }
 
 /**
 * 解码字节码
 *
 * @param data 字符串
 * @param charset 字符集，如果此字段为空，则解码的结果取决于平台
 * @return 解码后的字符串
 */
 public static String str(byte[] data, Charset charset) {
 
 if (data == null) {
 
 return null;
 }
 
 if (null == charset) {
 
 return new String(data);
 }
 return new String(data, charset);
 }
 
 /**
 * 将编码的byteBuffer数据转换为字符串
 *
 * @param data 数据
 * @param charset 字符集，如果为空使用当前系统字符集
 * @return 字符串
 */
 public static String str(ByteBuffer data, String charset) {
 
 if (data == null) {
 
 return null;
 }
 
 return str(data, Charset.forName(charset));
 }
 
 /**
 * 将编码的byteBuffer数据转换为字符串
 *
 * @param data 数据
 * @param charset 字符集，如果为空使用当前系统字符集
 * @return 字符串
 */
 public static String str(ByteBuffer data, Charset charset) {
 
 if (null == charset) {
 
 charset = Charset.defaultCharset();
 }
 return charset.decode(data).toString();
 }
 
 // ----------------------------------------------------------------------- 全角半角转换
 
 /**
 * 半角转全角
 *
 * @param input String.
 * @return 全角字符串.
 */
 public static String toSBC(String input) {
 
 return toSBC(input, null);
 }
 
 /**
 * 半角转全角
 *
 * @param input String
 * @param notConvertSet 不替换的字符集合
 * @return 全角字符串.
 */
 public static String toSBC(String input, Set<Character> notConvertSet) {
 
 char c[] = input.toCharArray();
 for (int i = 0; i < c.length; i++) {
 
 if (null != notConvertSet && notConvertSet.contains(c[i])) {
 
 // 跳过不替换的字符
 continue;
 }
 
 if (c[i] == ' ') {
 
 c[i] = '\u3000';
 } else if (c[i] < '\177') {
 
 c[i] = (char) (c[i] + 65248);
 
 }
 }
 return new String(c);
 }
 
 /**
 * 全角转半角
 *
 * @param input String.
 * @return 半角字符串
 */
 public static String toDBC(String input) {
 
 return toDBC(input, null);
 }
 
 /**
 * 替换全角为半角
 *
 * @param text 文本
 * @param notConvertSet 不替换的字符集合
 * @return 替换后的字符
 */
 public static String toDBC(String text, Set<Character> notConvertSet) {
 
 char c[] = text.toCharArray();
 for (int i = 0; i < c.length; i++) {
 
 if (null != notConvertSet && notConvertSet.contains(c[i])) {
 
 // 跳过不替换的字符
 continue;
 }
 
 if (c[i] == '\u3000') {
 
 c[i] = ' ';
 } else if (c[i] > '\uFF00' && c[i] < '\uFF5F') {
 
 c[i] = (char) (c[i] - 65248);
 }
 }
 
 return new String(c);
 }
 
 /**
 * 数字金额大写转换 先写个完整的然后将如零拾替换成零
 *
 * @param n 数字
 * @return 中文大写数字
 */
 public static String digitUppercase(double n) {
 
 String[] fraction = {
 "角", "分"};
 String[] digit = {
 "零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖"};
 String[][] unit = {
 {
 "元", "万", "亿"}, {
 "", "拾", "佰", "仟"}};
 
 String head = n < 0 ? "负" : "";
 n = Math.abs(n);
 
 StringBuilder s = new StringBuilder();
 for (int i = 0; i < fraction.length; i++) {
 
 s.append((digit[(int) (Math.floor(n * 10 * Math.pow(10, i)) % 10)] + fraction[i]).replaceAll("(零.)+", ""));
 }
 if (s.length() < 1) {
 
 s = new StringBuilder("整");
 }
 int integerPart = (int) Math.floor(n);
 
 for (int i = 0; i < unit[0].length && integerPart > 0; i++) {
 
 String p = "";
 for (int j = 0; j < unit[1].length && n > 0; j++) {
 
 p = digit[integerPart % 10] + unit[1][j] + p;
 integerPart = integerPart / 10;
 }
 s.insert(0, p.replaceAll("(零.)*零$", "").replaceAll("^$", "零") + unit[0][i]);
 }
 return head + s.toString().replaceAll("(零.)*零元", "元").replaceFirst("(零.)+", "").replaceAll("(零.)+", "零").replaceAll("^整$", "零元整");
 }
 }

### StringUtils ###

package com.yolo.springboot.kaptcha.util;
 
 import java.util.Collection;
 import java.util.Map;
 
 /**
 * 字符串工具类
 */
 public class StringUtils extends org.apache.commons.lang3.StringUtils {
 
 /**
 * 空字符串
 */
 private static final String NULLSTR = "";
 
 /**
 * 下划线
 */
 private static final char SEPARATOR = '_';
 
 private static final String EMPTY_JSON = "{}";
 private static final char C_BACKSLASH = '\\';
 private static final char C_DELIM_START = '{';
 
 /**
 * 获取参数不为空值
 *
 * @param value defaultValue 要判断的value
 * @return value 返回值
 */
 public static <T> T nvl(T value, T defaultValue) {
 
 return value != null ? value : defaultValue;
 }
 
 /**
 * * 判断一个Collection是否为空， 包含List，Set，Queue
 *
 * @param coll 要判断的Collection
 * @return true：为空 false：非空
 */
 public static boolean isEmpty(Collection<?> coll) {
 
 return isNull(coll) || coll.isEmpty();
 }
 
 /**
 * * 判断一个Collection是否非空，包含List，Set，Queue
 *
 * @param coll 要判断的Collection
 * @return true：非空 false：空
 */
 public static boolean isNotEmpty(Collection<?> coll) {
 
 return !isEmpty(coll);
 }
 
 /**
 * * 判断一个对象数组是否为空
 *
 * @param objects 要判断的对象数组
 * * @return true：为空 false：非空
 */
 public static boolean isEmpty(Object[] objects) {
 
 return isNull(objects) || (objects.length == 0);
 }
 
 /**
 * * 判断一个对象数组是否非空
 *
 * @param objects 要判断的对象数组
 * @return true：非空 false：空
 */
 public static boolean isNotEmpty(Object[] objects) {
 
 return !isEmpty(objects);
 }
 
 /**
 * * 判断一个Map是否为空
 *
 * @param map 要判断的Map
 * @return true：为空 false：非空
 */
 public static boolean isEmpty(Map<?, ?> map) {
 
 return isNull(map) || map.isEmpty();
 }
 
 /**
 * * 判断一个Map是否为空
 *
 * @param map 要判断的Map
 * @return true：非空 false：空
 */
 public static boolean isNotEmpty(Map<?, ?> map) {
 
 return !isEmpty(map);
 }
 
 /**
 * * 判断一个字符串是否为空串
 *
 * @param str String
 * @return true：为空 false：非空
 */
 public static boolean isEmpty(String str) {
 
 return isNull(str) || NULLSTR.equals(str.trim());
 }
 
 /**
 * * 判断一个字符串是否为非空串
 *
 * @param str String
 * @return true：非空串 false：空串
 */
 public static boolean isNotEmpty(String str) {
 
 return !isEmpty(str);
 }
 
 /**
 * * 判断一个对象是否为空
 *
 * @param object Object
 * @return true：为空 false：非空
 */
 public static boolean isNull(Object object) {
 
 return object == null;
 }
 
 /**
 * * 判断一个对象是否非空
 *
 * @param object Object
 * @return true：非空 false：空
 */
 public static boolean isNotNull(Object object) {
 
 return !isNull(object);
 }
 
 /**
 * * 判断一个对象是否是数组类型（Java基本型别的数组）
 *
 * @param object 对象
 * @return true：是数组 false：不是数组
 */
 public static boolean isArray(Object object) {
 
 return isNotNull(object) && object.getClass().isArray();
 }
 
 /**
 * 去空格
 */
 public static String trim(String str) {
 
 return (str == null ? "" : str.trim());
 }
 
 /**
 * 截取字符串
 *
 * @param str 字符串
 * @param start 开始
 * @return 结果
 */
 public static String substring(final String str, int start) {
 
 if (str == null) {
 
 return NULLSTR;
 }
 
 if (start < 0) {
 
 start = str.length() + start;
 }
 
 if (start < 0) {
 
 start = 0;
 }
 if (start > str.length()) {
 
 return NULLSTR;
 }
 
 return str.substring(start);
 }
 
 /**
 * 截取字符串
 *
 * @param str 字符串
 * @param start 开始
 * @param end 结束
 * @return 结果
 */
 public static String substring(final String str, int start, int end) {
 
 if (str == null) {
 
 return NULLSTR;
 }
 
 if (end < 0) {
 
 end = str.length() + end;
 }
 if (start < 0) {
 
 start = str.length() + start;
 }
 
 if (end > str.length()) {
 
 end = str.length();
 }
 
 if (start > end) {
 
 return NULLSTR;
 }
 
 if (start < 0) {
 
 start = 0;
 }
 if (end < 0) {
 
 end = 0;
 }
 
 return str.substring(start, end);
 }
 
 /**
 * 下划线转驼峰命名
 */
 public static String toUnderScoreCase(String str) {
 
 if (str == null) {
 
 return null;
 }
 StringBuilder sb = new StringBuilder();
 // 前置字符是否大写
 boolean preCharIsUpperCase = true;
 // 当前字符是否大写
 boolean curreCharIsUpperCase = true;
 // 下一字符是否大写
 boolean nexteCharIsUpperCase = true;
 for (int i = 0; i < str.length(); i++) {
 
 char c = str.charAt(i);
 if (i > 0) {
 
 preCharIsUpperCase = Character.isUpperCase(str.charAt(i - 1));
 } else {
 
 preCharIsUpperCase = false;
 }
 
 curreCharIsUpperCase = Character.isUpperCase(c);
 
 if (i < (str.length() - 1)) {
 
 nexteCharIsUpperCase = Character.isUpperCase(str.charAt(i + 1));
 }
 
 if (preCharIsUpperCase && curreCharIsUpperCase && !nexteCharIsUpperCase) {
 
 sb.append(SEPARATOR);
 } else if ((i != 0 && !preCharIsUpperCase) && curreCharIsUpperCase) {
 
 sb.append(SEPARATOR);
 }
 sb.append(Character.toLowerCase(c));
 }
 
 return sb.toString();
 }
 
 /**
 * 是否包含字符串
 *
 * @param str 验证字符串
 * @param strs 字符串组
 * @return 包含返回true
 */
 public static boolean inStringIgnoreCase(String str, String... strs) {
 
 if (str != null && strs != null) {
 
 for (String s : strs) {
 
 if (str.equalsIgnoreCase(trim(s))) {
 
 return true;
 }
 }
 }
 return false;
 }
 
 /**
 * 格式化字符串 
 * 此方法只是简单将占位符 {} 按照顺序替换为参数 
 * 如果想输出 {} 使用 \\转义 { 即可，如果想输出 {} 之前的 \ 使用双转义符 \\\\ 即可 
 * 例： 
 * 通常使用：format("this is {} for {}", "a", "b") -> this is a for b 
 * 转义{}： format("this is \\{} for {}", "a", "b") -> this is \{} for a 
 * 转义\： format("this is \\\\{} for {}", "a", "b") -> this is \a for b 
 *
 * @param strPattern 字符串模板
 * @param argArray 参数列表
 * @return 结果
 */
 public static String strFormat(String strPattern, Object... argArray) {
 
 if (StringUtils.isEmpty(strPattern) || StringUtils.isEmpty(argArray)) {
 
 return strPattern;
 }
 final int strPatternLength = strPattern.length();
 
 // 初始化定义好的长度以获得更好的性能
 StringBuilder sbuf = new StringBuilder(strPatternLength + 50);
 
 int handledPosition = 0;
 int delimIndex;// 占位符所在位置
 for (int argIndex = 0; argIndex < argArray.length; argIndex++) {
 
 delimIndex = strPattern.indexOf(EMPTY_JSON, handledPosition);
 if (delimIndex == -1) {
 
 if (handledPosition == 0) {
 
 return strPattern;
 } else {
 
 // 字符串模板剩余部分不再包含占位符，加入剩余部分后返回结果
 sbuf.append(strPattern, handledPosition, strPatternLength);
 return sbuf.toString();
 }
 } else {
 
 if (delimIndex > 0 && strPattern.charAt(delimIndex - 1) == C_BACKSLASH) {
 
 if (delimIndex > 1 && strPattern.charAt(delimIndex - 2) == C_BACKSLASH) {
 
 // 转义符之前还有一个转义符，占位符依旧有效
 sbuf.append(strPattern, handledPosition, delimIndex - 1);
 sbuf.append(ConvertUtils.utf8Str(argArray[argIndex]));
 handledPosition = delimIndex + 2;
 } else {
 
 // 占位符被转义
 argIndex--;
 sbuf.append(strPattern, handledPosition, delimIndex - 1);
 sbuf.append(C_DELIM_START);
 handledPosition = delimIndex + 1;
 }
 } else {
 
 // 正常占位符
 sbuf.append(strPattern, handledPosition, delimIndex);
 sbuf.append(ConvertUtils.utf8Str(argArray[argIndex]));
 handledPosition = delimIndex + 2;
 }
 }
 }
 // 加入最后一个占位符后所有的字符
 sbuf.append(strPattern, handledPosition, strPattern.length());
 
 return sbuf.toString();
 }
 
 /**
 * 将下划线大写方式命名的字符串转换为驼峰式。如果转换前的下划线大写方式命名的字符串为空，则返回空字符串。 例如：HELLO_WORLD->HelloWorld
 *
 * @param name 转换前的下划线大写方式命名的字符串
 * @return 转换后的驼峰式命名的字符串
 */
 public static String convertToCamelCase(String name) {
 
 StringBuilder result = new StringBuilder();
 // 快速检查
 if (name == null || name.isEmpty()) {
 
 // 没必要转换
 return "";
 } else if (!name.contains("_")) {
 
 // 不含下划线，仅将首字母大写
 return name.substring(0, 1).toUpperCase() + name.substring(1);
 }
 // 用下划线将原始字符串分割
 String[] camels = name.split("_");
 for (String camel : camels) {
 
 // 跳过原始字符串中开头、结尾的下换线或双重下划线
 if (camel.isEmpty()) {
 
 continue;
 }
 // 首字母大写
 result.append(camel.substring(0, 1).toUpperCase());
 result.append(camel.substring(1).toLowerCase());
 }
 return result.toString();
 }
 
 /**
 * 驼峰式命名法 例如：user_name->userName
 */
 public static String toCamelCase(String s) {
 
 if (s == null) {
 
 return null;
 }
 s = s.toLowerCase();
 StringBuilder sb = new StringBuilder(s.length());
 boolean upperCase = false;
 for (int i = 0; i < s.length(); i++) {
 
 char c = s.charAt(i);
 if (c == SEPARATOR) {
 
 upperCase = true;
 } else if (upperCase) {
 
 sb.append(Character.toUpperCase(c));
 upperCase = false;
 } else {
 
 sb.append(c);
 }
 }
 return sb.toString();
 }
 }

### ServletUtils ###

package com.yolo.springboot.kaptcha.util;
    
    import java.io.IOException;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    import javax.servlet.http.HttpSession;
    
    import org.springframework.web.context.request.RequestAttributes;
    import org.springframework.web.context.request.RequestContextHolder;
    import org.springframework.web.context.request.ServletRequestAttributes;
    
    /**
     * 客户端工具类
     */
    public class ServletUtils {
        
        /**
         * 获取String参数
         */
        public static String getParameter(String name) {
        
            return getRequest().getParameter(name);
        }
    
        /**
         * 获取String参数
         */
        public static String getParameter(String name, String defaultValue) {
        
            return ConvertUtils.toStr(getRequest().getParameter(name), defaultValue);
        }
    
        /**
         * 获取Integer参数
         */
        public static Integer getParameterToInt(String name) {
        
            return ConvertUtils.toInt(getRequest().getParameter(name));
        }
    
        /**
         * 获取Integer参数
         */
        public static Integer getParameterToInt(String name, Integer defaultValue) {
        
            return ConvertUtils.toInt(getRequest().getParameter(name), defaultValue);
        }
    
        /**
         * 获取request
         */
        public static HttpServletRequest getRequest() {
        
            return getRequestAttributes().getRequest();
        }
    
        /**
         * 获取response
         */
        public static HttpServletResponse getResponse() {
        
            return getRequestAttributes().getResponse();
        }
    
        /**
         * 获取session
         */
        public static HttpSession getSession() {
        
            return getRequest().getSession();
        }
    
        public static ServletRequestAttributes getRequestAttributes() {
        
            RequestAttributes attributes = RequestContextHolder.getRequestAttributes();
            return (ServletRequestAttributes) attributes;
        }
    
        /**
         * 将字符串渲染到客户端
         *
         * @param response 渲染对象
         * @param string   待渲染的字符串
         * @return null
         */
        public static String renderString(HttpServletResponse response, String string) {
        
            try {
        
                response.setContentType("application/json");
                response.setCharacterEncoding("utf-8");
                response.getWriter().print(string);
            } catch (IOException e) {
        
                e.printStackTrace();
            }
            return null;
        }
    
        /**
         * 是否是Ajax异步请求
         *
         * @param request
         */
        public static boolean isAjaxRequest(HttpServletRequest request) {
        
            String accept = request.getHeader("accept");
            if (accept != null && accept.contains("application/json")) {
        
                return true;
            }
    
            String xRequestedWith = request.getHeader("X-Requested-With");
            if (xRequestedWith != null && xRequestedWith.contains("XMLHttpRequest")) {
        
                return true;
            }
    
            String uri = request.getRequestURI();
            if (StringUtils.inStringIgnoreCase(uri, ".json", ".xml")) {
        
                return true;
            }
    
            String ajax = request.getParameter("__ajax");
            if (StringUtils.inStringIgnoreCase(ajax, "json", "xml")) {
        
                return true;
            }
            return false;
        }
    }

### FileDirectoryUtils ###

/**
     * @ClassName fileDirectoryUtils
     * @Description 文件目录工具类
     * @Author hl
     * @Date 2022/12/7 10:53
     * @Version 1.0
     */
    public class FileDirectoryUtils {
        
    
        /**
         * 获取临时目录
         */
        public static String getTempPath() {
        
            return System.getProperty("java.io.tmpdir");
        }
    
        /**
         * 获取当前项目工作目录
         */
        public static String getUserDir() {
        
            return System.getProperty("user.dir");
        }
    
        /**
         * 获取当前项目工作目录
         */
        public static String getCurrentProjectDownloadPath() {
        
            return System.getProperty("user.dir") + File.separator + "download" + File.separator;
        }
        /**
         * 获取临时下载目录
         * file.separator    文件分隔符(在 UNIX 系统中是“/”)
         * path.separator    路径分隔符(在 UNIX 系统中是“:”)
         * line.separator    行分隔符(在 UNIX 系统中是“/n”)
         */
        public static String getDownloadPath() {
        
            return getTempPath() + File.separator + "download" + File.separator;
        }
    }

### CharsetUtils ###

package com.yolo.springboot.kaptcha.util;
    
    import org.apache.commons.lang3.StringUtils;
    
    import java.nio.charset.Charset;
    import java.nio.charset.StandardCharsets;
    
    /**
     * 字符集工具类
     */
    public class CharsetUtils {
        
        /**
         * ISO-8859-1
         */
        public static final String ISO_8859_1 = "ISO-8859-1";
        /**
         * UTF-8
         */
        public static final String UTF_8 = "UTF-8";
        /**
         * GBK
         */
        public static final String GBK = "GBK";
    
        /**
         * ISO-8859-1
         */
        public static final Charset CHARSET_ISO_8859_1 = Charset.forName(ISO_8859_1);
        /**
         * UTF-8
         */
        public static final Charset CHARSET_UTF_8 = Charset.forName(UTF_8);
        /**
         * GBK
         */
        public static final Charset CHARSET_GBK = Charset.forName(GBK);
    
        /**
         * 转换为Charset对象
         *
         * @param charset 字符集，为空则返回默认字符集
         * @return Charset
         */
        public static Charset charset(String charset) {
        
            return StringUtils.isEmpty(charset) ? Charset.defaultCharset() : Charset.forName(charset);
        }
    
        /**
         * 转换字符串的字符集编码
         *
         * @param source      字符串
         * @param srcCharset  源字符集，默认ISO-8859-1
         * @param destCharset 目标字符集，默认UTF-8
         * @return 转换后的字符集
         */
        public static String convert(String source, String srcCharset, String destCharset) {
        
            return convert(source, Charset.forName(srcCharset), Charset.forName(destCharset));
        }
    
        /**
         * 转换字符串的字符集编码
         *
         * @param source      字符串
         * @param srcCharset  源字符集，默认ISO-8859-1
         * @param destCharset 目标字符集，默认UTF-8
         * @return 转换后的字符集
         */
        public static String convert(String source, Charset srcCharset, Charset destCharset) {
        
            if (null == srcCharset) {
        
                srcCharset = StandardCharsets.ISO_8859_1;
            }
    
            if (null == destCharset) {
        
                srcCharset = StandardCharsets.UTF_8;
            }
    
            if (StringUtils.isEmpty(source) || srcCharset.equals(destCharset)) {
        
                return source;
            }
    
            return new String(source.getBytes(srcCharset), destCharset);
        }
    
        /**
         * @return 系统字符集编码
         */
        public static String systemCharset() {
        
            return Charset.defaultCharset().name();
        }
    }

### 媒体类型工具类 ###

package com.example.file.util;
    
    /**
     * 媒体类型工具类
     */
    public class MimeTypeUtils {
        
        public static final String IMAGE_PNG = "image/png";
    
        public static final String IMAGE_JPG = "image/jpg";
    
        public static final String IMAGE_JPEG = "image/jpeg";
    
        public static final String IMAGE_BMP = "image/bmp";
    
        public static final String IMAGE_GIF = "image/gif";
    
        public static final String[] IMAGE_EXTENSION = {
        "bmp", "gif", "jpg", "jpeg", "png"};
    
        public static final String[] FLASH_EXTENSION = {
        "swf", "flv"};
    
        public static final String[] MEDIA_EXTENSION = {
        "swf", "flv", "mp3", "wav", "wma", "wmv", "mid", "avi", "mpg",
                "asf", "rm", "rmvb"};
    
        public static final String[] DEFAULT_ALLOWED_EXTENSION = {
        
                // 图片
                "bmp", "gif", "jpg", "jpeg", "png",
                // word excel powerpoint
                "doc", "docx", "xls", "xlsx", "ppt", "pptx", "html", "htm", "txt",
                // 压缩文件
                "rar", "zip", "gz", "bz2",
                // pdf
                "pdf"};
    
        public static String getExtension(String prefix) {
        
            switch (prefix) {
        
                case IMAGE_PNG:
                    return "png";
                case IMAGE_JPG:
                    return "jpg";
                case IMAGE_JPEG:
                    return "jpeg";
                case IMAGE_BMP:
                    return "bmp";
                case IMAGE_GIF:
                    return "gif";
                default:
                    return "";
            }
        }
    }

### 文件处理工具类 ###

package com.example.file.util;
    
    
    import javax.servlet.http.HttpServletRequest;
    import java.io.*;
    import java.net.URLEncoder;
    
    /**
     * 文件处理工具类
     */
    public class FileUtils {
        
        public static String FILENAME_PATTERN = "[a-zA-Z0-9_\\-\\|\\.\\u4e00-\\u9fa5]+";
    
        /**
         * 输出指定文件的byte数组
         *
         * @param filePath 文件路径
         * @param os       输出流
         */
        public static void writeBytes(String filePath, OutputStream os) throws IOException {
        
            FileInputStream fis = null;
            try {
        
                File file = new File(filePath);
                if (!file.exists()) {
        
                    throw new FileNotFoundException(filePath);
                }
                fis = new FileInputStream(file);
                byte[] b = new byte[1024];
                int length;
                while ((length = fis.read(b)) > 0) {
        
                    os.write(b, 0, length);
                }
            } finally {
        
                if (os != null) {
        
                    try {
        
                        os.close();
                    } catch (IOException e1) {
        
                        e1.printStackTrace();
                    }
                }
                if (fis != null) {
        
                    try {
        
                        fis.close();
                    } catch (IOException e1) {
        
                        e1.printStackTrace();
                    }
                }
            }
        }
    
        /**
         * 删除文件
         *
         * @param filePath 文件
         */
        public static void deleteFile(String filePath) {
        
            File file = new File(filePath);
            // 路径为文件且不为空则进行删除
            if (file.isFile() && file.exists()) {
        
                file.delete();
            }
        }
    
        /**
         * 文件名称验证
         *
         * @param filename 文件名称
         * @return true 正常 false 非法
         */
        public static boolean isValidFilename(String filename) {
        
            return filename.matches(FILENAME_PATTERN);
        }
    
        /**
         * 下载文件名重新编码
         *
         * @param request  请求对象
         * @param fileName 文件名
         * @return 编码后的文件名
         */
        public static String setFileDownloadHeader(HttpServletRequest request, String fileName)
                throws UnsupportedEncodingException {
        
            final String agent = request.getHeader("USER-AGENT");
            String filename = fileName;
            if (agent.contains("MSIE")) {
        
                // IE浏览器
                filename = URLEncoder.encode(filename, "utf-8");
                filename = filename.replace("+", " ");
            } else if (agent.contains("Firefox")) {
        
                // 火狐浏览器
                filename = new String(fileName.getBytes(), "ISO8859-1");
            } else if (agent.contains("Chrome")) {
        
                // google浏览器
                filename = URLEncoder.encode(filename, "utf-8");
            } else {
        
                // 其它浏览器
                filename = URLEncoder.encode(filename, "utf-8");
            }
            return filename;
        }
    
        /**
         * 获取系统临时目录
         *
         */
        public static String getTemp() {
        
            return System.getProperty("java.io.tmpdir");
        }
    
        /**
         * 创建临时文件
         *
         * @param filePath
         * @param data
         */
        public static File createTempFile(String filePath, byte[] data) throws IOException {
        
            String temp = getTemp() + filePath;
            File file = new File(temp);
            if (!file.getParentFile().exists()) {
        
                file.getParentFile().mkdirs();
            }
            if (!file.exists()) {
        
                file.createNewFile();
            }
            FileOutputStream fos = new FileOutputStream(file);
            fos.write(data, 0, data.length);
            fos.flush();
            fos.close();
            return file;
        }
    }

### Md5加密方法 ###

package com.example.file.util;
 
 import java.nio.charset.StandardCharsets;
 import java.security.MessageDigest;
 import java.util.Objects;
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 /**
 * Md5加密方法
 */
 public class Md5Utils {
 
 private static final Logger log = LoggerFactory.getLogger(Md5Utils.class);
 
 private static byte[] md5(String s) {
 
 MessageDigest algorithm;
 try {
 
 algorithm = MessageDigest.getInstance("MD5");
 algorithm.reset();
 algorithm.update(s.getBytes(StandardCharsets.UTF_8));
 return algorithm.digest();
 } catch (Exception e) {
 
 log.error("MD5 Error...", e);
 }
 return null;
 }
 
 private static String toHex(byte[] hash) {
 
 if (hash == null) {
 
 return null;
 }
 StringBuilder buf = new StringBuilder(hash.length * 2);
 int i;
 
 for (i = 0; i < hash.length; i++) {
 
 if ((hash[i] & 0xff) < 0x10) {
 
 buf.append("0");
 }
 buf.append(Long.toString(hash[i] & 0xff, 16));
 }
 return buf.toString();
 }
 
 public static String hash(String s) {
 
 try {
 
 return new String(Objects.requireNonNull(toHex(md5(s))).getBytes(StandardCharsets.UTF_8), StandardCharsets.UTF_8);
 } catch (Exception e) {
 
 log.error("not supported charset...{}", e);
 return s;
 }
 }
 }

### 文件上传工具类 ###

package com.example.file.util;
    
    import java.io.File;
    import java.io.IOException;
    import java.util.Arrays;
    import java.util.Date;
    import java.util.Objects;
    import org.apache.commons.io.FilenameUtils;
    import org.apache.commons.lang3.time.DateFormatUtils;
    import org.apache.tomcat.util.http.fileupload.FileUploadException;
    import org.springframework.web.multipart.MultipartFile;
    import javax.annotation.processing.FilerException;
    
    /**
     * 文件上传工具类
     *
     * @author ruoyi
     */
    public class FileUploadUtils {
        
        /**
         * 默认大小 50M
         */
        public static final long DEFAULT_MAX_SIZE = 50 * 1024 * 1024;
    
        /**
         * 默认的文件名最大长度 100
         */
        public static final int DEFAULT_FILE_NAME_LENGTH = 100;
    
        private static int counter = 0;
    
        public static final String RESOURCE_PREFIX  = "/profile";
    
        /**
         * 根据文件路径上传
         *
         * @param baseDir 相对应用的基目录
         * @param file    上传的文件
         * @return 文件名称
         * @throws IOException
         */
        public static String upload(String baseDir, MultipartFile file) throws IOException {
        
            try {
        
                return upload(baseDir, file, MimeTypeUtils.DEFAULT_ALLOWED_EXTENSION);
            } catch (Exception e) {
        
                throw new IOException(e.getMessage(), e);
            }
        }
    
        /**
         * 文件上传
         *
         * @param baseDir   相对应用的基目录
         * @param file      上传的文件
         * @param allowedExtension 上传文件类型
         * @return 返回上传成功的文件名
         * @throws IOException                          比如读写文件出错时
         */
        public static String upload(String baseDir, MultipartFile file, String[] allowedExtension) throws IOException, FileUploadException {
        
            int fileNameLength = Objects.requireNonNull(file.getOriginalFilename()).length();
            if (fileNameLength > FileUploadUtils.DEFAULT_FILE_NAME_LENGTH) {
        
                throw new FilerException("默认的文件名最大长度 :" + DEFAULT_FILE_NAME_LENGTH);
            }
            assertAllowed(file, allowedExtension);
            String fileName = extractFilename(file);
            File desc = getAbsoluteFile(baseDir, fileName);
            file.transferTo(desc);
            return getPathFileName(baseDir, fileName);
        }
    
        /**
         * 编码文件名
         */
        public static String extractFilename(MultipartFile file) {
        
            String fileName = file.getOriginalFilename();
            String extension = getExtension(file);
            fileName = datePath() + "/" + encodingFilename(fileName) + "." + extension;
            return fileName;
        }
    
        public static String datePath() {
        
            Date now = new Date();
            return DateFormatUtils.format(now, "yyyy/MM/dd");
        }
    
        private static String getPathFileName(String uploadDir, String fileName){
        
            int dirLastIndex = uploadDir.lastIndexOf("/") + 1;
            String currentDir = StringUtils.substring(uploadDir, dirLastIndex);
            return RESOURCE_PREFIX + "/" + currentDir + "/" + fileName;
        }
    
        private static File getAbsoluteFile(String uploadDir, String fileName){
        
            return new File(uploadDir + File.separator + fileName);
        }
    
        /**
         * 编码文件名
         */
        private static String encodingFilename(String fileName) {
        
            fileName = fileName.replace("_", " ");
            fileName = Md5Utils.hash(fileName + System.nanoTime() + counter++);
            return fileName;
        }
    
        /**
         * 文件大小校验
         *
         * @param file 上传的文件
         */
        public static void assertAllowed(MultipartFile file, String[] allowedExtension) throws FilerException, FileUploadException {
        
            long size = file.getSize();
            if (size > DEFAULT_MAX_SIZE) {
        
                throw new FilerException("默认的文件名最大长度 :" +  DEFAULT_MAX_SIZE / 1024 / 1024);
            }
            String fileName = file.getOriginalFilename();
            String extension = getExtension(file);
            if (allowedExtension != null && !isAllowedExtension(extension, allowedExtension)) {
        
                if (allowedExtension == MimeTypeUtils.IMAGE_EXTENSION) {
        
                    throw new FileUploadException("filename : [" + fileName + "], extension : [" + extension + "], allowed extension : [" + Arrays.toString(allowedExtension) + "]");
                } else if (allowedExtension == MimeTypeUtils.FLASH_EXTENSION) {
        
                    throw new FileUploadException("filename : [" + fileName + "], extension : [" + extension + "], allowed extension : [" + Arrays.toString(allowedExtension) + "]");
                } else if (allowedExtension == MimeTypeUtils.MEDIA_EXTENSION) {
        
                    throw new FileUploadException("filename : [" + fileName + "], extension : [" + extension + "], allowed extension : [" + Arrays.toString(allowedExtension) + "]");
                } else {
        
                    throw new FileUploadException("filename : [" + fileName + "], extension : [" + extension + "], allowed extension : [" + Arrays.toString(allowedExtension) + "]");
                }
            }
        }
    
        /**
         * 判断MIME类型是否是允许的MIME类型
         *
         * @param extension
         * @param allowedExtension
         * @return
         */
        public static boolean isAllowedExtension(String extension, String[] allowedExtension) {
        
            for (String str : allowedExtension) {
        
                if (str.equalsIgnoreCase(extension)) {
        
                    return true;
                }
            }
            return false;
        }
    
        /**
         * 获取文件名的后缀
         *
         * @param file 表单文件
         * @return 后缀名
         */
        public static String getExtension(MultipartFile file) {
        
            String extension = FilenameUtils.getExtension(file.getOriginalFilename());
            if (StringUtils.isEmpty(extension)) {
        
                extension = MimeTypeUtils.getExtension(Objects.requireNonNull(file.getContentType()));
            }
            return extension;
        }
    }