文件工具类-上传、删除、验证

主要功能
1.普通文件上传
2.多文件上传
3.大文件上传
4.验证文件（是否为空，类型是否正确，大小是否正确）
5.删除文件（多个文件）

import org.apache.commons.io.FileUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import org.springframework.util.ObjectUtils;
import org.springframework.web.multipart.MultipartFile;

import java.io.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.UUID;

/**
 * 文件上传工具类
 */
@Component
public class MyFileUtils {

    private final Logger logger = LoggerFactory.getLogger(MyFileUtils.class);

    //文件上传基本路径
    @Value("${file.upload.path}")
    private String basePath;

    //文件上传最大值数量
    @Value("${file.upload.size}")
    private Integer size;

    //文件上传最大值单位
    @Value("${file.upload.unit}")
    private String unit;

    //文件上传允许类型，用;隔开 例：jpg;png;
    @Value("${file.upload.type}")
    private String type;

    /**
     * 普通上传
     *
     * @param file     文件
     * @param midPath  中层文件夹
     * @param fileName 文件名
     * @return 文件名
     */
    public String upload(MultipartFile file, String midPath, String fileName) {
        String orgFileName = file.getOriginalFilename();
        if (fileName != null && !("").equals(fileName)) {
            assert orgFileName != null;
            String suf = this.cutSuffix(orgFileName);
            orgFileName = fileName + suf;
        }
        try {
            assert orgFileName != null;
            File directory = new File(basePath + midPath);
            if (!directory.exists()) {
                directory.mkdirs();
            }
            File targetFile = new File(directory, orgFileName);
            FileUtils.writeByteArrayToFile(targetFile, file.getBytes());
            return targetFile.getAbsolutePath();
        } catch (IOException e) {
            logger.error("上传失败");
            e.printStackTrace();
        }
        return "";
    }

    /**
     * 多文件上传
     *
     * @param prefix  前缀
     * @param midPath 中间目录
     * @param file    文件
     * @return 文件名列表
     * @throws IOException e
     */
    public List<String> uploadMulFile(String prefix, String midPath, MultipartFile[] file) throws IOException {
        List<String> fileList = new ArrayList<>();
        for (MultipartFile multipartFile : file) {
            String originalFilename = multipartFile.getOriginalFilename();
            assert originalFilename != null;
            String fileName = prefix + this.getUUID(8) + cutSuffix(originalFilename);
            File directory = new File(basePath + midPath);
            if (!directory.exists()) {
                directory.mkdirs();
            }
            String path = directory.getCanonicalPath();
            File dest = new File(path + "/" + fileName);            
            try {
                multipartFile.transferTo(dest);
                fileList.add(dest.getAbsolutePath());
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return fileList;
    }

    /**
     * 大文件上传
     *
     * @param file     文件
     * @param midPath  中层目录
     * @param fileName 文件名
     * @return 文件名
     * @throws IOException e
     */
    public String uploadBigFile(MultipartFile file, String midPath, String fileName) throws IOException {
        if (!file.isEmpty()) {
            String path = file.getOriginalFilename();
            if (fileName != null) {
                assert path != null;
                path = fileName + this.cutSuffix(path);
            }
            File directory = new File(basePath + midPath);
            String paths = directory.getCanonicalPath();
            path = paths + "/" + path;
            BufferedOutputStream bufferedOutputStream=null;
            try {
                bufferedOutputStream = new BufferedOutputStream(
                        new FileOutputStream(path));
                int length;
                byte[] buffer = new byte[1024];
                InputStream inputStream = file.getInputStream();
                while ((length = inputStream.read(buffer)) != -1) {
                    bufferedOutputStream.write(buffer, 0, length);
                }
                bufferedOutputStream.flush();
                bufferedOutputStream.close();
                return path;
            } catch (IOException e) {
                logger.error("文件上传失败");
                e.printStackTrace();
                logger.error(e.getMessage());
            }
        } else {
            logger.warn("文件内容为空");
        }
        return "";
    }

    /**
     * 截取文件名后缀
     *
     * @param fileName 文件名
     * @return 后缀
     */
    public String cutSuffix(String fileName) {
        int i = fileName.indexOf(".");
        if (i != -1) {
            return fileName.substring(i);
        }
        return fileName;
    }

    /**
     * 验证文件是否为空
     *
     * @param files 多文件
     * @return 是否符合
     */
    public boolean checkFileEmpty(MultipartFile... files) {
        if (files == null) {
            return false;
        }
        for (MultipartFile file : files) {
            if (ObjectUtils.isEmpty(file) || file.getSize() <= 0) {
                return false;
            }
        }
        return true;

    }

    /**
     * 验证文件列表是否符合
     *
     * @param files 多文件
     * @return 是否符合
     */
    public boolean checkFile(MultipartFile... files) {
        for (MultipartFile file : files) {
            List<String> allowType = Arrays.asList(type.split(","));
            boolean b = this.checkFileType(allowType, file.getOriginalFilename());
            if (!b) {
                logger.error("文件类型错误");
                return false;
            }
            boolean m = this.checkFileSize(file, size, unit);
            if (!m) {
                logger.error("文件太大");
                return false;
            }
        }
        return true;

    }

    /**
     * 验证文件大小
     *
     * @param file 文件
     * @param size 目标数
     * @param unit 目标单位
     * @return 是否符合
     */
    public boolean checkFileSize(MultipartFile file, int size, String unit) {
        long len = file.getSize();
        double fileSize = 0;
        switch (unit.toUpperCase()) {
            case "B":
                fileSize = (double) len;
                break;
            case "K":
                fileSize = (double) len / 1024;
                break;
            case "M":
                fileSize = (double) len / 1048576;
                break;
            case "G":
                fileSize = (double) len / 1073741824;
                break;
        }
        return !(fileSize > size);
    }

    /**
     * 验证文件类型
     *
     * @param allowType 允许类型
     * @param fileName  文件名
     * @return 是否符合
     */
    public boolean checkFileType(List<String> allowType, String fileName) {
        String suf = this.cutSuffix(fileName);
        if (suf.indexOf('.') != -1) {
            String substring = suf.substring(suf.indexOf('.') + 1);
            return allowType.contains(substring.toLowerCase());
        }
        return false;
    }

    /**
     * 删除文件
     *
     * @param filePath 多个文件路径
     */
    public void delFile(String... filePath) {
        try {
            for (String f : filePath) {
                File file = new File(f);
                if (file.exists()) {
                    file.delete();
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 获取带前缀的指定长度的uuid
     *
     * @param len    长度
     * @param prefix 前缀
     * @return 返回字符串
     */
    public String getUUID(int len, String... prefix) {
        String s = UUID.randomUUID().toString();
        s = s.replace("-", "");
        String uuid = len < s.length() ? s.substring(0, len) : s;
        if (prefix.length == 0) {
            return uuid;
        } else {
            StringBuilder stringBuilder = new StringBuilder();
            for (String prefix1 : prefix) {
                stringBuilder.append(prefix1);
                stringBuilder.append("-");
            }
            return stringBuilder.toString() + uuid;
        }
    }
}