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

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

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

文章目录

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

完整代码在gitee

一、依赖

  1. <dependencies>
  2.         <dependency>
  3.             <groupId>org.springframework.boot</groupId>
  4.             <artifactId>spring-boot-starter-web</artifactId>
  5.         </dependency>
  7.         <dependency>
  8.             <groupId>org.springframework.boot</groupId>
  9.             <artifactId>spring-boot-starter-test</artifactId>
  10.             <scope>test</scope>
  11.         </dependency>
  13.         <dependency>
  14.             <groupId>org.projectlombok</groupId>
  15.             <artifactId>lombok</artifactId>
  16.         </dependency>
  18.         <dependency>
  19.             <groupId>cn.hutool</groupId>
  20.             <artifactId>hutool-all</artifactId>
  21.             <version>5.6.3</version>
  22.         </dependency>
  24.         <dependency>
  25.             <groupId>org.springframework.boot</groupId>
  26.             <artifactId>spring-boot-configuration-processor</artifactId>
  27.             <optional>true</optional>
  28.         </dependency>
  30.         <dependency>
  31.             <groupId>org.apache.commons</groupId>
  32.             <artifactId>commons-lang3</artifactId>
  33.             <version>3.9</version>
  34.         </dependency>
  36.         <dependency>
  37.             <groupId>org.apache.commons</groupId>
  38.             <artifactId>commons-io</artifactId>
  39.             <version>1.3.2</version>
  40.         </dependency>
  42.     </dependencies>

二、配置类

application.properties

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

DfsConfig 上传文件信息实体类

  1. @Data
  2. @Component
  3. public class DfsConfig {
  6.     /** windows 路径*/
  7.     @Value("${dfs.win.path}")
  8.     private String winPath;
  10.     /** linux或者mac 路径*/
  11.     @Value("${dfs.linux.path}")
  12.     private String linuxPath;
  14.     //生产环境建议用nginx绑定域名映射
  15.     /** 域名*/
  16.     @Value("${dfs.domain}")
  17.     private String domain;
  18. }

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

注意：

在这里插入图片描述

  1. package com.example.file.config;
  3. import org.springframework.beans.factory.annotation.Autowired;
  4. import org.springframework.context.annotation.Configuration;
  5. import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
  6. import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
  8. /**
  9.  * @ClassName ResourcesConfig
  10.  * @Description 静态资源映射
  11.  * 生产使用为了安全,不建议通过这种方式映射,推荐使用nginx配置
  12.  * @Author hl
  13.  * @Date 2022/12/8 10:05
  14.  * @Version 1.0
  15.  */
  16. @Configuration
  17. public class ResourcesConfig implements WebMvcConfigurer {
  20.     @Autowired
  21.     private DfsConfig dfsConfig;
  23.     public static final String RESOURCE_PREFIX  = "/profile";
  25.     /**
  26.      * Spring Boot 访问静态资源的位置(优先级按以下顺序)
  27.      * classpath默认就是resources,所以classpath:/static/ 就是resources/static/
  28.      * classpath:/META‐INF/resources/
  29.      * classpath:/resources/
  30.      * classpath:/static/
  31.      * classpath:/public/
  32.      */
  33.     @Override
  34.     public void addResourceHandlers(ResourceHandlerRegistry registry) {
  37.         String os = System.getProperty("os.name");
  38.         if (os.toLowerCase().startsWith("win")) {
  40.             //如果是Windows系统
  41.             registry.addResourceHandler(RESOURCE_PREFIX + "/**")   //指的是对外暴露的访问路径
  42.                     .addResourceLocations("file:" + dfsConfig.getWinPath()); //指的是内部文件放置的目录
  43.         } else {
  45.             //linux 和mac
  46.             registry.addResourceHandler(RESOURCE_PREFIX + "/**")   //指的是对外暴露的访问路径
  47.                     .addResourceLocations("file:" + dfsConfig.getLinuxPath()); //指的是内部文件放置的目录
  48.         }
  49.     }
  50. }

三、工具类

字符集工具类

  1. package com.example.file.util;
  3. import org.apache.commons.lang3.StringUtils;
  5. import java.nio.charset.Charset;
  6. import java.nio.charset.StandardCharsets;
  8. /**
  9.  * 字符集工具类
  10.  */
  11. public class CharsetUtils {
  13.     /**
  14.      * ISO-8859-1
  15.      */
  16.     public static final String ISO_8859_1 = "ISO-8859-1";
  17.     /**
  18.      * UTF-8
  19.      */
  20.     public static final String UTF_8 = "UTF-8";
  21.     /**
  22.      * GBK
  23.      */
  24.     public static final String GBK = "GBK";
  26.     /**
  27.      * ISO-8859-1
  28.      */
  29.     public static final Charset CHARSET_ISO_8859_1 = StandardCharsets.ISO_8859_1;
  30.     /**
  31.      * UTF-8
  32.      */
  33.     public static final Charset CHARSET_UTF_8 = StandardCharsets.UTF_8;
  34.     /**
  35.      * GBK
  36.      */
  37.     public static final Charset CHARSET_GBK = Charset.forName(GBK);
  39.     /**
  40.      * 转换为Charset对象
  41.      *
  42.      * @param charset 字符集，为空则返回默认字符集
  43.      * @return Charset
  44.      */
  45.     public static Charset charset(String charset) {
  47.         return StringUtils.isEmpty(charset) ? Charset.defaultCharset() : Charset.forName(charset);
  48.     }
  50.     /**
  51.      * 转换字符串的字符集编码
  52.      *
  53.      * @param source      字符串
  54.      * @param srcCharset  源字符集，默认ISO-8859-1
  55.      * @param destCharset 目标字符集，默认UTF-8
  56.      * @return 转换后的字符集
  57.      */
  58.     public static String convert(String source, String srcCharset, String destCharset) {
  60.         return convert(source, Charset.forName(srcCharset), Charset.forName(destCharset));
  61.     }
  63.     /**
  64.      * 转换字符串的字符集编码
  65.      *
  66.      * @param source      字符串
  67.      * @param srcCharset  源字符集，默认ISO-8859-1
  68.      * @param destCharset 目标字符集，默认UTF-8
  69.      * @return 转换后的字符集
  70.      */
  71.     public static String convert(String source, Charset srcCharset, Charset destCharset) {
  73.         if (null == srcCharset) {
  75.             srcCharset = StandardCharsets.ISO_8859_1;
  76.         }
  78.         if (null == destCharset) {
  80.             srcCharset = StandardCharsets.UTF_8;
  81.         }
  83.         if (StringUtils.isEmpty(source) || srcCharset.equals(destCharset)) {
  85.             return source;
  86.         }
  88.         return new String(source.getBytes(srcCharset), destCharset);
  89.     }
  91.     /**
  92.      * @return 系统字符集编码
  93.      */
  94.     public static String systemCharset() {
  96.         return Charset.defaultCharset().name();
  97.     }
  98. }

