content: package com.ruoyi.work.utils;
  
  
  import com.ruoyi.common.utils.StringUtils;
  import com.ruoyi.common.utils.file.FileTypeUtils;
  import com.ruoyi.common.utils.file.MimeTypeUtils;
  import org.apache.commons.lang3.ArrayUtils;
  
  import javax.servlet.http.HttpServletRequest;
  import javax.servlet.http.HttpServletResponse;
  import java.io.*;
  import java.net.URLEncoder;
  import java.nio.charset.StandardCharsets;
  import java.nio.file.Files;
  
  /**
   * 文件处理工具类
   *
   * @author ruoyi
   */
  public class FileUtils {
      /**
       * 字符常量：斜杠 {@code '/'}
       */
      public static final char SLASH = '/';
  
      /**
       * 字符常量：反斜杠 {@code '\\'}
       */
      public static final char BACKSLASH = '\\';
  
      public static String FILENAME_PATTERN = "[a-zA-Z0-9_\\-\\|\\.\\u4e00-\\u9fa5]+";
  
      /**
       * 输出指定文件的byte数组
       *
       * @param filePath 文件路径
       * @param os       输出流
       * @return
       */
      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);
              }
          } catch (IOException e) {
              throw e;
          } 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 文件
       * @return
       */
      public static boolean deleteFile(String filePath) {
          boolean flag = false;
          File file = new File(filePath);
          // 路径为文件且不为空则进行删除
          if (file.isFile() && file.exists()) {
              flag = file.delete();
          }
          return flag;
      }
  
      /**
       * 文件名称验证
       *
       * @param filename 文件名称
       * @return true 正常 false 非法
       */
      public static boolean isValidFilename(String filename) {
          return filename.matches(FILENAME_PATTERN);
      }
  
      /**
       * 检查文件是否可下载
       *
       * @param resource 需要下载的文件
       * @return true 正常 false 非法
       */
      public static boolean checkAllowDownload(String resource) {
          // 禁止目录上跳级别
          if (StringUtils.contains(resource, "..")) {
              return false;
          }
  
          // 检查允许下载的文件规则
          if (ArrayUtils.contains(MimeTypeUtils.DEFAULT_ALLOWED_EXTENSION, FileTypeUtils.getFileType(resource))) {
              return true;
          }
  
          // 不在允许下载的文件规则
          return false;
      }
  
      /**
       * 下载文件名重新编码
       *
       * @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;
      }
  
      /**
       * 返回文件名
       *
       * @param filePath 文件
       * @return 文件名
       */
      public static String getName(String filePath) {
          if (null == filePath) {
              return null;
          }
          int len = filePath.length();
          if (0 == len) {
              return filePath;
          }
          if (isFileSeparator(filePath.charAt(len - 1))) {
              // 以分隔符结尾的去掉结尾分隔符
              len--;
          }
  
          int begin = 0;
          char c;
          for (int i = len - 1; i > -1; i--) {
              c = filePath.charAt(i);
              if (isFileSeparator(c)) {
                  // 查找最后一个路径分隔符（/或者\）
                  begin = i + 1;
                  break;
              }
          }
  
          return filePath.substring(begin, len);
      }
  
      /**
       * 是否为Windows或者Linux（Unix）文件分隔符<br>
       * Windows平台下分隔符为\，Linux（Unix）为/
       *
       * @param c 字符
       * @return 是否为Windows或者Linux（Unix）文件分隔符
       */
      public static boolean isFileSeparator(char c) {
          return SLASH == c || BACKSLASH == c;
      }
  
      /**
       * 下载文件名重新编码
       *
       * @param response     响应对象
       * @param realFileName 真实文件名
       * @return
       */
      public static void setAttachmentResponseHeader(HttpServletResponse response, String realFileName) throws UnsupportedEncodingException {
          String percentEncodedFileName = percentEncode(realFileName);
  
          StringBuilder contentDispositionValue = new StringBuilder();
          contentDispositionValue.append("attachment; filename=")
                  .append(percentEncodedFileName)
                  .append(";")
                  .append("filename*=")
                  .append("utf-8''")
                  .append(percentEncodedFileName);
  
          response.setHeader("Content-disposition", contentDispositionValue.toString());
          response.setHeader("download-filename", percentEncodedFileName);
      }
  
      /**
       * 百分号编码工具方法
       *
       * @param s 需要百分号编码的字符串
       * @return 百分号编码后的字符串
       */
      public static String percentEncode(String s) throws UnsupportedEncodingException {
          String encode = URLEncoder.encode(s, StandardCharsets.UTF_8.toString());
          return encode.replaceAll("\\+", "%20");
      }
  
      /**
       * 创建文件顺便创建父目录
       *
       * @param path 文件字符串路径例如d:/fulld/why/ass/a/asd
       */
      public static void createFile(String path) {
          createFile(new File(path));
      }
  
      /**
       * 创建文件顺便创建父目录
       *
       * @param file file类
       */
      private static void createFile(File file) {
          if (file.exists() && file.isFile()) {
              file.delete();
              try {
                  file.createNewFile();
              } catch (IOException e) {
                  e.printStackTrace();
              }
              return;
          }
          File parentFile = file.getParentFile();
          if (parentFile.exists()) {
              if (parentFile.isFile()) {
                  parentFile.delete();
                  parentFile.mkdirs();
              }
          } else {
              parentFile.mkdirs();
          }
          try {
              file.createNewFile();
          } catch (IOException e) {
              e.printStackTrace();
          }
      }
  
      /**
       * 创建文件夹顺便创建父目录
       *
       * @param path 文件夹的路径字符串例如d:/fulld/why/ass/a/asd/
       * @return 如果本来就存在或者创建成功，那么就返回true
       */
      public static void mkdirs(String path) {
          mkdirs(new File(path));
      }
  
      /**
       * 创建文件夹顺便创建父目录
       *
       * @param file file类
       */
      public static void mkdirs(File file) {
          if (file.exists() && file.isDirectory()) {
              return;
          }
          if (file.exists()) {
              file.delete();
              file.mkdirs();
          } else {
              file.mkdirs();
          }
      }
  
      //文件夹拷贝    不管是路径还是File对象都可直接使用
      //拷贝文件夹方法
      // String 对象
      public static void copyDir(String srcPath, String destPath) {
          File src = new File(srcPath);
          File dest = new File(destPath);
          copyDir(src, dest);
      }
  
      //拷贝文件夹方法
      //File 对象
      public static void copyDir(File src, File dest) {
          if (src.isDirectory()) {//文件夹
              dest = new File(dest, src.getName());
          }
          copyDirDetail(src, dest);
      }
  
  
      //拷贝文件夹细节
      public static void copyDirDetail(File src, File dest) {
          if (src.isFile()) {   //文件直接复制
              try {
                  copyFile(src, dest);
              } catch (IOException e) {
                  e.printStackTrace();
              }
          } else if (src.isDirectory()) {//目录
              //确保文件夹存在
              dest.mkdirs();
              //获取下一级目录|文件
              for (File sub : src.listFiles()) {
                  copyDirDetail(sub, new File(dest, sub.getName()));
              }
          }
      }
  
      //文件拷贝
      public static void copyFile(String srcPath, String destPath) throws IOException {
          File src = new File(srcPath);
          File dest = new File(destPath);
          copyFile(src, dest);
      }
  
      public static void copyFile(File srcPath, File destPath) throws IOException {
  
          //选择流
          InputStream is = Files.newInputStream(srcPath.toPath());
          OutputStream os = Files.newOutputStream(destPath.toPath());
          //拷贝  循环+读取+写出
          byte[] flush = new byte[1024];
          int len = 0;
          //读取
          while (-1 != (len = is.read(flush))) {
              //写出
              os.write(flush, 0, len);
          }
          os.flush();//强制刷出
          //关闭流  先打开后关闭
          os.close();
          is.close();
      }
  }
  