玄子Share-MultipartFileUtil-文件上传工具类，单文件，多文件，指定大小，指定后缀，等

package com.xuanzi.utils;

import jakarta.servlet.http.HttpSession;
import org.apache.commons.io.FilenameUtils;
import org.springframework.web.multipart.MultipartFile;

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
 * @author 玄子
 * @version 2.5
 * 先传入上传文件：multipartFile，在传入上传文件路径：serverUploadPath；
 * 可用 getProjectRealPath() 方法获取，传入 session 与子级目录
 * 用法示例：
 * MultipartFileUtil multipartFileUtil = new MultipartFileUtil();
 * String projectRealPath = multipartFileUtil.getProjectRealPath(session, "/statics/upload/");
 * multipartFileUtil.upLoadMultipartFileImg(multipartFile, projectRealPath);
 * System.out.println(multipartFileUtil.getServerFinalFileUploadPath());
 * 根据不同的需求可调用不同的 upLoadMultipartFile 方法，详见方法名与参数
 * 你可能会用到的字段：
 * serverFinalFileUploadPath：服务器最终文件上传文件的路径，从磁盘根路径到文件名称
 * uploadFileName：处理后上传文件名称，上传服务器的文件名称，仅限文件名包含后缀名
 * getProjectContextPath() 与 getProjectRealPath() 用法一致，前者返回项目路径，后者返回磁盘路径，均不包含文件名
 * 多文件上传提供遍历模板，仅具有文件上传功能，根据需求往数据库添加所需字段
 * 最终修改日期：2023-09-16
 */
public class MultipartFileUtil {
    private String serverUploadPath;
    //  服务器上传路径，下一级目录为上传文件
    private boolean serverUploadPathExists;
    //  服务器上传路径，是否存在，不存在自动创建
    private String originalFileName;
    //  上传源文件名称
    private String originalFileSuffix;
    //  上传源文件后缀
    private long originalFileSize;
    //  上传源文件大小
    private double maxRequire = 10485760;
    //  上传文件最大大小，默认 10 MB = 10240 KB
    private double minRequire = 10485.76;
    //  上传文件最小大小，默认 0.01 MB = 10.24 KB
    private String uploadFileName;
    //  处理后上传文件名称
    private String serverFinalFileUploadPath;
    //  服务器最终文件上传文件路径
    private boolean isUploadFile;
    //  文件是否上传校验
    private String errorMessage;
    //  获取文件上传异常信息

    //  验证上传文件是否为空
    private boolean multipartFileIsEmpty(MultipartFile multipartFile) {
        if (!multipartFile.isEmpty()) {
            this.originalFileSize = multipartFile.getSize();
            this.originalFileName = multipartFile.getOriginalFilename();
            this.originalFileSuffix = FilenameUtils.getExtension(this.originalFileName);
            System.out.println("单文件上传：源文件非空校验通过");
            return isUploadFile = true;
        } else {
            System.out.println("单文件上传：源文件非空校验异常");
            return isUploadFile = false;
        }
    }

    //  验证多文件上传文件是否为空
    private boolean multipartFilesIsEmpty(MultipartFile[] multipartFiles) {
        if (multipartFiles != null) {
            System.out.println("多文件上传：源文件非空校验通过");
            return isUploadFile = true;
        } else {
            System.out.println("多文件上传：源文件非空校验异常");
            return isUploadFile = false;
        }
    }

    //  验证上传文件目录是否为空
    private boolean serverUploadPathExists(String serverUploadPath) {
        this.serverUploadPath = serverUploadPath;
        File uploadPath = new File(this.serverUploadPath);
        if (uploadPath.exists()) {
            this.serverUploadPathExists = true;
            System.out.println("服务器上传路径校验通过");
            return isUploadFile = true;
        } else {
            this.serverUploadPathExists = uploadPath.mkdirs();
            //  检查目录是否存在，目录不存在进行创建
            if (!this.serverUploadPathExists) {
                System.out.println("服务器上传路径校验异常");
                return isUploadFile = false;
            } else {
                System.out.println("服务器上传路径校验通过");
                return isUploadFile = false;
            }
        }
    }

    //  验证上传文件大小限制
    private boolean originalFileSizeRequire(double minRequire, double maxRequire) {
        this.minRequire = minRequire;
        this.maxRequire = maxRequire;
        if ((this.originalFileSize >= this.minRequire) && (this.originalFileSize <= this.maxRequire)) {
            System.out.println("上传文件大小校验通过");
            return isUploadFile = true;
        } else {
            System.out.println("上传文件大小校验异常：上传文件字节：" + this.originalFileSize + ";限制最小字节：" + this.minRequire + ";限制最大字节：" + this.maxRequire);
            return isUploadFile = false;
        }
    }