类型转换工具类

  1. package com.example.file.util;
  3. import org.apache.commons.lang3.StringUtils;
  5. import java.math.BigDecimal;
  6. import java.math.BigInteger;
  7. import java.nio.ByteBuffer;
  8. import java.nio.charset.Charset;
  9. import java.text.NumberFormat;
  10. import java.util.Set;
  12. /**
  13.  * 类型转换器
  14.  */
  15. public class ConvertUtils {
  17.     /**
  18.      * 转换为字符串<br>
  19.      * 如果给定的值为null，或者转换失败，返回默认值<br>
  20.      * 转换失败不会报错
  21.      *
  22.      * @param value        被转换的值
  23.      * @param defaultValue 转换错误时的默认值
  24.      * @return 结果
  25.      */
  26.     public static String toStr(Object value, String defaultValue) {
  28.         if (null == value) {
  30.             return defaultValue;
  31.         }
  32.         if (value instanceof String) {
  34.             return (String) value;
  35.         }
  36.         return value.toString();
  37.     }
  39.     /**
  40.      * 转换为字符串<br>
  41.      * 如果给定的值为<code>null</code>，或者转换失败，返回默认值<code>null</code><br>
  42.      * 转换失败不会报错
  43.      *
  44.      * @param value 被转换的值
  45.      * @return 结果
  46.      */
  47.     public static String toStr(Object value) {
  49.         return toStr(value, null);
  50.     }
  52.     /**
  53.      * 转换为字符<br>
  54.      * 如果给定的值为null，或者转换失败，返回默认值<br>
  55.      * 转换失败不会报错
  56.      *
  57.      * @param value        被转换的值
  58.      * @param defaultValue 转换错误时的默认值
  59.      * @return 结果
  60.      */
  61.     public static Character toChar(Object value, Character defaultValue) {
  63.         if (null == value) {
  65.             return defaultValue;
  66.         }
  67.         if (value instanceof Character) {
  69.             return (Character) value;
  70.         }
  72.         final String valueStr = toStr(value, null);
  73.         return StringUtils.isEmpty(valueStr) ? defaultValue : valueStr.charAt(0);
  74.     }
  76.     /**
  77.      * 转换为字符<br>
  78.      * 如果给定的值为<code>null</code>，或者转换失败，返回默认值<code>null</code><br>
  79.      * 转换失败不会报错
  80.      *
  81.      * @param value 被转换的值
  82.      * @return 结果
  83.      */
  84.     public static Character toChar(Object value) {
  86.         return toChar(value, null);
  87.     }
  89.     /**
  90.      * 转换为byte<br>
  91.      * 如果给定的值为<code>null</code>，或者转换失败，返回默认值<br>
  92.      * 转换失败不会报错
  93.      *
  94.      * @param value        被转换的值
  95.      * @param defaultValue 转换错误时的默认值
  96.      * @return 结果
  97.      */
  98.     public static Byte toByte(Object value, Byte defaultValue) {
  100.         if (value == null) {
  102.             return defaultValue;
  103.         }
  104.         if (value instanceof Byte) {
  106.             return (Byte) value;
  107.         }
  108.         if (value instanceof Number) {
  110.             return ((Number) value).byteValue();
  111.         }
  112.         final String valueStr = toStr(value, null);
  113.         if (StringUtils.isEmpty(valueStr)) {
  115.             return defaultValue;
  116.         }
  117.         try {
  119.             return Byte.parseByte(valueStr);
  120.         } catch (Exception e) {
  122.             return defaultValue;
  123.         }
  124.     }
  126.     /**
  127.      * 转换为byte<br>
  128.      * 如果给定的值为<code>null</code>，或者转换失败，返回默认值<code>null</code><br>
  129.      * 转换失败不会报错
  130.      *
  131.      * @param value 被转换的值
  132.      * @return 结果
  133.      */
  134.     public static Byte toByte(Object value) {
  136.         return toByte(value, null);
  137.     }
  139.     /**
  140.      * 转换为Short<br>
  141.      * 如果给定的值为<code>null</code>，或者转换失败，返回默认值<br>
  142.      * 转换失败不会报错
  143.      *
  144.      * @param value        被转换的值
  145.      * @param defaultValue 转换错误时的默认值
  146.      * @return 结果
  147.      */
  148.     public static Short toShort(Object value, Short defaultValue) {
  150.         if (value == null) {
  152.             return defaultValue;
  153.         }
  154.         if (value instanceof Short) {
  156.             return (Short) value;
  157.         }
  158.         if (value instanceof Number) {
  160.             return ((Number) value).shortValue();
  161.         }
  162.         final String valueStr = toStr(value, null);
  163.         if (StringUtils.isEmpty(valueStr)) {
  165.             return defaultValue;
  166.         }
  167.         try {
  169.             return Short.parseShort(valueStr.trim());
  170.         } catch (Exception e) {
  172.             return defaultValue;
  173.         }
  174.     }
  176.     /**
  177.      * 转换为Short<br>
  178.      * 如果给定的值为<code>null</code>，或者转换失败，返回默认值<code>null</code><br>
  179.      * 转换失败不会报错
  180.      *
  181.      * @param value 被转换的值
  182.      * @return 结果
  183.      */
  184.     public static Short toShort(Object value) {
  186.         return toShort(value, null);
  187.     }
  189.     /**
  190.      * 转换为Number<br>
  191.      * 如果给定的值为空，或者转换失败，返回默认值<br>
  192.      * 转换失败不会报错
  193.      *
  194.      * @param value        被转换的值
  195.      * @param defaultValue 转换错误时的默认值
  196.      * @return 结果
  197.      */
  198.     public static Number toNumber(Object value, Number defaultValue) {
  200.         if (value == null) {
  202.             return defaultValue;
  203.         }
  204.         if (value instanceof Number) {
  206.             return (Number) value;
  207.         }
  208.         final String valueStr = toStr(value, null);
  209.         if (StringUtils.isEmpty(valueStr)) {
  211.             return defaultValue;
  212.         }
  213.         try {
  215.             return NumberFormat.getInstance().parse(valueStr);
  216.         } catch (Exception e) {
  218.             return defaultValue;
  219.         }
  220.     }
  222.     /**
  223.      * 转换为Number<br>
  224.      * 如果给定的值为空，或者转换失败，返回默认值<code>null</code><br>
  225.      * 转换失败不会报错
  226.      *
  227.      * @param value 被转换的值
  228.      * @return 结果
  229.      */
  230.     public static Number toNumber(Object value) {
  232.         return toNumber(value, null);
  233.     }
  235.     /**
  236.      * 转换为int<br>
  237.      * 如果给定的值为空，或者转换失败，返回默认值<br>
  238.      * 转换失败不会报错
  239.      *
  240.      * @param value        被转换的值
  241.      * @param defaultValue 转换错误时的默认值
  242.      * @return 结果
  243.      */
  244.     public static Integer toInt(Object value, Integer defaultValue) {
  246.         if (value == null) {
  248.             return defaultValue;
  249.         }
  250.         if (value instanceof Integer) {
  252.             return (Integer) value;
  253.         }
  254.         if (value instanceof Number) {
  256.             return ((Number) value).intValue();
  257.         }
  258.         final String valueStr = toStr(value, null);
  259.         if (StringUtils.isEmpty(valueStr)) {
  261.             return defaultValue;
  262.         }
  263.         try {
  265.             return Integer.parseInt(valueStr.trim());
  266.         } catch (Exception e) {
  268.             return defaultValue;
  269.         }
  270.     }
  272.     /**
  273.      * 转换为int<br>
  274.      * 如果给定的值为<code>null</code>，或者转换失败，返回默认值<code>null</code><br>
  275.      * 转换失败不会报错
  276.      *
  277.      * @param value 被转换的值
  278.      * @return 结果
  279.      */
  280.     public static Integer toInt(Object value) {
  282.         return toInt(value, null);
  283.     }
  285.     /**
  286.      * 转换为Integer数组<br>
  287.      *
  288.      * @param str 被转换的值
  289.      * @return 结果
  290.      */
  291.     public static Integer[] toIntArray(String str) {
  293.         return toIntArray(",", str);
  294.     }
  296.     /**
  297.      * 转换为Long数组<br>
  298.      *
  299.      * @param str 被转换的值
  300.      * @return 结果
  301.      */
  302.     public static Long[] toLongArray(String str) {
  304.         return toLongArray(",", str);
  305.     }
  307.     /**
  308.      * 转换为Integer数组<br>
  309.      *
  310.      * @param split 分隔符
  311.      * @param split 被转换的值
  312.      * @return 结果
  313.      */
  314.     public static Integer[] toIntArray(String split, String str) {
  316.         if (StringUtils.isEmpty(str)) {
  318.             return new Integer[]{
  319.     };
  320.         }
  321.         String[] arr = str.split(split);
  322.         final Integer[] ints = new Integer[arr.length];
  323.         for (int i = 0; i < arr.length; i++) {
  325.             final Integer v = toInt(arr[i], 0);
  326.             ints[i] = v;
  327.         }
  328.         return ints;
  329.     }
  331.     /**
  332.      * 转换为Long数组<br>
  333.      *
  334.      * @param split 分隔符
  335.      * @param str   被转换的值
  336.      * @return 结果
  337.      */
  338.     public static Long[] toLongArray(String split, String str) {
  340.         if (StringUtils.isEmpty(str)) {
  342.             return new Long[]{
  343.     };
  344.         }
  345.         String[] arr = str.split(split);
  346.         final Long[] longs = new Long[arr.length];
  347.         for (int i = 0; i < arr.length; i++) {
  349.             final Long v = toLong(arr[i], null);
  350.             longs[i] = v;
  351.         }
  352.         return longs;
  353.     }
  355.     /**
  356.      * 转换为String数组<br>
  357.      *
  358.      * @param str 被转换的值
  359.      * @return 结果
  360.      */
  361.     public static String[] toStrArray(String str) {
  363.         return toStrArray(",", str);
  364.     }
  366.     /**
  367.      * 转换为String数组<br>
  368.      *
  369.      * @param split 分隔符
  370.      * @param split 被转换的值
  371.      * @return 结果
  372.      */
  373.     public static String[] toStrArray(String split, String str) {
  375.         return str.split(split);
  376.     }
  378.     /**
  379.      * 转换为long<br>
  380.      * 如果给定的值为空，或者转换失败，返回默认值<br>
  381.      * 转换失败不会报错
  382.      *
  383.      * @param value        被转换的值
  384.      * @param defaultValue 转换错误时的默认值
  385.      * @return 结果
  386.      */
  387.     public static Long toLong(Object value, Long defaultValue) {
  389.         if (value == null) {
  391.             return defaultValue;
  392.         }
  393.         if (value instanceof Long) {
  395.             return (Long) value;
  396.         }
  397.         if (value instanceof Number) {
  399.             return ((Number) value).longValue();
  400.         }
  401.         final String valueStr = toStr(value, null);
  402.         if (StringUtils.isEmpty(valueStr)) {
  404.             return defaultValue;
  405.         }
  406.         try {
  408.             // 支持科学计数法
  409.             return new BigDecimal(valueStr.trim()).longValue();
  410.         } catch (Exception e) {
  412.             return defaultValue;
  413.         }
  414.     }
  416.     /**
  417.      * 转换为long<br>
  418.      * 如果给定的值为<code>null</code>，或者转换失败，返回默认值<code>null</code><br>
  419.      * 转换失败不会报错
  420.      *
  421.      * @param value 被转换的值
  422.      * @return 结果
  423.      */
  424.     public static Long toLong(Object value) {
  426.         return toLong(value, null);
  427.     }
  429.     /**
  430.      * 转换为double<br>
  431.      * 如果给定的值为空，或者转换失败，返回默认值<br>
  432.      * 转换失败不会报错
  433.      *
  434.      * @param value        被转换的值
  435.      * @param defaultValue 转换错误时的默认值
  436.      * @return 结果
  437.      */
  438.     public static Double toDouble(Object value, Double defaultValue) {
  440.         if (value == null) {
  442.             return defaultValue;
  443.         }
  444.         if (value instanceof Double) {
  446.             return (Double) value;
  447.         }
  448.         if (value instanceof Number) {
  450.             return ((Number) value).doubleValue();
  451.         }
  452.         final String valueStr = toStr(value, null);
  453.         if (StringUtils.isEmpty(valueStr)) {
  455.             return defaultValue;
  456.         }
  457.         try {
  459.             // 支持科学计数法
  460.             return new BigDecimal(valueStr.trim()).doubleValue();
  461.         } catch (Exception e) {
  463.             return defaultValue;
  464.         }
  465.     }
  467.     /**
  468.      * 转换为double<br>
  469.      * 如果给定的值为空，或者转换失败，返回默认值<code>null</code><br>
  470.      * 转换失败不会报错
  471.      *
  472.      * @param value 被转换的值
  473.      * @return 结果
  474.      */
  475.     public static Double toDouble(Object value) {
  477.         return toDouble(value, null);
  478.     }
  480.     /**
  481.      * 转换为Float<br>
  482.      * 如果给定的值为空，或者转换失败，返回默认值<br>
  483.      * 转换失败不会报错
  484.      *
  485.      * @param value        被转换的值
  486.      * @param defaultValue 转换错误时的默认值
  487.      * @return 结果
  488.      */
  489.     public static Float toFloat(Object value, Float defaultValue) {
  491.         if (value == null) {
  493.             return defaultValue;
  494.         }
  495.         if (value instanceof Float) {
  497.             return (Float) value;
  498.         }
  499.         if (value instanceof Number) {
  501.             return ((Number) value).floatValue();
  502.         }
  503.         final String valueStr = toStr(value, null);
  504.         if (StringUtils.isEmpty(valueStr)) {
  506.             return defaultValue;
  507.         }
  508.         try {
  510.             return Float.parseFloat(valueStr.trim());
  511.         } catch (Exception e) {
  513.             return defaultValue;
  514.         }
  515.     }
  517.     /**
  518.      * 转换为Float<br>
  519.      * 如果给定的值为空，或者转换失败，返回默认值<code>null</code><br>
  520.      * 转换失败不会报错
  521.      *
  522.      * @param value 被转换的值
  523.      * @return 结果
  524.      */
  525.     public static Float toFloat(Object value) {
  527.         return toFloat(value, null);
  528.     }
  530.     /**
  531.      * 转换为boolean<br>
  532.      * String支持的值为：true、false、yes、ok、no，1,0 如果给定的值为空，或者转换失败，返回默认值<br>
  533.      * 转换失败不会报错
  534.      *
  535.      * @param value        被转换的值
  536.      * @param defaultValue 转换错误时的默认值
  537.      * @return 结果
  538.      */
  539.     public static Boolean toBool(Object value, Boolean defaultValue) {
  541.         if (value == null) {
  543.             return defaultValue;
  544.         }
  545.         if (value instanceof Boolean) {
  547.             return (Boolean) value;
  548.         }
  549.         String valueStr = toStr(value, null);
  550.         if (StringUtils.isEmpty(valueStr)) {
  552.             return defaultValue;
  553.         }
  554.         valueStr = valueStr.trim().toLowerCase();
  555.         switch (valueStr) {
  557.             case "true":
  558.                 return true;
  559.             case "false":
  560.                 return false;
  561.             case "yes":
  562.                 return true;
  563.             case "ok":
  564.                 return true;
  565.             case "no":
  566.                 return false;
  567.             case "1":
  568.                 return true;
  569.             case "0":
  570.                 return false;
  571.             default:
  572.                 return defaultValue;
  573.         }
  574.     }
  576.     /**
  577.      * 转换为boolean<br>
  578.      * 如果给定的值为空，或者转换失败，返回默认值<code>null</code><br>
  579.      * 转换失败不会报错
  580.      *
  581.      * @param value 被转换的值
  582.      * @return 结果
  583.      */
  584.     public static Boolean toBool(Object value) {
  586.         return toBool(value, null);
  587.     }
  589.     /**
  590.      * 转换为Enum对象<br>
  591.      * 如果给定的值为空，或者转换失败，返回默认值<br>
  592.      *
  593.      * @param clazz        Enum的Class
  594.      * @param value        值
  595.      * @param defaultValue 默认值
  596.      * @return Enum
  597.      */
  598.     public static <E extends Enum<E>> E toEnum(Class<E> clazz, Object value, E defaultValue) {
  600.         if (value == null) {
  602.             return defaultValue;
  603.         }
  604.         if (clazz.isAssignableFrom(value.getClass())) {
  606.             @SuppressWarnings("unchecked")
  607.             E myE = (E) value;
  608.             return myE;
  609.         }
  610.         final String valueStr = toStr(value, null);
  611.         if (StringUtils.isEmpty(valueStr)) {
  613.             return defaultValue;
  614.         }
  615.         try {
  617.             return Enum.valueOf(clazz, valueStr);
  618.         } catch (Exception e) {
  620.             return defaultValue;
  621.         }
  622.     }
  624.     /**
  625.      * 转换为Enum对象<br>
  626.      * 如果给定的值为空，或者转换失败，返回默认值<code>null</code><br>
  627.      *
  628.      * @param clazz Enum的Class
  629.      * @param value 值
  630.      * @return Enum
  631.      */
  632.     public static <E extends Enum<E>> E toEnum(Class<E> clazz, Object value) {
  634.         return toEnum(clazz, value, null);
  635.     }
  637.     /**
  638.      * 转换为BigInteger<br>
  639.      * 如果给定的值为空，或者转换失败，返回默认值<br>
  640.      * 转换失败不会报错
  641.      *
  642.      * @param value        被转换的值
  643.      * @param defaultValue 转换错误时的默认值
  644.      * @return 结果
  645.      */
  646.     public static BigInteger toBigInteger(Object value, BigInteger defaultValue) {
  648.         if (value == null) {
  650.             return defaultValue;
  651.         }
  652.         if (value instanceof BigInteger) {
  654.             return (BigInteger) value;
  655.         }
  656.         if (value instanceof Long) {
  658.             return BigInteger.valueOf((Long) value);
  659.         }
  660.         final String valueStr = toStr(value, null);
  661.         if (StringUtils.isEmpty(valueStr)) {
  663.             return defaultValue;
  664.         }
  665.         try {
  667.             return new BigInteger(valueStr);
  668.         } catch (Exception e) {
  670.             return defaultValue;
  671.         }
  672.     }
  674.     /**
  675.      * 转换为BigInteger<br>
  676.      * 如果给定的值为空，或者转换失败，返回默认值<code>null</code><br>
  677.      * 转换失败不会报错
  678.      *
  679.      * @param value 被转换的值
  680.      * @return 结果
  681.      */
  682.     public static BigInteger toBigInteger(Object value) {
  684.         return toBigInteger(value, null);
  685.     }
  687.     /**
  688.      * 转换为BigDecimal<br>
  689.      * 如果给定的值为空，或者转换失败，返回默认值<br>
  690.      * 转换失败不会报错
  691.      *
  692.      * @param value        被转换的值
  693.      * @param defaultValue 转换错误时的默认值
  694.      * @return 结果
  695.      */
  696.     public static BigDecimal toBigDecimal(Object value, BigDecimal defaultValue) {
  698.         if (value == null) {
  700.             return defaultValue;
  701.         }
  702.         if (value instanceof BigDecimal) {
  704.             return (BigDecimal) value;
  705.         }
  706.         if (value instanceof Long) {
  708.             return new BigDecimal((Long) value);
  709.         }
  710.         if (value instanceof Double) {
  712.             return BigDecimal.valueOf((Double) value);
  713.         }
  714.         if (value instanceof Integer) {
  716.             return new BigDecimal((Integer) value);
  717.         }
  718.         final String valueStr = toStr(value, null);
  719.         if (StringUtils.isEmpty(valueStr)) {
  721.             return defaultValue;
  722.         }
  723.         try {
  725.             return new BigDecimal(valueStr);
  726.         } catch (Exception e) {
  728.             return defaultValue;
  729.         }
  730.     }
  732.     /**
  733.      * 转换为BigDecimal<br>
  734.      * 如果给定的值为空，或者转换失败，返回默认值<br>
  735.      * 转换失败不会报错
  736.      *
  737.      * @param value 被转换的值
  738.      * @return 结果
  739.      */
  740.     public static BigDecimal toBigDecimal(Object value) {
  742.         return toBigDecimal(value, null);
  743.     }
  745.     /**
  746.      * 将对象转为字符串<br>
  747.      * 1、Byte数组和ByteBuffer会被转换为对应字符串的数组 2、对象数组会调用Arrays.toString方法
  748.      *
  749.      * @param obj 对象
  750.      * @return 字符串
  751.      */
  752.     public static String utf8Str(Object obj) {
  754.         return str(obj, CharsetUtils.CHARSET_UTF_8);
  755.     }
  757.     /**
  758.      * 将对象转为字符串<br>
  759.      * 1、Byte数组和ByteBuffer会被转换为对应字符串的数组 2、对象数组会调用Arrays.toString方法
  760.      *
  761.      * @param obj         对象
  762.      * @param charsetName 字符集
  763.      * @return 字符串
  764.      */
  765.     public static String str(Object obj, String charsetName) {
  767.         return str(obj, Charset.forName(charsetName));
  768.     }
  770.     /**
  771.      * 将对象转为字符串<br>
  772.      * 1、Byte数组和ByteBuffer会被转换为对应字符串的数组 2、对象数组会调用Arrays.toString方法
  773.      *
  774.      * @param obj     对象
  775.      * @param charset 字符集
  776.      * @return 字符串
  777.      */
  778.     public static String str(Object obj, Charset charset) {
  780.         if (null == obj) {
  782.             return null;
  783.         }
  785.         if (obj instanceof String) {
  787.             return (String) obj;
  788.         } else if (obj instanceof byte[] || obj instanceof Byte[]) {
  790.             return str((Byte[]) obj, charset);
  791.         } else if (obj instanceof ByteBuffer) {
  793.             return str((ByteBuffer) obj, charset);
  794.         }
  795.         return obj.toString();
  796.     }
  798.     /**
  799.      * 将byte数组转为字符串
  800.      *
  801.      * @param bytes   byte数组
  802.      * @param charset 字符集
  803.      * @return 字符串
  804.      */
  805.     public static String str(byte[] bytes, String charset) {
  807.         return str(bytes, StringUtils.isEmpty(charset) ? Charset.defaultCharset() : Charset.forName(charset));
  808.     }
  810.     /**
  811.      * 解码字节码
  812.      *
  813.      * @param data    字符串
  814.      * @param charset 字符集，如果此字段为空，则解码的结果取决于平台
  815.      * @return 解码后的字符串
  816.      */
  817.     public static String str(byte[] data, Charset charset) {
  819.         if (data == null) {
  821.             return null;
  822.         }
  824.         if (null == charset) {
  826.             return new String(data);
  827.         }
  828.         return new String(data, charset);
  829.     }
  831.     /**
  832.      * 将编码的byteBuffer数据转换为字符串
  833.      *
  834.      * @param data    数据
  835.      * @param charset 字符集，如果为空使用当前系统字符集
  836.      * @return 字符串
  837.      */
  838.     public static String str(ByteBuffer data, String charset) {
  840.         if (data == null) {
  842.             return null;
  843.         }
  845.         return str(data, Charset.forName(charset));
  846.     }
  848.     /**
  849.      * 将编码的byteBuffer数据转换为字符串
  850.      *
  851.      * @param data    数据
  852.      * @param charset 字符集，如果为空使用当前系统字符集
  853.      * @return 字符串
  854.      */
  855.     public static String str(ByteBuffer data, Charset charset) {
  857.         if (null == charset) {
  859.             charset = Charset.defaultCharset();
  860.         }
  861.         return charset.decode(data).toString();
  862.     }
  864.     // ----------------------------------------------------------------------- 全角半角转换
  866.     /**
  867.      * 半角转全角
  868.      *
  869.      * @param input String.
  870.      * @return 全角字符串.
  871.      */
  872.     public static String toSBC(String input) {
  874.         return toSBC(input, null);
  875.     }
  877.     /**
  878.      * 半角转全角
  879.      *
  880.      * @param input         String
  881.      * @param notConvertSet 不替换的字符集合
  882.      * @return 全角字符串.
  883.      */
  884.     public static String toSBC(String input, Set<Character> notConvertSet) {
  886.         char c[] = input.toCharArray();
  887.         for (int i = 0; i < c.length; i++) {
  889.             if (null != notConvertSet && notConvertSet.contains(c[i])) {
  891.                 // 跳过不替换的字符
  892.                 continue;
  893.             }
  895.             if (c[i] == ' ') {
  897.                 c[i] = '\u3000';
  898.             } else if (c[i] < '\177') {
  900.                 c[i] = (char) (c[i] + 65248);
  902.             }
  903.         }
  904.         return new String(c);
  905.     }
  907.     /**
  908.      * 全角转半角
  909.      *
  910.      * @param input String.
  911.      * @return 半角字符串
  912.      */
  913.     public static String toDBC(String input) {
  915.         return toDBC(input, null);
  916.     }
  918.     /**
  919.      * 替换全角为半角
  920.      *
  921.      * @param text          文本
  922.      * @param notConvertSet 不替换的字符集合
  923.      * @return 替换后的字符
  924.      */
  925.     public static String toDBC(String text, Set<Character> notConvertSet) {
  927.         char c[] = text.toCharArray();
  928.         for (int i = 0; i < c.length; i++) {
  930.             if (null != notConvertSet && notConvertSet.contains(c[i])) {
  932.                 // 跳过不替换的字符
  933.                 continue;
  934.             }
  936.             if (c[i] == '\u3000') {
  938.                 c[i] = ' ';
  939.             } else if (c[i] > '\uFF00' && c[i] < '\uFF5F') {
  941.                 c[i] = (char) (c[i] - 65248);
  942.             }
  943.         }
  945.         return new String(c);
  946.     }
  948.     /**
  949.      * 数字金额大写转换 先写个完整的然后将如零拾替换成零
  950.      *
  951.      * @param n 数字
  952.      * @return 中文大写数字
  953.      */
  954.     public static String digitUppercase(double n) {
  956.         String[] fraction = {
  957.     "角", "分"};
  958.         String[] digit = {
  959.     "零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖"};
  960.         String[][] unit = {
  961.     {
  962.     "元", "万", "亿"}, {
  963.     "", "拾", "佰", "仟"}};
  965.         String head = n < 0 ? "负" : "";
  966.         n = Math.abs(n);
  968.         StringBuilder s = new StringBuilder();
  969.         for (int i = 0; i < fraction.length; i++) {
  971.             s.append((digit[(int) (Math.floor(n * 10 * Math.pow(10, i)) % 10)] + fraction[i]).replaceAll("(零.)+", ""));
  972.         }
  973.         if (s.length() < 1) {
  975.             s = new StringBuilder("整");
  976.         }
  977.         int integerPart = (int) Math.floor(n);
  979.         for (int i = 0; i < unit[0].length && integerPart > 0; i++) {
  981.             String p = "";
  982.             for (int j = 0; j < unit[1].length && n > 0; j++) {
  984.                 p = digit[integerPart % 10] + unit[1][j] + p;
  985.                 integerPart = integerPart / 10;
  986.             }
  987.             s.insert(0, p.replaceAll("(零.)*零$", "").replaceAll("^$", "零") + unit[0][i]);
  988.         }
  989.         return head + s.toString().replaceAll("(零.)*零元", "元").replaceFirst("(零.)+", "").replaceAll("(零.)+", "零").replaceAll("^整$", "零元整");
  990.     }
  991. }

