Java离线数据包导入导出解决方案

导入依赖

            <!-- HuTool工具 -->
            <dependency>
                <groupId>cn.hutool</groupId>
                <artifactId>hutool-all</artifactId>
                <version>5.8.5</version>
            </dependency>
            
            <!-- 阿里JSON解析器 -->
            <dependency>
                <groupId>com.alibaba.fastjson2</groupId>
                <artifactId>fastjson2</artifactId>
                <version>2.0.9</version>
            </dependency>

打包工具类

public class PackDataUtils {
    private static final Logger LOGGER = LoggerFactory.getLogger(PackDataUtils.class);

	//打包后的后缀
    public static final String PACK_SUFFIX = ".data";

	//包中的文件后缀
    public static final String JSON_SUFFIX = ".json";

	//打包时的文件临时存放目录
    public static final String TEMP_PATH = "D://tempPath/";

	//打包后的文件存放目录
    public static final String OUT_PATH = "D://downloadPath/";


    /**
     * 创建临时文件夹
     * @return 临时文件夹路径
     */
    public static String createTempPath() {
        String tempPath = TEMP_PATH + DateUtils.dateTimeNow();
        File file = new File(tempPath);
        if (!file.exists()) {
            file.mkdirs();
        }
        return tempPath;
    }

    /**
     * 在原目录创建目标文件夹
     * @param targetPath 源目录
     * @param path 目标目录
     * @return 文件目录
     */
    public static String createPath(String targetPath, String path) {
        File file = new File(targetPath + File.separator + path);
        if (!file.exists()) {
            file.mkdirs();
        }
        return file.getPath();
    }

    /**
     * 压缩成数据包
     * @param inPath   输入路径
     * @param fileName 数据包名称
     * @param outPath  输出路径
     * @return 压缩包文件名称
     */
    public static String compressDataPack(String inPath, String fileName, String outPath) {
        ZipUtil.zip(inPath, outPath + File.separator + fileName, false);
        FileUtil.del(inPath);
        return fileName;
    }

    /**
     * 压缩成数据包
     * @param tempPath 输入路径
     * @param fileName 数据包名称
     */
    public static String compressDataPack(String tempPath, String fileName) {
        return compressDataPack(tempPath, fileName, OUT_PATH);
    }

    /**
     * 压缩成数据包
     * @param tempPath 输入路径
     */
    public static String compressDataPack(String tempPath) {
        return compressDataPack(tempPath, DateUtils.dateTimeNow() + PACK_SUFFIX, OUT_PATH);
    }

    public static String npackDataPack(MultipartFile file) {
        String tempPath = createTempPath();
        String fileName = file.getOriginalFilename();
        if (!fileName.endsWith(PACK_SUFFIX)) {
            throw new BaseException("文件类型错误");
        }
        String filePath = tempPath + fileName;
        try {
            file.transferTo(new File(filePath));
        } catch (IOException e) {
            throw new BaseException("文件解析失败");
        }
        ZipUtil.unzip(filePath, tempPath, CharsetUtil.CHARSET_GBK);
        return tempPath;
    }

    /**
     * 将byte数组写入文件
     * @param fileName 文件名称
     * @param outPath  输出路径
     * @param tList    数组
     */
    private static void writeJson(String fileName, String outPath, byte[] tList) {
        if (StringUtils.isNotEmpty(fileName)) {
            outPath = outPath + File.separator + fileName + JSON_SUFFIX;
        }

        FileOutputStream fos = null;
        try {
            fos = new FileOutputStream(outPath);
            fos.write(tList);
        } catch (IOException e) {
            LOGGER.error("writeJson -> There was a problem writing to the JSON file : 写入JSON文件时出现了问题");
        } finally {
            try {
                IOUtils.close(fos);
            } catch (IOException e) {
                LOGGER.error(ExceptionUtils.getMessage(e));
            }
        }
    }

    /**
     * 将集合写入JSON文件
     * @param tList    集合数据
     * @param outPath  输出路径
     * @param fileName 文件名称
     */
    public static void writeListToJson(List<?> tList, String outPath, String fileName) {
        if (tList.size() == 0) {
            return;
        }
        writeJson(fileName, outPath, JSON.toJSONBytes(tList));
    }

    /**
     * 将对象写入JSON文件
     * @param o        集合数据
     * @param outPath  输出路径
     * @param fileName 文件名称
     */
    public static void writeEntityToJson(Object o, String outPath, String fileName) {
        if (o == null) {
            return;
        }

        writeJson(fileName, outPath, JSON.toJSONBytes(o));
    }