    //  验证上传文件后缀限制
    private boolean suffixRequires(List<String> suffixRequires) {
        for (String suffixRequire : suffixRequires) {
            if (this.originalFileSuffix.equalsIgnoreCase(suffixRequire)) {
                System.out.println("上传文件后缀校验通过");
                return isUploadFile = true;
            }
        }
        System.out.println("上传文件后缀校验异常：上传文件后缀：" + this.originalFileSuffix + ";限制文件后缀：" + suffixRequires);
        return isUploadFile = false;
    }

    //  文件上传校验失败调用
    private MultipartFileUtil UploadFileError(String errorMessage) {
        this.errorMessage = errorMessage;
        System.out.println("文件上传失败：" + this.isUploadFile);
        System.out.println("========================");
        return this;
    }

    //  单文件上传，全参数
    public MultipartFileUtil upLoadMultipartFile(MultipartFile multipartFile, String serverUploadPath, List<String> suffixRequires, double minRequire, double maxRequire) throws IOException {
        if (multipartFileIsEmpty(multipartFile)) {
            if (serverUploadPathExists(serverUploadPath)) {
                if (originalFileSizeRequire(minRequire, maxRequire)) {
                    if (suffixRequires(suffixRequires)) {
                        this.uploadFileName = System.currentTimeMillis() + "-" + this.originalFileName;
                        System.out.println("处理后上传文件名称：" + this.uploadFileName);
                        this.serverFinalFileUploadPath = this.serverUploadPath + this.uploadFileName;
                        System.out.println("服务器最终文件上传文件路径：" + this.serverFinalFileUploadPath);
                        multipartFile.transferTo(new File(this.serverFinalFileUploadPath));
                        System.out.println("文件上传成功：" + isUploadFile);
                        System.out.println("========================");
                        return this;
                    } else {
                        return UploadFileError("上传文件后缀校验异常：上传文件后缀：" + this.originalFileSuffix + ";限制文件后缀：" + suffixRequires);
                    }
                } else {
                    return UploadFileError("上传文件大小校验异常：上传文件字节：" + this.originalFileSize + ";限制最小字节：" + this.minRequire + ";限制最大字节：" + this.maxRequire);
                }
            } else {
                return UploadFileError("服务器上传路径校验异常");
            }
        } else {
            return UploadFileError("单文件上传：源文件非空校验异常");
        }
    }

    //  单文件上传，无大小参数
    public MultipartFileUtil upLoadMultipartFileNoSize(MultipartFile multipartFile, String serverUploadPath, List<String> suffixRequires) throws IOException {
        return upLoadMultipartFile(multipartFile, serverUploadPath, suffixRequires, this.minRequire, this.maxRequire);
    }

    //  单文件上传，无后缀大小参数，上传图片验证
    public MultipartFileUtil upLoadMultipartFileImg(MultipartFile multipartFile, String serverUploadPath) throws IOException {
        return upLoadMultipartFile(multipartFile, serverUploadPath, this.getImgSuffixRequires(), this.minRequire, this.maxRequire);
    }

    //  单文件上传，无后缀大小参数，上传文档验证
    public MultipartFileUtil upLoadMultipartFileWord(MultipartFile multipartFile, String serverUploadPath) throws IOException {
        return upLoadMultipartFile(multipartFile, serverUploadPath, this.getWordSuffixRequires(), this.minRequire, this.maxRequire);
    }

    //  多文件上传，全参数
    public List<MultipartFileUtil> upLoadMultipartFiles(MultipartFile[] multipartFiles, String serverUploadPath, List<String> suffixRequires, double minRequire, double maxRequire) throws IOException {
        List<MultipartFileUtil> multipartFileUtil2List = new ArrayList<>();
        if (multipartFilesIsEmpty(multipartFiles)) {
            for (MultipartFile multipartFile : multipartFiles) {
                MultipartFileUtil multipartFileUtil = new MultipartFileUtil().upLoadMultipartFile(multipartFile, serverUploadPath, suffixRequires, minRequire, maxRequire);
                multipartFileUtil2List.add(multipartFileUtil);
            }
            System.out.println("多文件上传：执行完毕");
        } else {
            System.out.println("多文件上传异常：上传文件校验为空");
            this.errorMessage = "多文件上传异常：上传文件校验为空";
        }
        return multipartFileUtil2List;
    }

    //  多文件上传，无大小参数
    public List<MultipartFileUtil> upLoadMultipartFilesNoSizes(MultipartFile[] multipartFiles, String serverUploadPath, List<String> suffixRequires) throws IOException {
        List<MultipartFileUtil> multipartFileUtil2List = new ArrayList<>();
        if (multipartFilesIsEmpty(multipartFiles)) {
            for (MultipartFile multipartFile : multipartFiles) {
                MultipartFileUtil multipartFileUtil = new MultipartFileUtil().upLoadMultipartFileNoSize(multipartFile, serverUploadPath, suffixRequires);
                multipartFileUtil2List.add(multipartFileUtil);
            }
            System.out.println("多文件上传：执行完毕");
        } else {
            System.out.println("多文件上传异常：上传文件校验为空");
            this.errorMessage = "多文件上传异常：上传文件校验为空";
        }
        return multipartFileUtil2List;
    }