文件上传工具类

  1. package com.example.file.util;
  3. import java.io.File;
  4. import java.io.IOException;
  5. import java.util.Arrays;
  6. import java.util.Date;
  7. import java.util.Objects;
  8. import org.apache.commons.io.FilenameUtils;
  9. import org.apache.commons.lang3.time.DateFormatUtils;
  10. import org.apache.tomcat.util.http.fileupload.FileUploadException;
  11. import org.springframework.web.multipart.MultipartFile;
  12. import javax.annotation.processing.FilerException;
  14. /**
  15.  * 文件上传工具类
  16.  *
  17.  * @author ruoyi
  18.  */
  19. public class FileUploadUtils {
  21.     /**
  22.      * 默认大小 50M
  23.      */
  24.     public static final long DEFAULT_MAX_SIZE = 50 * 1024 * 1024;
  26.     /**
  27.      * 默认的文件名最大长度 100
  28.      */
  29.     public static final int DEFAULT_FILE_NAME_LENGTH = 100;
  31.     private static int counter = 0;
  33.     public static final String RESOURCE_PREFIX  = "/profile";
  35.     /**
  36.      * 根据文件路径上传
  37.      *
  38.      * @param baseDir 相对应用的基目录
  39.      * @param file    上传的文件
  40.      * @return 文件名称
  41.      * @throws IOException
  42.      */
  43.     public static String upload(String baseDir, MultipartFile file) throws IOException {
  45.         try {
  47.             return upload(baseDir, file, MimeTypeUtils.DEFAULT_ALLOWED_EXTENSION);
  48.         } catch (Exception e) {
  50.             throw new IOException(e.getMessage(), e);
  51.         }
  52.     }
  54.     /**
  55.      * 文件上传
  56.      *
  57.      * @param baseDir   相对应用的基目录
  58.      * @param file      上传的文件
  59.      * @param allowedExtension 上传文件类型
  60.      * @return 返回上传成功的文件名
  61.      * @throws IOException                          比如读写文件出错时
  62.      */
  63.     public static String upload(String baseDir, MultipartFile file, String[] allowedExtension) throws IOException, FileUploadException {
  65.         int fileNameLength = Objects.requireNonNull(file.getOriginalFilename()).length();
  66.         if (fileNameLength > FileUploadUtils.DEFAULT_FILE_NAME_LENGTH) {
  68.             throw new FilerException("默认的文件名最大长度 :" + DEFAULT_FILE_NAME_LENGTH);
  69.         }
  70.         assertAllowed(file, allowedExtension);
  71.         String fileName = extractFilename(file);
  72.         File desc = new File(baseDir + File.separator + fileName);
  74.         if (!desc.getParentFile().exists()){
  76.             desc.getParentFile().mkdirs();
  77.         }
  79.         file.transferTo(desc);
  80.         return getPathFileName(baseDir, fileName);
  81.     }
  83.     /**
  84.      * 编码文件名
  85.      */
  86.     public static String extractFilename(MultipartFile file) {
  88.         String fileName = file.getOriginalFilename();
  89.         String extension = getExtension(file);
  90.         fileName = datePath() + "/" + encodingFilename(fileName) + "." + extension;
  91.         return fileName;
  92.     }
  94.     public static String datePath() {
  96.         Date now = new Date();
  97.         return DateFormatUtils.format(now, "yyyy/MM/dd");
  98.     }
  100.     private static String getPathFileName(String uploadDir, String fileName){
  102.         int dirLastIndex = uploadDir.lastIndexOf("/") + 1;
  103.         String currentDir = StringUtils.substring(uploadDir, dirLastIndex);
  104.         return RESOURCE_PREFIX + "/" + currentDir + "/" + fileName;
  105.     }
  107.     /**
  108.      * 编码文件名
  109.      */
  110.     private static String encodingFilename(String fileName) {
  112.         return Md5Utils.hash(fileName.replace("_", " ") + System.nanoTime() + counter++);
  113.     }
  115.     /**
  116.      * 文件大小校验
  117.      *
  118.      * @param file 上传的文件
  119.      */
  120.     public static void assertAllowed(MultipartFile file, String[] allowedExtension) throws FilerException, FileUploadException {
  122.         long size = file.getSize();
  123.         if (size > DEFAULT_MAX_SIZE) {
  125.             throw new FilerException("默认的文件名最大长度 :" +  DEFAULT_MAX_SIZE / 1024 / 1024);
  126.         }
  127.         String fileName = file.getOriginalFilename();
  128.         String extension = getExtension(file);
  129.         if (allowedExtension != null && !isAllowedExtension(extension, allowedExtension)) {
  131.             if (allowedExtension == MimeTypeUtils.IMAGE_EXTENSION) {
  133.                 throw new FileUploadException("filename : [" + fileName + "], extension : [" + extension + "], allowed extension : [" + Arrays.toString(allowedExtension) + "]");
  134.             } else if (allowedExtension == MimeTypeUtils.FLASH_EXTENSION) {
  136.                 throw new FileUploadException("filename : [" + fileName + "], extension : [" + extension + "], allowed extension : [" + Arrays.toString(allowedExtension) + "]");
  137.             } else if (allowedExtension == MimeTypeUtils.MEDIA_EXTENSION) {
  139.                 throw new FileUploadException("filename : [" + fileName + "], extension : [" + extension + "], allowed extension : [" + Arrays.toString(allowedExtension) + "]");
  140.             } else {
  142.                 throw new FileUploadException("filename : [" + fileName + "], extension : [" + extension + "], allowed extension : [" + Arrays.toString(allowedExtension) + "]");
  143.             }
  144.         }
  145.     }
  147.     /**
  148.      * 判断MIME类型是否是允许的MIME类型
  149.      *
  150.      * @param extension
  151.      * @param allowedExtension
  152.      * @return
  153.      */
  154.     public static boolean isAllowedExtension(String extension, String[] allowedExtension) {
  156.         for (String str : allowedExtension) {
  158.             if (str.equalsIgnoreCase(extension)) {
  160.                 return true;
  161.             }
  162.         }
  163.         return false;
  164.     }
  166.     /**
  167.      * 获取文件名的后缀
  168.      *
  169.      * @param file 表单文件
  170.      * @return 后缀名
  171.      */
  172.     public static String getExtension(MultipartFile file) {
  174.         String extension = FilenameUtils.getExtension(file.getOriginalFilename());
  175.         if (StringUtils.isEmpty(extension)) {
  177.             extension = MimeTypeUtils.getExtension(Objects.requireNonNull(file.getContentType()));
  178.         }
  179.         return extension;
  180.     }
  181. }