    /**
     * 将集合写入JSON文件
     * @param tList   集合数据
     * @param outPath 输出路径
     */
    public static void writeListToJson(List<?> tList, String outPath) {
        String simpleName = "";
        if (tList.size() == 0) {
            return;
        }
        if (StringUtils.isNotNull(tList.get(0))) {
            simpleName = getClassSimpleName(tList.get(0).getClass());
        }
        writeListToJson(tList, outPath, simpleName);
    }

    /**
     * 将对象写入JSON文件
     * @param o       集合数据
     * @param outPath 输出路径
     */
    public static void writeEntityToJson(Object o, String outPath) {
        writeEntityToJson(o, outPath, getClassSimpleName(o.getClass()));
    }

    /**
     * 获取JSON文件内容
     * @param inPath JSON文件路径
     * @return JSON
     */
    private static String getJsonContent(String inPath) {
        String jsonContent = "";
        try {
            jsonContent = FileUtils.readFileToString(new File(inPath + JSON_SUFFIX), "UTF-8");
        } catch (IOException e) {
            LOGGER.error("getJsonContent -> There was a problem reading the JSON file : 读取JSON文件时出现了问题");
        }
        return jsonContent;
    }

    /**
     * 读取JSON文件转为集合
     * @param inPath   输入文件路径
     * @param tClass   class
     * @param fileName 文件名称
     * @return 集合
     */
    public static <T> List<T> readJsonToList(String inPath, Class<T> tClass, String fileName) {
        return JSON.parseArray(getJsonContent(inPath + File.separator + fileName), tClass);
    }

    /**
     * 读取JSON文件转为对象
     * @param inPath   输入文件路径
     * @param tClass   class
     * @param fileName 文件名称
     * @return 集合
     */
    public static <T> T readJsonToObject(String inPath, Class<T> tClass, String fileName) {
        return JSON.parseObject(getJsonContent(inPath + File.separator + fileName), tClass);
    }

    /**
     * 读取JSON文件转为集合
     * @param inPath 输入文件路径
     * @param tClass class
     * @return 集合
     */
    public static <T> List<T> readJsonToList(String inPath, Class<T> tClass) {
        return readJsonToList(inPath, tClass, getClassSimpleName(tClass));
    }

    /**
     * 读取JSON文件转为对象
     * @param tClass class
     * @param inPath 输入文件路径
     * @return 集合
     */
    public static <T> T readJsonToObject(String inPath, Class<T> tClass) {
        return readJsonToObject(inPath, tClass, getClassSimpleName(tClass));
    }


    /**
     * 获取类名称
     * @param tClass 类
     * @return 类名
     */
    public static String getClassSimpleName(Class<?> tClass) {
        return tClass.getSimpleName();
    }

    public static String getClassSimpleNameJson(Class<?> tClass) {
        return getClassSimpleName(tClass) + JSON_SUFFIX;
    }
}

调用方式

public String exportDataPack() {
    //创建临时目录
    String tempPath = PackDataUtils.createTempPath();

    // 压缩包名称
    String zipName = "数据包.data";

    //需要导出的List集合
    List<> userList = new ArrayList<>();

    //这里处理数据将数据添加到进集合中
    userList.add(new User(1, "张三"));
    userList.add(new User(2, "李四"));
    userList.add(new User(3, "王五"));

    //将List写入JSON文件
    PackDataUtils.writeListToJson(userList, tempPath);

    //打包成.data文件，最后返回文件名称，文件存放在输出目录目录下（D://downloadPath/）
    return AjaxResult.success(PackDataUtils.compressDataPack(tempPath, zipName));
}

public void importDataPack(importEntity importEntity) {
    final MultipartFile importFile = importEntity.getFile();

    //解压数据包到文件临时存放目录，返回解压后的路径
    String filePath = PackDataUtils.npackDataPack(importFile) + File.separator;

    //判断数据包是否有该实体的JSON文件
    if (FileUtil.exist(filePath + PackDataUtils.getClassSimpleNameJson(User.class))) {
        // 拿到数据集合
        List<JhExpenditure> users = PackDataUtils.readJsonToList(filePath, User.class);

        //处理相应的业务添加进数据库

    }

    // 最后删除临时文件
    FileUtil.del(filePath);
}