背景

实际工作中两个服务之间的接口调用可能会涉及到文件加密传输的问题，Base64就是其中一种解决方案。

工具类

/**
 * 参考：https://blog.csdn.net/p812438109/article/details/108370312
 */
@Slf4j
public class Base64FileUtils {

    /**
     * 根据文件路径加密
     * @param filePath
     * @return
     */
    public static String encode(String filePath) {
        if (StrUtil.isNotBlank(filePath)) {
            return encode(new File(filePath));
        }
        return null;
    }

    /**
     * 根据文件加密
     * @param file
     * @return
     */
    public static String encode(File file) {
        if (!file.exists()) {
            throw new RuntimeException("File is not exist");
        }
        return encode(FileUtil.getName(file), FileUtil.readBytes(file));
    }
    /**
     * 根据文件名称及内容加密
     * @param fileName
     * @param content
     * @return
     */
    public static String encode(String fileName, byte[] content) {
        if (StrUtil.isNotBlank(fileName) && ArrayUtil.isNotEmpty(content)) {
            String fileExtName = FileNameUtil.extName(fileName);
            String base64FileType = Base64FileType.getByFileExtName(fileExtName);
            if (StrUtil.isNotBlank(base64FileType)) {
                return base64FileType + Base64.encode(content);
            }
        }
        return null;
    }

    /**
     * 根据文件名称及加密字符串解密
     * @param encodeStr
     * @param fileName
     * @return
     */
    public static byte[] decode(String encodeStr, String fileName) {
        if (StrUtil.isNotBlank(fileName) && StrUtil.isNotBlank(encodeStr)) {
            String fileExtName = FileNameUtil.extName(fileName);
            String base64FileType = Base64FileType.getByFileExtName(fileExtName);
            if (StrUtil.isNotBlank(base64FileType)) {
                return Base64.decode(encodeStr.replace(base64FileType, StrUtil.EMPTY));
            }
        }
        return null;
    }

    /**
     * 解码并生成文件
     * @param encodeStr
     * @param targetFilePath
     * @return
     */
    public static boolean decodeToFile(String encodeStr, String targetFilePath) {
        if (StrUtil.isNotBlank(encodeStr)) {
            String fileExtName = FileNameUtil.extName(targetFilePath);
            String base64FileType = Base64FileType.getByFileExtName(fileExtName);
            if (StrUtil.isNotBlank(base64FileType)) {
                FileUtil.writeBytes(Base64.decode(encodeStr.replace(base64FileType, StrUtil.EMPTY)), targetFilePath);
                return true;
            }
        }
        return false;
    }

    /**
     * base64文件类型对应枚举类
     */
    public enum Base64FileType {
        // 文件类型
        BASE64_FILE_TYPE_DOC("doc", "data:application/msword;base64,"),
        BASE64_FILE_TYPE_DOCX("docx", "data:application/vnd.openxmlformats-officedocument.wordprocessingml.document;base64,"),
        BASE64_FILE_TYPE_XLS("xls", "data:application/vnd.ms-excel;base64,"),
        BASE64_FILE_TYPE_XLSX("xlsx", "data:application/vnd.openxmlformats-officedocument.spreadsheetml.sheet;base64,"),
        BASE64_FILE_TYPE_PDF("pdf", "data:application/pdf;base64,"),
        BASE64_FILE_TYPE_PPT("ppt", "data:application/vnd.ms-powerpoint;base64,"),
        BASE64_FILE_TYPE_PPTX("pptx", "data:application/vnd.openxmlformats-officedocument.presentationml.presentation;base64,"),
        BASE64_FILE_TYPE_TXT("txt", "data:text/plain;base64,"),

        // 图片类型
        BASE64_FILE_TYPE_PNG("png", "data:image/png;base64,"),
        BASE64_FILE_TYPE_JPG("jpg", "data:image/jpeg;base64,"),
        BASE64_FILE_TYPE_JPEG("jpeg", "data:image/jpeg;base64,"),
        BASE64_FILE_TYPE_GIF("gif", "data:image/gif;base64,"),
        BASE64_FILE_TYPE_SVG("svg", "data:image/svg+xml;base64,"),
        BASE64_FILE_TYPE_ICO("ico", "data:image/x-icon;base64,"),
        BASE64_FILE_TYPE_BMP("bmp", "data:image/bmp;base64,"),

        // 二进制流
        BASE64_FILE_TYPE_OCTET_STREAM("octet-stream", "data:application/octet-stream;base64,")
        ;

        Base64FileType(String code, String value) {
            this.fileExtName = code;
            this.base64FileType = value;
        }

        /**
         * 文件扩展名类型
         */
        private String fileExtName;
        /**
         * 文件对应的base64类型
         */
        private String base64FileType;

        public String getFileExtName() {
            return fileExtName;
        }

        public String getBase64FileType() {
            return base64FileType;
        }

        public static String getByFileExtName(String fileExtName) {
            Base64FileType[] types = Base64FileType.values();
            for (Base64FileType type : types) {
                if (type.getFileExtName().equals(fileExtName)) {
                    return type.getBase64FileType();
                }
            }
            return null;
        }
    }
}

测试示例

public class Base64FileUtilsTest {
    String BASE_DIR = "E:\\1temp\\";

    /**
     * 模拟需要传输的文件
     */
    String SOURCE_FILE_PATH = BASE_DIR.concat("1.docx");

    /**
     * 模拟接口路径
     */
    String URL = "http://localhost:8080/encode";

    /**
     * 模拟加密
     */
    @Test
    public void testEncode() {
        String encodeStr = Base64FileUtils.encode(SOURCE_FILE_PATH);
        Map<String, Object> params = new HashMap<>();
        params.put("fileName", FileUtil.getName(SOURCE_FILE_PATH));
        params.put("fileContent", encodeStr);
        this.sendJsonPostRequest(URL, params);
    }

    /**
     * 模拟发送请求
     *
     * @param url
     * @param params
     * @return
     */
    private String sendJsonPostRequest(String url, Map<String, Object> params) {
        Map<String, String> header = new HashMap<>();
        header.put("Content-Type", "application/json;charset=UTF-8");
        return HttpUtil.createPost(url).body(JSONUtil.toJsonStr(params)).addHeaders(header).execute().body();
    }

    /**
     * 模拟解密后生成的文件路径
     */
    String TARGET_FILE_PATH = BASE_DIR.concat("encode.docx");

    /**
     * 模拟解密并生成文件
     */
    @Test
    public void testDecode() {
        String decodeStr = this.getEncodeStr();
        Base64FileUtils.decodeToFile(decodeStr, TARGET_FILE_PATH);
    }

    /**
     * 模拟获取加密字符串
     */
    public String getEncodeStr() {
        // 相关的业务操作
        return "xxx";
    }
}