文件处理工具类

  1. package com.example.file.util;
  4. import javax.servlet.http.HttpServletRequest;
  5. import java.io.*;
  6. import java.net.URLEncoder;
  8. /**
  9.  * 文件处理工具类
  10.  */
  11. public class FileUtils {
  13.     public static String FILENAME_PATTERN = "[a-zA-Z0-9_\\-\\|\\.\\/\\u4e00-\\u9fa5]+";
  15.     /**
  16.      * 输出指定文件的byte数组
  17.      *
  18.      * @param filePath 文件路径
  19.      * @param os       输出流
  20.      */
  21.     public static void writeBytes(String filePath, OutputStream os) throws IOException {
  23.         FileInputStream fis = null;
  24.         try {
  26.             File file = new File(filePath);
  27.             if (!file.exists()) {
  29.                 throw new FileNotFoundException(filePath);
  30.             }
  31.             fis = new FileInputStream(file);
  32.             byte[] b = new byte[1024];
  33.             int length;
  34.             while ((length = fis.read(b)) > 0) {
  36.                 os.write(b, 0, length);
  37.             }
  38.         } finally {
  40.             if (os != null) {
  42.                 try {
  44.                     os.close();
  45.                 } catch (IOException e1) {
  47.                     e1.printStackTrace();
  48.                 }
  49.             }
  50.             if (fis != null) {
  52.                 try {
  54.                     fis.close();
  55.                 } catch (IOException e1) {
  57.                     e1.printStackTrace();
  58.                 }
  59.             }
  60.         }
  61.     }
  63.     /**
  64.      * 删除文件
  65.      *
  66.      * @param filePath 文件
  67.      */
  68.     public static void deleteFile(String filePath) {
  70.         File file = new File(filePath);
  71.         // 路径为文件且不为空则进行删除
  72.         if (file.isFile() && file.exists()) {
  74.             file.delete();
  75.         }
  76.     }
  78.     /**
  79.      * 文件名称验证
  80.      *
  81.      * @param filename 文件名称
  82.      * @return true 正常 false 非法
  83.      */
  84.     public static boolean isValidFilename(String filename) {
  86.         return filename.matches(FILENAME_PATTERN);
  87.     }
  89.     /**
  90.      * 下载文件名重新编码
  91.      *
  92.      * @param request  请求对象
  93.      * @param fileName 文件名
  94.      * @return 编码后的文件名
  95.      */
  96.     public static String setFileDownloadHeader(HttpServletRequest request, String fileName)
  97.             throws UnsupportedEncodingException {
  99.         final String agent = request.getHeader("USER-AGENT");
  100.         String filename = fileName;
  101.         if (agent.contains("MSIE")) {
  103.             // IE浏览器
  104.             filename = URLEncoder.encode(filename, "utf-8");
  105.             filename = filename.replace("+", " ");
  106.         } else if (agent.contains("Firefox")) {
  108.             // 火狐浏览器
  109.             filename = new String(fileName.getBytes(), "ISO8859-1");
  110.         } else if (agent.contains("Chrome")) {
  112.             // google浏览器
  113.             filename = URLEncoder.encode(filename, "utf-8");
  114.         } else {
  116.             // 其它浏览器
  117.             filename = URLEncoder.encode(filename, "utf-8");
  118.         }
  119.         return filename;
  120.     }
  122.     /**
  123.      * 获取系统临时目录
  124.      *
  125.      */
  126.     public static String getTemp() {
  128.         return System.getProperty("java.io.tmpdir");
  129.     }
  131.     /**
  132.      * 创建临时文件
  133.      *
  134.      * @param filePath
  135.      * @param data
  136.      */
  137.     public static File createTempFile(String filePath, byte[] data) throws IOException {
  139.         String temp = getTemp() + filePath;
  140.         File file = new File(temp);
  141.         if (!file.getParentFile().exists()) {
  143.             file.getParentFile().mkdirs();
  144.         }
  145.         if (!file.exists()) {
  147.             file.createNewFile();
  148.         }
  149.         FileOutputStream fos = new FileOutputStream(file);
  150.         fos.write(data, 0, data.length);
  151.         fos.flush();
  152.         fos.close();
  153.         return file;
  154.     }
  155. }

