java实现大数量级的数据导出excel，excel数据读取

于 2024-09-12 15:02:09 发布
阅读量696 收藏 13
点赞数 14
文章标签： java excel
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cai_xu_kun_kun/article/details/142175558
版权

先搞个工具类：

public class EasyExcelUtil {
    /**
     * @param response
     * @param exportTypeEnum
     * @param fileName
     * @return java.io.OutputStream
     * @Author JH
     * @Description 设置导出响应请求头
     * @Date 13:57 2022/10/27
     **/
    public static OutputStream getOutputStream(HttpServletResponse response, ExportTypeEnum exportTypeEnum, String fileName) throws IOException {
        response.setContentType(exportTypeEnum.getContentType());
        response.setHeader(HttpHeaders.CACHE_CONTROL, "no-cache");
        response.setCharacterEncoding(Constants.UTF8);
        // 这里URLEncoder.encode可以防止中文乱码
        fileName = URLEncoder.encode(fileName, "UTF-8");
        response.setHeader("Content-Disposition", "attachment;filename=" + new String((fileName + exportTypeEnum.getFileExtName()).getBytes()));
        response.setHeader("download-filename", fileName + exportTypeEnum.getFileExtName());
        return response.getOutputStream();
    }

    /**
     * @param templateEmun
     * @return java.io.InputStream
     * @Author JH
     * @Description 获取模板 的 InputStream
     * @Date 14:09 2022/10/27
     **/
    public static InputStream getTemplate(TemplateEmun templateEmun) {
        String templateName = templateEmun.getName() + templateEmun.getExportTypeEnum().getFileExtName();
        ClassLoader classLoader = EasyExcelUtil.class.getClassLoader();
        InputStream inputStream = classLoader.getResourceAsStream("/template/" + templateName);
        if (Objects.isNull(inputStream)) {
            inputStream = classLoader.getResourceAsStream("template/" + templateName);
        }
/*        if (Objects.isNull(inputStream)) {
            throw new TemplateNotFoundException("下载模板没有找到，请核对后重试");
        }*/
        Assert.isTrue(StringUtils.isNotNull(inputStream), "下载模板没有找到，请核对后重试");
        return inputStream;
    }



    /**
     *
     * @Author ljy
     * @Description 优化后的导出方法，支持高性能导出
     * @Date 16:02 2024/9/9
     * @param response
     * @param templateEmun
     * @param fileName
     * @param exportList
     **/
    public static void exportExcelBetter(HttpServletResponse response, TemplateEmun templateEmun, String fileName, List exportList) throws IOException {
        // 使用流式写入
        OutputStream outputStream = getOutputStream(response, templateEmun.getExportTypeEnum(), fileName);
        // 关闭自动流关闭
        ExcelWriterBuilder excelWriterBuilder = EasyExcel.write(outputStream)
                .registerConverter(new ExcelLocalDateTimeConverter())
                .registerConverter(new ExcelLocalDateConverter())
                .withTemplate(getTemplate(templateEmun))
                .autoCloseStream(Boolean.FALSE);
        ExcelWriter excelWriter = excelWriterBuilder.build();
        WriteSheet writeSheet = EasyExcel.writerSheet().build();
        FillConfig fillConfig = FillConfig.builder().forceNewRow(Boolean.TRUE).build();
        // 分批写入数据
        // 每批写入的数量
        int batchSize = 5000;
        for (int i = 0; i < exportList.size(); i += batchSize) {
            int end = Math.min(i + batchSize, exportList.size());
            List<?> batchList = exportList.subList(i, end);
            excelWriter.fill(batchList, fillConfig, writeSheet);
        }
        // 手动关闭流
        excelWriter.finish();
        outputStream.close();
    }