    //  多文件上传，无后缀大小参数，上传图片验证
    public List<MultipartFileUtil> upLoadMultipartFilesImgs(MultipartFile[] multipartFiles, String serverUploadPath) throws IOException {
        List<MultipartFileUtil> multipartFileUtil2List = new ArrayList<>();
        if (multipartFilesIsEmpty(multipartFiles)) {
            for (MultipartFile multipartFile : multipartFiles) {
                MultipartFileUtil multipartFileUtil = new MultipartFileUtil().upLoadMultipartFileImg(multipartFile, serverUploadPath);
                multipartFileUtil2List.add(multipartFileUtil);
            }
            System.out.println("多文件上传：执行完毕");
        } else {
            System.out.println("多文件上传异常：上传文件校验为空");
            this.errorMessage = "多文件上传异常：上传文件校验为空";
        }
        return multipartFileUtil2List;
    }

    //  多文件上传，无后缀大小参数，上传文档验证
    public List<MultipartFileUtil> upLoadMultipartFilesWords(MultipartFile[] multipartFiles, String serverUploadPath) throws IOException {
        List<MultipartFileUtil> multipartFileUtil2List = new ArrayList<>();
        if (multipartFilesIsEmpty(multipartFiles)) {
            for (MultipartFile multipartFile : multipartFiles) {
                MultipartFileUtil multipartFileUtil = new MultipartFileUtil().upLoadMultipartFileWord(multipartFile, serverUploadPath);
                multipartFileUtil2List.add(multipartFileUtil);
            }
            System.out.println("多文件上传：执行完毕");
        } else {
            System.out.println("多文件上传异常：上传文件校验为空");
            this.errorMessage = "多文件上传异常：上传文件校验为空";
        }
        return multipartFileUtil2List;
    }

    //  文件上传的全路径：磁盘跟目录到文件路径
    public String getProjectRealPath(HttpSession session, String catalogue) {
        return session.getServletContext().getRealPath(catalogue);
    }

    //  文件上传的项目路径：项目名到文件路径
    public String getProjectContextPath(HttpSession session, String catalogue) {
        return session.getServletContext().getContextPath() + catalogue;
    }

    //  将兆字节 (MB) 转换为字节 (bytes)
    public long getMBToBytes(double megabytes) {
        if (megabytes < 0) {
            throw new IllegalArgumentException("兆字节数不能为负数");
        }
        return (long) (megabytes * 1024 * 1024);
    }

    //  将字节 (bytes) 转换为兆字节 (MB)
    public double getBytesToMB(long bytes) {
        if (bytes < 0) {
            throw new IllegalArgumentException("字节数不能为负数");
        }
        return (double) bytes / (1024 * 1024);
    }

    //  获取常见图片后缀格式
    public List<String> getImgSuffixRequires() {
        return new ArrayList<>(Arrays.asList("jpg", "jpeg", "png", "gif", "bmp", "tif", "tiff", "ico"));
    }

    //  获取常见文档后缀格式
    public List<String> getWordSuffixRequires() {
        return new ArrayList<>(Arrays.asList("pdf", "doc", "docx", "ppt", "pptx", "xls", "xlsx", "txt"));
    }

    public String getServerUploadPath() {
        return serverUploadPath;
    }

    public boolean isServerUploadPathExists() {
        return serverUploadPathExists;
    }

    public String getOriginalFileName() {
        return originalFileName;
    }

    public String getOriginalFileSuffix() {
        return originalFileSuffix;
    }

    public long getOriginalFileSize() {
        return originalFileSize;
    }

    public double getMaxRequire() {
        return maxRequire;
    }

    public double getMinRequire() {
        return minRequire;
    }

    public String getUploadFileName() {
        return uploadFileName;
    }

    public String getServerFinalFileUploadPath() {
        return serverFinalFileUploadPath;
    }

    public boolean isUploadFile() {
        return isUploadFile;
    }

    public String getErrorMessage() {
        return errorMessage;
    }

    @Override
    public String toString() {
        return "MultipartFileUtil{" +
                "serverUploadPath='" + serverUploadPath + '\'' +
                ", serverUploadPathExists=" + serverUploadPathExists +
                ", originalFileName='" + originalFileName + '\'' +
                ", originalFileSuffix='" + originalFileSuffix + '\'' +
                ", originalFileSize=" + originalFileSize +
                ", maxRequire=" + maxRequire +
                ", minRequire=" + minRequire +
                ", uploadFileName='" + uploadFileName + '\'' +
                ", serverFinalFileUploadPath='" + serverFinalFileUploadPath + '\'' +
                ", isUploadFile=" + isUploadFile +
                ", errorMessage='" + errorMessage + '\'' +
                '}';
    }
}