Md5加密方法

  1. package com.example.file.util;
  3. import java.nio.charset.StandardCharsets;
  4. import java.security.MessageDigest;
  5. import java.util.Objects;
  7. import org.slf4j.Logger;
  8. import org.slf4j.LoggerFactory;
  10. /**
  11.  * Md5加密方法
  12.  */
  13. public class Md5Utils {
  15.     private static final Logger log = LoggerFactory.getLogger(Md5Utils.class);
  17.     private static byte[] md5(String s) {
  19.         MessageDigest algorithm;
  20.         try {
  22.             algorithm = MessageDigest.getInstance("MD5");
  23.             algorithm.reset();
  24.             algorithm.update(s.getBytes(StandardCharsets.UTF_8));
  25.             return algorithm.digest();
  26.         } catch (Exception e) {
  28.             log.error("MD5 Error...", e);
  29.         }
  30.         return null;
  31.     }
  33.     private static String toHex(byte[] hash) {
  35.         if (hash == null) {
  37.             return null;
  38.         }
  39.         StringBuilder buf = new StringBuilder(hash.length * 2);
  40.         int i;
  42.         for (i = 0; i < hash.length; i++) {
  44.             if ((hash[i] & 0xff) < 0x10) {
  46.                 buf.append("0");
  47.             }
  48.             buf.append(Long.toString(hash[i] & 0xff, 16));
  49.         }
  50.         return buf.toString();
  51.     }
  53.     public static String hash(String s) {
  55.         try {
  57.             return new String(Objects.requireNonNull(toHex(md5(s))).getBytes(StandardCharsets.UTF_8), StandardCharsets.UTF_8);
  58.         } catch (Exception e) {
  60.             log.error("not supported charset...{}", e);
  61.             return s;
  62.         }
  63.     }
  64. }