   /**
    *
     * @Author ljy
     * @Description 
     * @Date 14:40 2024/9/12 
     * @param file
     * @param templateEmun
     * @param fileName
     * @param exportList 
     **/
    public static void exportExcelFile(File file, TemplateEmun templateEmun, String fileName, List exportList) throws IOException {
        // 使用流式写入
        OutputStream outputStream = new FileOutputStream(file);
        // 关闭自动流关闭
        ExcelWriterBuilder excelWriterBuilder = EasyExcel.write(outputStream)
                .registerConverter(new ExcelLocalDateTimeConverter())
                .registerConverter(new ExcelLocalDateConverter())
                .withTemplate(getTemplate(templateEmun))
                .autoCloseStream(Boolean.FALSE);
        ExcelWriter excelWriter = excelWriterBuilder.build();
        WriteSheet writeSheet = EasyExcel.writerSheet().build();
        FillConfig fillConfig = FillConfig.builder().forceNewRow(Boolean.TRUE).build();
        // 分批写入数据
/*        int batchSize = 5000;
        for (int i = 0; i < exportList.size(); i += batchSize) {
            int end = Math.min(i + batchSize, exportList.size());
            List<?> batchList = exportList.subList(i, end);

        }*/
        excelWriter.fill(exportList, fillConfig, writeSheet);
        // 手动关闭流
        excelWriter.finish();
        outputStream.close();
    }


    /**
     * @param response
     * @param templateEmun
     * @param fileName   下载文件名
     * @param exportList 导出的数据
     * @Author JH
     * @Description
     * @Date 15:56 2022/10/27
     **/
    public static void exportExcel(HttpServletResponse response, TemplateEmun templateEmun, String fileName, List exportList) throws IOException {
        exportExcel(response, null, templateEmun, fileName, exportList);
    }

    /**
     * @param response
     * @param writeHandler 单元格处理类
     * @param templateEmun
     * @param fileName     下载文件名
     * @param exportList   导出的数据
     * @Author JH
     * @Description
     * @Date 15:56 2022/10/27
     **/
    public static void exportExcel(HttpServletResponse response, WriteHandler writeHandler, TemplateEmun templateEmun, String fileName, List exportList) throws IOException {
        OutputStream outputStream = getOutputStream(response, templateEmun.getExportTypeEnum(), fileName);
        ExcelWriterBuilder excelWriterBuilder = EasyExcel.write(outputStream).registerConverter(new ExcelLocalDateTimeConverter()).registerConverter(new ExcelLocalDateConverter())
                .withTemplate(getTemplate(templateEmun))
                .autoCloseStream(Boolean.TRUE);
        if (writeHandler != null) {
            excelWriterBuilder.registerWriteHandler(writeHandler);
        }

        ExcelWriter excelWriter = excelWriterBuilder.build();
        WriteSheet writeSheet = EasyExcel.writerSheet().build();
        FillConfig fillConfig = FillConfig.builder().forceNewRow(Boolean.TRUE).build();
        excelWriter.fill(exportList, fillConfig, writeSheet);
        excelWriter.finish();
    }

    /**
     * @param inputstream
     * @param tclass
     * @param rowNum      表头所在行
     * @return java.util.List<T>
     * @Author JH
     * @Description
     * @Date 16:50 2022/10/27
     **/
    public static <T> List<T> readExcel(InputStream inputstream, Class<T> tclass, int rowNum) throws InstantiationException, IllegalAccessException {
        return EasyExcel.read(inputstream, tclass, new ReadExcelListener(tclass)).head(tclass).registerConverter(new ExcelLocalDateTimeConverter())
                .sheet().headRowNumber(rowNum).doReadSync();
    }


    /**
     *
     * @Author ljy
     * @Description 分批次读取
     * @Date 10:37 2024/9/11
     * @param inputstream
     * @param tclass
     * @param rowNum
     * @return java.util.List<T>
     **/
    public static <T> List<T> readExcelBatch(InputStream inputstream, Class<T> tclass, int rowNum) throws InstantiationException, IllegalAccessException {
        List<T> resultList = new ArrayList<>();
        List<T> all = new ArrayList<>();
        EasyExcel.read(inputstream, tclass, new ReadExcelListener<T>(tclass) {
            @Override
            public void invoke(T data, AnalysisContext context) {
                resultList.add(data);
                if (resultList.size() >= 5000) {
                    // 处理当前批次数据
                    processBatch(resultList, all);
                    resultList.clear();
                }
            }
        })
                .head(tclass)
                .registerConverter(new ExcelLocalDateTimeConverter())
                .sheet()
                .headRowNumber(rowNum)
                .doRead();
        // 处理剩余数据
        if (!resultList.isEmpty()) {
            processBatch(resultList, all);
        }
        return all;
    }

