springboot：文件上传下载及静态资源访问

川长思鸟来 2024-03-31 16:29 83阅读 0赞

## springboot：文件上传下载及静态资源访问 ##

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

*  springboot：文件上传下载及静态资源访问
 *   *  一、依赖
     *  二、配置类
     *  三、工具类
     *   *  字符集工具类
         *  类型转换工具类
         *  文件上传工具类
         *  文件处理工具类
         *  Md5加密方法
         *  媒体类型工具类
         *  字符串工具类
         *  返回类
     *  四、上传下载功能
     *   *  上传
         *  下载

> 完整代码在[gitee][]

### 一、依赖 ###

<dependencies>
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-web</artifactId>
 </dependency>
 
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-test</artifactId>
 <scope>test</scope>
 </dependency>
 
 <dependency>
 <groupId>org.projectlombok</groupId>
 <artifactId>lombok</artifactId>
 </dependency>
 
 <dependency>
 <groupId>cn.hutool</groupId>
 <artifactId>hutool-all</artifactId>
 <version>5.6.3</version>
 </dependency>
 
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-configuration-processor</artifactId>
 <optional>true</optional>
 </dependency>
 
 <dependency>
 <groupId>org.apache.commons</groupId>
 <artifactId>commons-lang3</artifactId>
 <version>3.9</version>
 </dependency>
 
 <dependency>
 <groupId>org.apache.commons</groupId>
 <artifactId>commons-io</artifactId>
 <version>1.3.2</version>
 </dependency>
 
 </dependencies>

### 二、配置类 ###

> application.properties

server.port=8888
    dfs.win.path=D:/myeCode/hlCode/springboot-file/src/main/resources/file-upload
    dfs.linux.path=/resources/file-upload
    dfs.domain=127.0.0.1:8888

> DfsConfig 上传文件信息实体类

@Data
    @Component
    public class DfsConfig {
        
    
        /** windows 路径*/
        @Value("${dfs.win.path}")
        private String winPath;
    
        /** linux或者mac 路径*/
        @Value("${dfs.linux.path}")
        private String linuxPath;
    
        //生产环境建议用nginx绑定域名映射
        /** 域名*/
        @Value("${dfs.domain}")
        private String domain;
    }

> 自定义静态资源映射配置类

注意：

![在这里插入图片描述][829fde66761c4595acb9fcfef13769c2.png_pic_center]

package com.example.file.config;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
    import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
    
    /**
     * @ClassName ResourcesConfig
     * @Description 静态资源映射
     * 生产使用为了安全,不建议通过这种方式映射,推荐使用nginx配置
     * @Author hl
     * @Date 2022/12/8 10:05
     * @Version 1.0
     */
    @Configuration
    public class ResourcesConfig implements WebMvcConfigurer {
        
    
        @Autowired
        private DfsConfig dfsConfig;
    
        public static final String RESOURCE_PREFIX  = "/profile";
    
        /**
         * Spring Boot 访问静态资源的位置(优先级按以下顺序)
         * classpath默认就是resources,所以classpath:/static/ 就是resources/static/
         * classpath:/META‐INF/resources/
         * classpath:/resources/
         * classpath:/static/
         * classpath:/public/
         */
        @Override
        public void addResourceHandlers(ResourceHandlerRegistry registry) {
        
    
            String os = System.getProperty("os.name");
            if (os.toLowerCase().startsWith("win")) {
        
                //如果是Windows系统
                registry.addResourceHandler(RESOURCE_PREFIX + "/**")   //指的是对外暴露的访问路径
                        .addResourceLocations("file:" + dfsConfig.getWinPath()); //指的是内部文件放置的目录
            } else {
        
                //linux 和mac
                registry.addResourceHandler(RESOURCE_PREFIX + "/**")   //指的是对外暴露的访问路径
                        .addResourceLocations("file:" + dfsConfig.getLinuxPath()); //指的是内部文件放置的目录
            }
        }
    }

### 三、工具类 ###

#### 字符集工具类 ####