媒体类型工具类

  1. package com.example.file.util;
  3. /**
  4.  * 媒体类型工具类
  5.  */
  6. public class MimeTypeUtils {
  8.     public static final String IMAGE_PNG = "image/png";
  10.     public static final String IMAGE_JPG = "image/jpg";
  12.     public static final String IMAGE_JPEG = "image/jpeg";
  14.     public static final String IMAGE_BMP = "image/bmp";
  16.     public static final String IMAGE_GIF = "image/gif";
  18.     public static final String[] IMAGE_EXTENSION = {
  19.     "bmp", "gif", "jpg", "jpeg", "png"};
  21.     public static final String[] FLASH_EXTENSION = {
  22.     "swf", "flv"};
  24.     public static final String[] MEDIA_EXTENSION = {
  25.     "swf", "flv", "mp3", "wav", "wma", "wmv", "mid", "avi", "mpg",
  26.             "asf", "rm", "rmvb"};
  28.     public static final String[] DEFAULT_ALLOWED_EXTENSION = {
  30.             // 图片
  31.             "bmp", "gif", "jpg", "jpeg", "png",
  32.             // word excel powerpoint
  33.             "doc", "docx", "xls", "xlsx", "ppt", "pptx", "html", "htm", "txt",
  34.             // 压缩文件
  35.             "rar", "zip", "gz", "bz2",
  36.             // pdf
  37.             "pdf"};
  39.     public static String getExtension(String prefix) {
  41.         switch (prefix) {
  43.             case IMAGE_PNG:
  44.                 return "png";
  45.             case IMAGE_JPG:
  46.                 return "jpg";
  47.             case IMAGE_JPEG:
  48.                 return "jpeg";
  49.             case IMAGE_BMP:
  50.                 return "bmp";
  51.             case IMAGE_GIF:
  52.                 return "gif";
  53.             default:
  54.                 return "";
  55.         }
  56.     }
  57. }