    private static <T> void processBatch(List<T> resultList, List<T> all) {
        all.addAll(resultList);
    }


    /**
     * @Author lx
     * @Date 上午10:01 2024/8/5
     * @param inputstream
     * @param tclass
     * @param headerRowNumber 表头所在行
     * @param startRow  数据所在行
     * @return java.util.List<T>
     **/
    public static <T> List<T> readExcel(InputStream inputstream, Class<T> tclass, int headerRowNumber, int startRow) throws InstantiationException, IllegalAccessException {
        ReadExcelListener readExcelListener = new ReadExcelListener(tclass, headerRowNumber, startRow);
        EasyExcel.read(inputstream).headRowNumber(headerRowNumber).head(tclass).registerReadListener(readExcelListener).registerConverter(new ExcelLocalDateTimeConverter())
        .sheet().doReadSync();
        return readExcelListener.getList();
    }

    /**
     * @param inputstream
     * @param tclass
     * @param rowNum      表头所在行
     * @param sheetName   sheet名称
     * @return java.util.List<T>
     * @Author JH
     * @Description
     * @Date 16:50 2022/10/27
     **/
    public static <T> List<T> readExcelSheet(InputStream inputstream, Class<T> tclass, int rowNum, String sheetName) throws InstantiationException, IllegalAccessException {
        return EasyExcel.read(inputstream).headRowNumber(rowNum).head(tclass).registerReadListener(new ReadExcelListener(tclass, rowNum - 1)).registerConverter(new ExcelLocalDateTimeConverter())
                .sheet(sheetName).doReadSync();
    }

现在有一个这样的需求：根据指定一个所属地市的所有电缆数据导出成文件（电缆的数据量达到10万级别哦）

对于这个需求要注意的地方是：

具体实现的思路，先查询出指定所属地市数据，然后再excelWriter.fill填充到excel表格，最后响应。

对于庞大的数据量接口要保证接口响应不能太久，要避免OOM

因此在实现过程中可以采用分批次查询，分批次写入excel表格，最后将每个批次的excel文件放到一个压缩文件夹里面，最后一起再一起响应。

分析工具类里面的方法：方法的主要目的是将一个数据列表导出为一个 Excel 文件，使用指定的模板和格式化选项。它通过流式写入的方式高效地处理数据，并确保在完成后正确关闭资源。

    public static void exportExcelFile(File file, TemplateEmun templateEmun, String fileName, List exportList) throws IOException {
        // 使用流式写入
        OutputStream outputStream = new FileOutputStream(file);
        // 关闭自动流关闭
        ExcelWriterBuilder excelWriterBuilder = EasyExcel.write(outputStream)
                .registerConverter(new ExcelLocalDateTimeConverter())
                .registerConverter(new ExcelLocalDateConverter())
                .withTemplate(getTemplate(templateEmun))
                .autoCloseStream(Boolean.FALSE);
        ExcelWriter excelWriter = excelWriterBuilder.build();
        WriteSheet writeSheet = EasyExcel.writerSheet().build();
        FillConfig fillConfig = FillConfig.builder().forceNewRow(Boolean.TRUE).build();
        excelWriter.fill(exportList, fillConfig, writeSheet);
        // 手动关闭流
        excelWriter.finish();
        outputStream.close();
    }

  1. 创建输出流:

    OutputStream outputStream = new FileOutputStream(file);
    • 使用 FileOutputStream 创建一个输出流，以便将数据写入指定的 Excel 文件。

  2. 构建 ExcelWriter:

    ExcelWriterBuilder excelWriterBuilder = EasyExcel.write(outputStream)
        .registerConverter(new ExcelLocalDateTimeConverter())
        .registerConverter(new ExcelLocalDateConverter())
        .withTemplate(getTemplate(templateEmun))
        .autoCloseStream(Boolean.FALSE);
    • 使用 EasyExcel 库的 write 方法创建一个 ExcelWriterBuilder。
    • 注册了两个转换器：ExcelLocalDateTimeConverter 和 ExcelLocalDateConverter，用于处理日期和时间格式。
    • 使用指定的模板（通过 getTemplate(templateEmun) 获取）来格式化 Excel 文件。
    • 设置 autoCloseStream 为 false，表示在写入完成后不会自动关闭输出流。