package com.example.file.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 = StandardCharsets.ISO_8859_1;
        /**
         * UTF-8
         */
        public static final Charset CHARSET_UTF_8 = StandardCharsets.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;
 
 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("^整$", "零元整");
 }
 }

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

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 = new File(baseDir + File.separator + fileName);
    
            if (!desc.getParentFile().exists()){
        
                desc.getParentFile().mkdirs();
            }
    
            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 String encodingFilename(String fileName) {
        
            return Md5Utils.hash(fileName.replace("_", " ") + System.nanoTime() + counter++);
        }
    
        /**
         * 文件大小校验
         *
         * @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;
        }
    }

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

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;
    
    /**
     * 媒体类型工具类
     */
    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 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);
 }
 
 /**
 * 格式化字符串 
 * 此方法只是简单将占位符 {} 按照顺序替换为参数 
 * 如果想输出 {} 使用 \\转义 { 即可，如果想输出 {} 之前的 \ 使用双转义符 \\\\ 即可 
 * 例： 
 * 通常使用：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();
 }
 
 
 /**
 * 下划线转驼峰命名
 */
 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;
 }
 
 /**
 * 将下划线大写方式命名的字符串转换为驼峰式。如果转换前的下划线大写方式命名的字符串为空，则返回空字符串。 例如：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();
 }
 }

#### 返回类 ####

package com.example.file.common;
 
 import java.util.HashMap;
 import java.util.Map;
 
 public class R extends HashMap<String, Object> {
 
 	private static final long serialVersionUID = -8157613083634272196L;
 
 	public R() {
 
 		put("code", 0);
 		put("msg", "success");
 	}
 
 	public static R error() {
 
 		return error(500, "未知异常，请联系管理员");
 	}
 
 	public static R error(String msg) {
 
 		return error(500, msg);
 	}
 
 	public static R error(int code, String msg) {
 
 		R r = new R();
 		r.put("code", code);
 		r.put("msg", msg);
 		return r;
 	}
 
 	public static R ok(String msg) {
 
 		R r = new R();
 		r.put("msg", msg);
 		return r;
 	}
 
 	public static R data(Object obj) {
 
 		R r = new R();
 		r.put("data", obj);
 		return r;
 	}
 
 	public static R ok(Map<String, Object> map) {
 
 		R r = new R();
 		r.putAll(map);
 		return r;
 	}
 
 	public static R ok() {
 
 		return new R();
 	}
 
 	@Override
 	public R put(String key, Object value) {
 
 		super.put(key, value);
 		return this;
 	}
 }

### 四、上传下载功能 ###

#### 上传 ####

/**
         * 通用上传请求
         */
        @PostMapping("upload")
        public R upload(MultipartFile file){
        
            try {
        
                String filePath = getFilePath();
                // 上传并返回新文件名称
                String fileName = FileUploadUtils.upload(filePath, file);
                String url = dfsConfig.getDomain() + fileName;
                return Objects.requireNonNull(R.ok().put("fileName", fileName)).put("url", url);
            } catch (Exception e) {
        
                log.error("上传文件失败", e);
                return R.error(e.getMessage());
            }
        }
    
        private String getFilePath() {
        
            // 上传文件路径
            String filePath;
            String os = System.getProperty("os.name");
            if (os.toLowerCase().startsWith("win")) {
        
                //如果是Windows系统
                filePath = dfsConfig.getWinPath();
            } else {
        
                //linux 和mac
                filePath = dfsConfig.getLinuxPath();
            }
            return filePath;
        }

![在这里插入图片描述][1acba6d29fcd436490e3259bdbb5233c.png_pic_center]  
访问就是在浏览器输入那个url：  
![在这里插入图片描述][7625469b1e704186894c17373d8ad251.png]

#### 下载 ####

/**
         * 通用下载请求
         *
         * @param fileName 文件名称
         * @param delete   是否删除
         */
        @GetMapping("download")
        public void download(String fileName, Boolean delete, HttpServletResponse response, HttpServletRequest request) {
        
            try {
        
                // 上传文件路径
                String filePath = getFilePath();
                boolean validFilename = FileUtils.isValidFilename(fileName.trim());
                if (!validFilename) {
        
                    throw new Exception(StringUtils.strFormat("文件名称({})非法，不允许下载。 ", fileName));
                }
    
                String realName = fileName.substring(fileName.lastIndexOf("/") + 1);
                String substring = fileName.substring(fileName.lastIndexOf("file-upload/") + 11);
    
                filePath = filePath + substring;
                response.setCharacterEncoding("utf-8");
                response.setContentType("multipart/form-data");
                response.setHeader("Content-Disposition",
                        "attachment;fileName=" + FileUtils.setFileDownloadHeader(request, System.currentTimeMillis() + realName));
                FileUtils.writeBytes(filePath, response.getOutputStream());
                if (delete) {
        
                    FileUtils.deleteFile(filePath);
                }
            } catch (Exception e) {
        
                log.error("下载文件失败", e);
            }
        }

![在这里插入图片描述][43375ec8a25c4d0fb3ae00d87b8ddef8.png_pic_center]

[gitee]: https://gitee.com/huanglei1111/springboot-file
[829fde66761c4595acb9fcfef13769c2.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/a9933f5ba46f431aa968b17e8de87c51.png
[1acba6d29fcd436490e3259bdbb5233c.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/e262bca2f59541c79052fec59f8ba8a9.png
[7625469b1e704186894c17373d8ad251.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/35ad29ca991649398f1dd34e028811dc.png
[43375ec8a25c4d0fb3ae00d87b8ddef8.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/375c7acc3697417ea5f40c6a969a6d38.png