字符串工具类

  1. package com.example.file.util;
  3. import java.util.Collection;
  4. import java.util.Map;
  6. /**
  7.  * 字符串工具类
  8.  */
  9. public class StringUtils extends org.apache.commons.lang3.StringUtils {
  11.     /**
  12.      * 空字符串
  13.      */
  14.     private static final String NULLSTR = "";
  16.     /**
  17.      * 下划线
  18.      */
  19.     private static final char SEPARATOR = '_';
  21.     private static final String EMPTY_JSON = "{}";
  22.     private static final char C_BACKSLASH = '\\';
  23.     private static final char C_DELIM_START = '{';
  25.     /**
  26.      * 获取参数不为空值
  27.      *
  28.      * @param value defaultValue 要判断的value
  29.      * @return value 返回值
  30.      */
  31.     public static <T> T nvl(T value, T defaultValue) {
  33.         return value != null ? value : defaultValue;
  34.     }
  36.     /**
  37.      * * 判断一个Collection是否为空， 包含List，Set，Queue
  38.      *
  39.      * @param coll 要判断的Collection
  40.      * @return true：为空 false：非空
  41.      */
  42.     public static boolean isEmpty(Collection<?> coll) {
  44.         return isNull(coll) || coll.isEmpty();
  45.     }
  47.     /**
  48.      * * 判断一个Collection是否非空，包含List，Set，Queue
  49.      *
  50.      * @param coll 要判断的Collection
  51.      * @return true：非空 false：空
  52.      */
  53.     public static boolean isNotEmpty(Collection<?> coll) {
  55.         return !isEmpty(coll);
  56.     }
  58.     /**
  59.      * * 判断一个对象数组是否为空
  60.      *
  61.      * @param objects 要判断的对象数组
  62.      *                * @return true：为空 false：非空
  63.      */
  64.     public static boolean isEmpty(Object[] objects) {
  66.         return isNull(objects) || (objects.length == 0);
  67.     }
  69.     /**
  70.      * * 判断一个对象数组是否非空
  71.      *
  72.      * @param objects 要判断的对象数组
  73.      * @return true：非空 false：空
  74.      */
  75.     public static boolean isNotEmpty(Object[] objects) {
  77.         return !isEmpty(objects);
  78.     }
  80.     /**
  81.      * * 判断一个Map是否为空
  82.      *
  83.      * @param map 要判断的Map
  84.      * @return true：为空 false：非空
  85.      */
  86.     public static boolean isEmpty(Map<?, ?> map) {
  88.         return isNull(map) || map.isEmpty();
  89.     }
  91.     /**
  92.      * * 判断一个Map是否为空
  93.      *
  94.      * @param map 要判断的Map
  95.      * @return true：非空 false：空
  96.      */
  97.     public static boolean isNotEmpty(Map<?, ?> map) {
  99.         return !isEmpty(map);
  100.     }
  102.     /**
  103.      * * 判断一个字符串是否为空串
  104.      *
  105.      * @param str String
  106.      * @return true：为空 false：非空
  107.      */
  108.     public static boolean isEmpty(String str) {
  110.         return isNull(str) || NULLSTR.equals(str.trim());
  111.     }
  113.     /**
  114.      * * 判断一个字符串是否为非空串
  115.      *
  116.      * @param str String
  117.      * @return true：非空串 false：空串
  118.      */
  119.     public static boolean isNotEmpty(String str) {
  121.         return !isEmpty(str);
  122.     }
  124.     /**
  125.      * * 判断一个对象是否为空
  126.      *
  127.      * @param object Object
  128.      * @return true：为空 false：非空
  129.      */
  130.     public static boolean isNull(Object object) {
  132.         return object == null;
  133.     }
  135.     /**
  136.      * * 判断一个对象是否非空
  137.      *
  138.      * @param object Object
  139.      * @return true：非空 false：空
  140.      */
  141.     public static boolean isNotNull(Object object) {
  143.         return !isNull(object);
  144.     }
  146.     /**
  147.      * * 判断一个对象是否是数组类型（Java基本型别的数组）
  148.      *
  149.      * @param object 对象
  150.      * @return true：是数组 false：不是数组
  151.      */
  152.     public static boolean isArray(Object object) {
  154.         return isNotNull(object) && object.getClass().isArray();
  155.     }
  157.     /**
  158.      * 去空格
  159.      */
  160.     public static String trim(String str) {
  162.         return (str == null ? "" : str.trim());
  163.     }
  165.     /**
  166.      * 截取字符串
  167.      *
  168.      * @param str   字符串
  169.      * @param start 开始
  170.      * @return 结果
  171.      */
  172.     public static String substring(final String str, int start) {
  174.         if (str == null) {
  176.             return NULLSTR;
  177.         }
  179.         if (start < 0) {
  181.             start = str.length() + start;
  182.         }
  184.         if (start < 0) {
  186.             start = 0;
  187.         }
  188.         if (start > str.length()) {
  190.             return NULLSTR;
  191.         }
  193.         return str.substring(start);
  194.     }
  196.     /**
  197.      * 截取字符串
  198.      *
  199.      * @param str   字符串
  200.      * @param start 开始
  201.      * @param end   结束
  202.      * @return 结果
  203.      */
  204.     public static String substring(final String str, int start, int end) {
  206.         if (str == null) {
  208.             return NULLSTR;
  209.         }
  211.         if (end < 0) {
  213.             end = str.length() + end;
  214.         }
  215.         if (start < 0) {
  217.             start = str.length() + start;
  218.         }
  220.         if (end > str.length()) {
  222.             end = str.length();
  223.         }
  225.         if (start > end) {
  227.             return NULLSTR;
  228.         }
  230.         if (start < 0) {
  232.             start = 0;
  233.         }
  234.         if (end < 0) {
  236.             end = 0;
  237.         }
  239.         return str.substring(start, end);
  240.     }
  242.     /**
  243.      * 格式化字符串<br>
  244.      * 此方法只是简单将占位符 {} 按照顺序替换为参数<br>
  245.      * 如果想输出 {} 使用 \\转义 { 即可，如果想输出 {} 之前的 \ 使用双转义符 \\\\ 即可<br>
  246.      * 例：<br>
  247.      * 通常使用：format("this is {} for {}", "a", "b") -> this is a for b<br>
  248.      * 转义{}： format("this is \\{} for {}", "a", "b") -> this is \{} for a<br>
  249.      * 转义\： format("this is \\\\{} for {}", "a", "b") -> this is \a for b<br>
  250.      *
  251.      * @param strPattern 字符串模板
  252.      * @param argArray 参数列表
  253.      * @return 结果
  254.      */
  255.     public static String strFormat(String strPattern, Object... argArray) {
  257.         if (StringUtils.isEmpty(strPattern) || StringUtils.isEmpty(argArray)) {
  259.             return strPattern;
  260.         }
  261.         final int strPatternLength = strPattern.length();
  263.         // 初始化定义好的长度以获得更好的性能
  264.         StringBuilder sbuf = new StringBuilder(strPatternLength + 50);
  266.         int handledPosition = 0;
  267.         int delimIndex;// 占位符所在位置
  268.         for (int argIndex = 0; argIndex < argArray.length; argIndex++) {
  270.             delimIndex = strPattern.indexOf(EMPTY_JSON, handledPosition);
  271.             if (delimIndex == -1) {
  273.                 if (handledPosition == 0) {
  275.                     return strPattern;
  276.                 } else {
  278.                     // 字符串模板剩余部分不再包含占位符，加入剩余部分后返回结果
  279.                     sbuf.append(strPattern, handledPosition, strPatternLength);
  280.                     return sbuf.toString();
  281.                 }
  282.             } else {
  284.                 if (delimIndex > 0 && strPattern.charAt(delimIndex - 1) == C_BACKSLASH) {
  286.                     if (delimIndex > 1 && strPattern.charAt(delimIndex - 2) == C_BACKSLASH) {
  288.                         // 转义符之前还有一个转义符，占位符依旧有效
  289.                         sbuf.append(strPattern, handledPosition, delimIndex - 1);
  290.                         sbuf.append(ConvertUtils.utf8Str(argArray[argIndex]));
  291.                         handledPosition = delimIndex + 2;
  292.                     } else {
  294.                         // 占位符被转义
  295.                         argIndex--;
  296.                         sbuf.append(strPattern, handledPosition, delimIndex - 1);
  297.                         sbuf.append(C_DELIM_START);
  298.                         handledPosition = delimIndex + 1;
  299.                     }
  300.                 } else {
  302.                     // 正常占位符
  303.                     sbuf.append(strPattern, handledPosition, delimIndex);
  304.                     sbuf.append(ConvertUtils.utf8Str(argArray[argIndex]));
  305.                     handledPosition = delimIndex + 2;
  306.                 }
  307.             }
  308.         }
  309.         // 加入最后一个占位符后所有的字符
  310.         sbuf.append(strPattern, handledPosition, strPattern.length());
  312.         return sbuf.toString();
  313.     }
  316.     /**
  317.      * 下划线转驼峰命名
  318.      */
  319.     public static String toUnderScoreCase(String str) {
  321.         if (str == null) {
  323.             return null;
  324.         }
  325.         StringBuilder sb = new StringBuilder();
  326.         // 前置字符是否大写
  327.         boolean preCharIsUpperCase = true;
  328.         // 当前字符是否大写
  329.         boolean curreCharIsUpperCase = true;
  330.         // 下一字符是否大写
  331.         boolean nexteCharIsUpperCase = true;
  332.         for (int i = 0; i < str.length(); i++) {
  334.             char c = str.charAt(i);
  335.             if (i > 0) {
  337.                 preCharIsUpperCase = Character.isUpperCase(str.charAt(i - 1));
  338.             } else {
  340.                 preCharIsUpperCase = false;
  341.             }
  343.             curreCharIsUpperCase = Character.isUpperCase(c);
  345.             if (i < (str.length() - 1)) {
  347.                 nexteCharIsUpperCase = Character.isUpperCase(str.charAt(i + 1));
  348.             }
  350.             if (preCharIsUpperCase && curreCharIsUpperCase && !nexteCharIsUpperCase) {
  352.                 sb.append(SEPARATOR);
  353.             } else if ((i != 0 && !preCharIsUpperCase) && curreCharIsUpperCase) {
  355.                 sb.append(SEPARATOR);
  356.             }
  357.             sb.append(Character.toLowerCase(c));
  358.         }
  360.         return sb.toString();
  361.     }
  363.     /**
  364.      * 是否包含字符串
  365.      *
  366.      * @param str  验证字符串
  367.      * @param strs 字符串组
  368.      * @return 包含返回true
  369.      */
  370.     public static boolean inStringIgnoreCase(String str, String... strs) {
  372.         if (str != null && strs != null) {
  374.             for (String s : strs) {
  376.                 if (str.equalsIgnoreCase(trim(s))) {
  378.                     return true;
  379.                 }
  380.             }
  381.         }
  382.         return false;
  383.     }
  385.     /**
  386.      * 将下划线大写方式命名的字符串转换为驼峰式。如果转换前的下划线大写方式命名的字符串为空，则返回空字符串。 例如：HELLO_WORLD->HelloWorld
  387.      *
  388.      * @param name 转换前的下划线大写方式命名的字符串
  389.      * @return 转换后的驼峰式命名的字符串
  390.      */
  391.     public static String convertToCamelCase(String name) {
  393.         StringBuilder result = new StringBuilder();
  394.         // 快速检查
  395.         if (name == null || name.isEmpty()) {
  397.             // 没必要转换
  398.             return "";
  399.         } else if (!name.contains("_")) {
  401.             // 不含下划线，仅将首字母大写
  402.             return name.substring(0, 1).toUpperCase() + name.substring(1);
  403.         }
  404.         // 用下划线将原始字符串分割
  405.         String[] camels = name.split("_");
  406.         for (String camel : camels) {
  408.             // 跳过原始字符串中开头、结尾的下换线或双重下划线
  409.             if (camel.isEmpty()) {
  411.                 continue;
  412.             }
  413.             // 首字母大写
  414.             result.append(camel.substring(0, 1).toUpperCase());
  415.             result.append(camel.substring(1).toLowerCase());
  416.         }
  417.         return result.toString();
  418.     }
  420.     /**
  421.      * 驼峰式命名法 例如：user_name->userName
  422.      */
  423.     public static String toCamelCase(String s) {
  425.         if (s == null) {
  427.             return null;
  428.         }
  429.         s = s.toLowerCase();
  430.         StringBuilder sb = new StringBuilder(s.length());
  431.         boolean upperCase = false;
  432.         for (int i = 0; i < s.length(); i++) {
  434.             char c = s.charAt(i);
  435.             if (c == SEPARATOR) {
  437.                 upperCase = true;
  438.             } else if (upperCase) {
  440.                 sb.append(Character.toUpperCase(c));
  441.                 upperCase = false;
  442.             } else {
  444.                 sb.append(c);
  445.             }
  446.         }
  447.         return sb.toString();
  448.     }
  449. }