  3. 构建写入工作表:

    WriteSheet writeSheet = EasyExcel.writerSheet().build();
    • 创建一个 WriteSheet 对象，表示要写入的工作表。

  4. 配置填充设置:

    FillConfig fillConfig = FillConfig.builder().forceNewRow(Boolean.TRUE).build();
    • 创建一个 FillConfig 对象，设置 forceNewRow 为 true，表示在填充数据时强制换行。

  5. 填充数据:

    excelWriter.fill(exportList, fillConfig, writeSheet);
    • 使用 excelWriter 将 exportList 中的数据填充到指定的工作表中。

  6. 关闭流:

    excelWriter.finish();
outputStream.close();
    • 调用 finish() 方法完成写入操作，并手动关闭输出流，确保资源被释放

具体业务使用：

 /**
    *
     * @Author ljy
     * @Description 数据导出成文件
     * @Date 14:54 2024/9/12
     * @param city      所属地市
     * @param type      选择要到处的数据类型
     * @param response  响应体
     **/
    @GetMapping("/export/all")
    public void exportDataToExcelAll(@RequestParam(value = "city", required = true)String city,
                                     @RequestParam(value = "type", required = true)String type,
                                     HttpServletResponse response) throws IOException {
        accountCableService.exportDataToExcelAll(city, type, response);
    }
public void exportDataToExcelAll(String city, String type, HttpServletResponse response) throws IOException {
        ExcelExportObjectEnum exportObjectEnum = ExcelExportObjectEnum.ofByCode(type);
        Assert.notNull(exportObjectEnum, "没找到该类型对应的模板");
        switch (exportObjectEnum){
            case CABLE:
                commonService.exportDataToExcelCable(city, response);
                break;
            case CABLE_SECTION:
                commonService.exportDataToExcelCableSection(city, response);
                break;
            case CABLE_TERMINAL:
                commonService.exportDataToExcelCableTerminal(city, response);
                break;
            case LINE_JOINT:
                commonService.exportDataToExcelCableLineJoint(city, response);
                break;
            case LINE:
                commonService.exportDataToExcelCableLine(city, response);
                break;
            case DKX:
                commonService.exportDataToExcelDkx(city, response);
                break;
            default:

        }
public void exportDataToExcelCable(String city, HttpServletResponse response) throws IOException {
        // 当前页码
        int pageNum = 1;
        int j = 0;
        int pageSize = 8000;
        ExportExcelRequestVO vo = new ExportExcelRequestVO();
        vo.setCity(city);
        vo.setPageNum(pageNum);
        vo.setPageSize(pageSize);
        PageResult<AccountCable> pageResult = iAccountCableCrud.findCableListAll(vo);
        long total = pageResult.getTotal();
        int pages = (int) Math.ceil((double) total / pageSize);
        // 创建一个临时文件用于存储压缩文件
        File zipFile = File.createTempFile("cables", ".zip");
        try (ZipOutputStream zos = new ZipOutputStream(new FileOutputStream(zipFile))) {
            for (int i = 1; i <= pages; i++) {
                vo.setPageNum(i);
                List<AccountCable> list = iAccountCableCrud.findCableListAll(vo).getData();
                // 创建每个Excel文件
                File tempExcelFile = File.createTempFile("cable_page_" + j, ".xlsx");
                EasyExcelUtil.exportExcelFile(tempExcelFile, TemplateEmun.CABLE_ACCOUNT_ALL_TEMPLATE, "电缆记录表", list);
                // 将Excel文件添加到压缩文件中
                try (FileInputStream fis = new FileInputStream(tempExcelFile)) {
                    ZipEntry zipEntry = new ZipEntry(tempExcelFile.getName());
                    zos.putNextEntry(zipEntry);
                    byte[] buffer = new byte[1024];
                    int length;
                    while ((length = fis.read(buffer)) >= 0) {
                        zos.write(buffer, 0, length);
                    }
                    zos.closeEntry();
                }
                // 删除临时Excel文件
                tempExcelFile.delete();
                j++;
            }
        }
        // 设置响应头并发送压缩文件
        response.setContentType("application/zip");
        response.setHeader("Content-Disposition", "attachment; filename=cables.zip");
        try (FileInputStream fis = new FileInputStream(zipFile);
             OutputStream os = response.getOutputStream()) {
            byte[] buffer = new byte[1024];
            int length;
            while ((length = fis.read(buffer)) >= 0) {
                os.write(buffer, 0, length);
            }
        }
        // 删除临时压缩文件
        zipFile.delete();
    }

分析核心业务方法exportDataToExcelCable()：

这个方法实现了从数据库中提取电缆记录数据，并将其导出为一个包含多个 Excel 文件的 ZIP 文件，供用户下载。

  1. 获取数据：

    • 使用 iAccountCableCrud.findCableListAll(vo) 方法获取电缆记录的总数和分页信息。

  2. 创建临时 ZIP 文件：

    • 创建一个临时 ZIP 文件，用于存储生成的 Excel 文件。

  3. 分页处理：

    • 根据总记录数和每页大小计算总页数。
    • 循环遍历每一页，获取电缆记录列表。

  4. 生成 Excel 文件：

    • 为每一页创建一个临时 Excel 文件，并使用 EasyExcelUtil.exportExcelFile 方法将数据写入该文件。

  5. 将 Excel 文件添加到 ZIP：

    • 将生成的 Excel 文件读取并写入到 ZIP 文件中。

  6. 清理临时文件：

    • 删除每个生成的临时 Excel 文件。

  7. 设置响应头并发送 ZIP 文件：

    • 设置 HTTP 响应的内容类型和文件名。
    • 将 ZIP 文件的内容写入 HTTP 响应流中，发送给客户端。

  8. 删除临时 ZIP 文件：

    • 在完成文件发送后，删除临时 ZIP 文件以释放资源

程序员_小李z
关注
java多线程导出excel（千万级别）优化
12-05
轻松解决普通poi形式导出Excel的中出现的栈溢出问题，此资源可实现千万级数据分批导出csv文件，csv大数据量导出(千万级别，不会内存溢出)，多线程导出 ，生产环境已经很稳定的使用着
百万级数据excel导出功能如何实现？
lisu061714112的专栏
02-04 4609
最近我做过一个MySQL百万级别数据的excel导出功能，已经正常上线使用了。这个功能挺有意思的，里面需要注意的细节还真不少，现在拿出来跟大家分享一下，希望对你会有所帮助。原始需求：用户在UI界面上点击全部导出按钮，就能导出所有商品数据。咋一看，这个需求挺简单的。但如果我告诉你，导出的记录条数，可能有一百多万，甚至两百万呢？这时你可能会倒吸一口气。如果同步导数据，接口很容易超时。如果把所有数据一次性装载到内存，很容易引起OOM。数据量太大sql语句必定很慢。
java实现大数据量快速导入
最新发布
weixin_46516173的博客
08-22 367
java实现大数据量快速导入。
Java导出大批量数据(分批查询导出篇)
夜の雨的博客
09-05 9154
​上篇文章介绍了 java导出文件格式篇xls,xlsx,csv 本篇介绍下 大批量数据的导出思路和方法 导出数据慢的原因: 一次性查询太多数据 sql会很慢 太多数据导出处理很慢 这里我讲解下分批查询和分批导出分批查询方法 一: 根据数据量 分割每一部分数据 二: 根据查询时间间隔 分割为每一天一个时间段 ​
java csv大数据量导出(千万级别，不会内存溢出)
11-19
java csv大数据量导出(千万级别，不会内存溢出)，多线程导出 ，生产环境已经很稳定的使用着
POI实现导出Excel数据工具类
小范的博客
09-28 409
项目中很多地方需要导出excel数据，因此需要将导出excel数据封装成工具类。实现思路:      1、将查询结果List以及T作为入参。      2、新建一个注解，在T对象需要生成表格数据的字段加上这个注解。供外部调用的方法:import java.io.IOException; import java.util.List; import javax.servlet.http.HttpSe
C#快速导出Excel文件(3秒可导10万行数据)
09-09
C#快速导出Excel文件，3秒可导10万行数据
java实现百万级别数据导出excel(JPA,hibernate,mybatis三种方式)
热门推荐
hgq0916的博客
05-06 1万+
java实现百万级别数据导出excel，提供了JPA，hibernate,mybatis三种不同的方式来实现
java大批量数据导出excel
weixin_44263023的博客
07-06 1608
百万级数量导出
Java导出大批量数据(文件格式篇xls,xlsx,csv)
夜の雨的博客
09-01 1万+
java导出我准备分为三篇文章介绍文件格式篇xls,xlsx,csv,分批查询导出篇,异步多线程导出篇一起来看看吧Java导出excel文件 我分为了xls,xlsx,csv三个文件格式首先介绍下三种文件格式的优劣导出少量数据 需要表头样式的 采用xlsx文件导出导出大量数据 无表头样式要求 采用csv文件导出。.........
JAVA大量数据导出excel
caijigskg的博客
05-09 1691
背景：因项目需要导出3万行+，90列+的数据到excel，使用传统的apache poi 直接导出，导致504连接超时无法导出。然后改造方法，异步导出。
Spring框架实现Excel批量导入数据
04-13
在企业级应用开发中，数据管理是一个至关重要的环节。Spring框架作为Java后端开发的主流框架，提供了丰富的功能来处理各种业务场景。本教程将详细讲解如何利用Spring框架实现Excel数据的批量导入，以提高数据录入...
通过EasyExcel+线程池实现百万级数据从Excel导入到数据库
03-26
在处理大量数据导入数据库的场景中，使用...通过以上步骤，可以利用EasyExcel和线程池实现百万级数据从Excel导入到数据库的功能。这种方式可以提高数据处理的效率，减少内存占用，并且能够更好地利用多核CPU的优势。
批量导出CVS-千万级数据处理
11-05
使用POI的SXSSFWorkbook类，我们可以实现流式写入Excel文件，只保留最近100行数据在内存中，其余数据写入磁盘，这样极大地降低了内存消耗。以下是基本步骤： 1. 创建`SXSSFWorkbook`实例，设置保留行数，例如`...
java配置文件动态配置excel导出动态数据并发送email
04-09
这个过程涉及到几个关键的技术点，包括Java配置文件的使用、Excel的数据动态生成、以及邮件的发送。接下来，我们将深入探讨这些知识点。 首先，**Java配置文件**通常用来存储应用的配置信息，如数据库连接字符串、...
java批量文件打包成压缩成zip下载和大量数据导出excel时的处理方法
zzzgd_666的博客
06-25 7059
对于我们来说,java导出数据成excel或其他数据文件,或者下载资源是开发中的家常便饭, 但是在导出的时候,如果点击一个按钮导出几百万条数据,如果不作处理的话很可能会出现一系列的问题. 这里介绍打包成zip压缩包下载 针对大量数据导出excel, 这里有几种办法: 1. 每到一定数量就分成一个sheet 2. 每到一定数量分成一个excel,压缩成zip包打包下载 3. 控制导出的数据量...
JAVA百万条数据导出
taoCSD的博客
03-22 367
@RequestMapping("/zz") public ResponseEntity export(){ List<Map<String,Object>> data = new ArrayList<Map<String,Object>>(); LinkedHashMap<String, Object> keyMap = new LinkedHashMap<>(); keyMap
【实战】EasyExcel实现百万级数据导入导出
勤于笔记，成于点滴。
07-02 3898
最近接到一个百万级excel数据导入导出的需求，大概就是我们在进行公众号API群发的时候，需要支持500w以上的openid进行群发，并且可以提供发送openid数据的导出功能。可能有的同学会说，这么大的数据量发送为啥不用标签发送呢。哈哈，标签发送需要提前打标签微信限制50个一批，我们开10个线程也是需要3个小时左右才能打完，这样肯定不能满足客户需求。如果用openid群发就不一样了，微信支持10000个每批，基本上我开5个线程同时发送差不多几分钟搞定。所以，问题就来到了百万级excel数据的导入与导出啦。
Java导出Excel列数过多，大数据量导出速度过慢解决办法
weixin_43682323的博客
03-06 7073
在日常开发中，数据导出到Excel是非常常见的操作，尤其是在开发管理类的系统时，导出报表等相关数据表格会因为数据量过大，列数过多从而导致导出耗时过多甚至将服务器CPU吃满，内存溢出，导致服务宕机，这是非常危险的。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值