返回类

  1. package com.example.file.common;
  3. import java.util.HashMap;
  4. import java.util.Map;
  6. public class R extends HashMap<String, Object> {
  8.     private static final long serialVersionUID = -8157613083634272196L;
  10.     public R() {
  12.         put("code", 0);
  13.         put("msg", "success");
  14.     }
  16.     public static R error() {
  18.         return error(500, "未知异常，请联系管理员");
  19.     }
  21.     public static R error(String msg) {
  23.         return error(500, msg);
  24.     }
  26.     public static R error(int code, String msg) {
  28.         R r = new R();
  29.         r.put("code", code);
  30.         r.put("msg", msg);
  31.         return r;
  32.     }
  34.     public static R ok(String msg) {
  36.         R r = new R();
  37.         r.put("msg", msg);
  38.         return r;
  39.     }
  41.     public static R data(Object obj) {
  43.         R r = new R();
  44.         r.put("data", obj);
  45.         return r;
  46.     }
  48.     public static R ok(Map<String, Object> map) {
  50.         R r = new R();
  51.         r.putAll(map);
  52.         return r;
  53.     }
  55.     public static R ok() {
  57.         return new R();
  58.     }
  60.     @Override
  61.     public R put(String key, Object value) {
  63.         super.put(key, value);
  64.         return this;
  65.     }
  66. }

四、上传下载功能

上传

  1. /**
  2.      * 通用上传请求
  3.      */
  4.     @PostMapping("upload")
  5.     public R upload(MultipartFile file){
  7.         try {
  9.             String filePath = getFilePath();
  10.             // 上传并返回新文件名称
  11.             String fileName = FileUploadUtils.upload(filePath, file);
  12.             String url = dfsConfig.getDomain() + fileName;
  13.             return Objects.requireNonNull(R.ok().put("fileName", fileName)).put("url", url);
  14.         } catch (Exception e) {
  16.             log.error("上传文件失败", e);
  17.             return R.error(e.getMessage());
  18.         }
  19.     }
  21.     private String getFilePath() {
  23.         // 上传文件路径
  24.         String filePath;
  25.         String os = System.getProperty("os.name");
  26.         if (os.toLowerCase().startsWith("win")) {
  28.             //如果是Windows系统
  29.             filePath = dfsConfig.getWinPath();
  30.         } else {
  32.             //linux 和mac
  33.             filePath = dfsConfig.getLinuxPath();
  34.         }
  35.         return filePath;
  36.     }

在这里插入图片描述
访问就是在浏览器输入那个url：
在这里插入图片描述

下载

  1. /**
  2.      * 通用下载请求
  3.      *
  4.      * @param fileName 文件名称
  5.      * @param delete   是否删除
  6.      */
  7.     @GetMapping("download")
  8.     public void download(String fileName, Boolean delete, HttpServletResponse response, HttpServletRequest request) {
  10.         try {
  12.             // 上传文件路径
  13.             String filePath = getFilePath();
  14.             boolean validFilename = FileUtils.isValidFilename(fileName.trim());
  15.             if (!validFilename) {
  17.                 throw new Exception(StringUtils.strFormat("文件名称({})非法，不允许下载。 ", fileName));
  18.             }
  20.             String realName = fileName.substring(fileName.lastIndexOf("/") + 1);
  21.             String substring = fileName.substring(fileName.lastIndexOf("file-upload/") + 11);
  23.             filePath = filePath + substring;
  24.             response.setCharacterEncoding("utf-8");
  25.             response.setContentType("multipart/form-data");
  26.             response.setHeader("Content-Disposition",
  27.                     "attachment;fileName=" + FileUtils.setFileDownloadHeader(request, System.currentTimeMillis() + realName));
  28.             FileUtils.writeBytes(filePath, response.getOutputStream());
  29.             if (delete) {
  31.                 FileUtils.deleteFile(filePath);
  32.             }
  33.         } catch (Exception e) {
  35.             log.error("下载文件失败", e);
  36.         }
  37.     }

在这里插入图片描述

发表评论

表情：
评论列表 （有 0 条评论，160人围观）

还没有评论，来说两句吧...

相关阅读