Java百万数据导出Excel#

1
/**
2
 * 导出Excel(先查后写)，<br>
3
 * 注意：实际应用中，pageSize参数不应对外开放，此处为方便测试，或pageSize需要设置上限，防止恶意用户传一个很大的pageSize值，而撑满内存
4
 * @param response 响应
5
 * @param pageSize 页大小
6
 * @throws IOException
7
 */
8
@GetMapping("/exportExcel")
9
public void exportExcel(HttpServletResponse response,
10
                        @RequestParam(value = "pageSize", defaultValue = "10000") int pageSize) throws IOException {
11
    XExcelUtil.download(response, "测试").pageSize(pageSize).pageExcelWriter(Demo.class, page -> demoService.lambdaQuery().page(page));
12
}

1
/**
2
 * 创建并初始化用于Excel文件下载的工具类实例
3
 * 作用：配置HTTP响应头信息，指定Excel文件下载的相关参数（文件名、格式等）
4
 *
5
 * @param response HTTP响应对象，用于设置响应头信息（如文件名、内容类型）
6
 * @param fileNamePrefix 下载文件名的前缀（用户自定义部分，后续会拼接时间戳和文件后缀）
7
 * @return 初始化完成的XExcelUtil实例，可用于后续向Excel中填充数据
8
 * @throws UnsupportedEncodingException 当URL编码过程中使用的UTF-8编码不被支持时抛出
9
 */
10
public static XExcelUtil download(HttpServletResponse response, String fileNamePrefix) throws UnsupportedEncodingException {
11
    // 创建Excel工具类实例，后续可用于填充数据、写入文件内容
12
    XExcelUtil excelUtil = new XExcelUtil();
13

14
    // 将HTTP响应对象绑定到工具类，便于后续通过工具类直接操作响应流
15
    excelUtil.httpServletResponse = response;
16

17
    // 构建完整文件名：前缀 + 当前时间戳 + .xlsx后缀
18
    // xFormat("yyyyMMddHHmmss")：将时间格式化为"年月日时分秒"字符串，确保文件名唯一性
19
    excelUtil.fileName = fileNamePrefix + "_" + Date.xNow().xFormat("yyyyMMddHHmmss") + ".xlsx";
20

21
    // 设置响应内容类型：对应Excel 2007+格式(xlsx)的MIME类型
22
    // MIME类型说明：application/vnd.openxmlformats-officedocument.spreadsheetml.sheet是Office Open XML格式的Excel文件标准MIME类型
23
    response.setContentType("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
24

25
    // 设置响应字符编码为UTF-8，确保文件名等中文内容正确显示
26
    response.setCharacterEncoding("utf-8");
27

28
    // 对文件名进行URL编码处理（解决中文文件名乱码问题）
29
    // 1. URLEncoder.encode：将文件名编码为UTF-8格式的URL安全字符串
30
    // 2. replaceAll("\\+", "%20")：因为URLEncoder会将空格编码为"+"，而HTTP标准中推荐用"%20"表示空格，此处替换确保兼容性
31
    String downloadFileName = URLEncoder.encode(excelUtil.fileName, "UTF-8").replaceAll("\\+", "%20");
32

33
    // 设置响应头Content-disposition：告知浏览器以附件形式下载文件
34
    // filename*=utf-8'': 是RFC 5987标准的编码格式，明确指定文件名编码为UTF-8，解决中文文件名乱码问题
35
    response.setHeader("Content-disposition", "attachment;filename*=utf-8''" + downloadFileName);
36

37
    // 返回初始化完成的XExcelUtil实例，调用方后续可使用该实例进行Excel内容的填充和写入
38
    return excelUtil;
39
}

1
/**
2
 * 分页查询数据并写入Excel文件（支持自动分sheet页）
3
 *
4
 * @param outputStream  Excel输出流（如HTTP响应流、文件输出流等）
5
 * @param fileName      文件名（用于日志记录，区分不同Excel任务）
6
 * @param head          Excel表头对应的实体类Class（EasyExcel通过该类生成表头）
7
 * @param pageSize      每页查询的数据量
8
 * @param pageFunction  分页查询函数（接收分页参数，返回查询结果页），通常用于数据库分页查询
9
 * @param <T>           Excel数据行对应的实体类泛型
10
 */
11
private static <T> void pageExcelWriter(
12
       OutputStream outputStream,
13
        String fileName,
14
        Class<T> head,
15
        long pageSize,
16
        UnaryOperator<IPage<T>> pageFunction
17
) {
18
    long start = System.currentTimeMillis(); // 记录任务开始时间，用于统计总耗时
19
    log.debug("fileName:{}, excel writer start", fileName); // 记录任务开始日志
20
    // try-with-resources自动管理ExcelWriter资源，确保使用后关闭（避免内存泄漏）
21
    try (ExcelWriter excelWriter = EasyExcel.write(outputStream, head).build()) {
22
        IPage<T> page = null; // 分页查询结果对象，初始为null（表示首次查询）
23
        WriteSheet writeSheet = EasyExcel.writerSheet(0).build(); // 初始sheet（编号从0开始）
24
        // 循环分页查询并写入Excel，直到所有数据页处理完成
25
        do {
26
            // 记录当前页查询开始时间，用于统计单页查询耗时
27
            long pageSearchStartTime = System.currentTimeMillis();
28

29
            // 根据是否为首次查询构造分页参数：
30
            // - 首次查询（page为null）：创建第1页，每页大小pageSize
31
            // - 后续查询：当前页+1，保持页大小不变，复用总记录数（避免重复查询总条数，提升性能）
32
            page = pageFunction.apply(
33
                page == null ?
34
                new Page<>(1, pageSize) :  // 首次查询：第1页，页大小pageSize
35
                new Page<>(page.getCurrent() + 1, page.getSize(), page.getTotal(), false) // 后续查询：下一页，禁用count查询
36
            );
37
            // 记录当前页数据写入开始时间，用于统计单页写入耗时
38
            long pageExcelWriteStartTime = System.currentTimeMillis();
39

40
            // 计算当前数据应写入的sheet编号：
41
            // 公式：(当前页号 * 每页大小) / 单sheet最大行数 → 确定当前累积记录数对应哪个sheet
42
            // （EXCEL_SHEET_ROW_MAX_SIZE为常量，如65535行，避免单sheet行数超Excel限制）
43
            writeSheet.setSheetNo((int) (page.getCurrent() * page.getSize() / EXCEL_SHEET_ROW_MAX_SIZE));
44

45
            // 将当前页数据写入Excel的指定sheet
46
            excelWriter.write(page.getRecords(), writeSheet);
47
            // 打印当前页处理日志：包含文件名、总记录数、页大小、总页数、当前页号、sheet编号及耗时统计
48
            log.debug(
49
                "fileName:{}, total:{}, pageSize:{}, totalPage:{}, pageNo:{}, sheetNo:{}, " +
50
                "pageSearchTime:{}ms, pageExcelWriterTime:{}ms",
51
                fileName,
52
                page.getTotal(),  // 总记录数
53
                page.getSize(),   // 每页大小
54
                page.getPages(),  // 总页数
55
                page.getCurrent(), // 当前页码
56
                writeSheet.getSheetNo(), // 当前写入的sheet编号
57
                pageExcelWriteStartTime - pageSearchStartTime, // 当前页查询耗时（ms）
58
                System.currentTimeMillis() - pageExcelWriteStartTime // 当前页写入耗时（ms）
59
            );
60
        } while (page.getCurrent() < page.getPages()); // 循环条件：当前页码 < 总页数（是否还有下一页）
61
    } // ExcelWriter在try-with-resources结束时自动关闭，释放资源
62
    // 记录任务总耗时日志
63
    log.debug(
64
        "fileName:{}, excel writer done, totalTime:{}ms",
65
        fileName,
66
        System.currentTimeMillis() - start
67
    );
68
}

1
/**
2
 * 导出Excel[下载速度可能更快]（并发查询，串行写入）<br>
3
 * 注意：实际应用中，pageSize和parallelNum参数不应对外开放，此处为方便测试，或pageSize需要设置上限，防止恶意用户传一个很大的pageSize值，而撑满内存。
4
 * @param response 响应
5
 * @param parallelNum 并发查询线程数
6
 * @param pageSize 页大小
7
 * @throws IOException
8
 */
9
@GetMapping("/writeExcelForXParallel")
10
public void writeExcelForXParallel(HttpServletResponse response,
11
                                  @RequestParam(value = "parallelNum", defaultValue = "3") int parallelNum,
12
                                  @RequestParam(value = "pageSize", defaultValue = "10000") int pageSize) throws IOException {
13
    XExcelUtil.download(response, "测试并发查询导出").parallel(parallelNum).pageSize(pageSize).pageExcelWriter(Demo.class, page -> demoService.lambdaQuery().page(page));
14
}

1
/**
2
 * 并行分页查询并写入Excel文件（支持自动分Sheet）
3
 *
4
 * @param <T>            Excel数据行对应的Java实体类类型（泛型）
5
 * @param outputStream   Excel文件的输出流（如网络响应流、本地文件流等）
6
 * @param fileName       文件名（用于日志打印，标识当前处理的文件）
7
 * @param head           Excel表头对应的实体类Class（EasyExcel据此解析表头信息）
8
 * @param parallelNum    并行处理数量（控制同时执行的查询/写入任务数）
9
 * @param pageSize       每页查询的数据量大小（单次查询获取的数据条数）
10
 * @param pageFunction   分页查询函数（用户自定义的分页数据获取逻辑，如从数据库查数据）
11
 * @throws ExecutionException   并行处理中可能抛出的异常（如任务执行失败）
12
 * @throws InterruptedException 并行处理被中断时抛出的异常
13
 */
14
private static <T> void pageExcelWriterParallel(
15
        OutputStream outputStream,
16
        String fileName,
17
        Class<T> head,
18
        int parallelNum,
19
        long pageSize,
20
        UnaryOperator<IPage<T>> pageFunction
21
) throws ExecutionException, InterruptedException {
22
    // 记录开始时间，用于统计总耗时
23
    long start = System.currentTimeMillis();
24
    log.debug("fileName:{}, excel writer start", fileName);
25
    // 使用try-with-resources自动管理ExcelWriter资源，确保最终关闭流释放资源
26
    try (ExcelWriter excelWriter = EasyExcel.write(outputStream, head).build()) {
27
        // 创建初始Sheet（默认第0个Sheet，名称为"Sheet0"）
28
        final WriteSheet writeSheet = EasyExcel.writerSheet(0, "Sheet0").build();
29
        // 1. 初始化基础分页参数（获取总记录数并设置分页大小）
30
        // 注：先调用pageFunction查询第1页、size=0的数据，目的是获取总记录数（total）
31
        // 然后通过setSize(pageSize)设置实际分页大小，从而计算总页数
32
        IPage<T> basePage = pageFunction.apply(new Page<>(1, 0))  // 查总记录数（size=0表示仅获取总数，不返回数据）
33
                                        .setSize(pageSize);       // 设置实际分页大小，计算总页数
34
        log.debug("fileName:{}, 分页查询初始化完成，总记录数:{}, 每页条数:{}, 总页数:{}",
35
                  fileName, basePage.getTotal(), basePage.getSize(), basePage.getPages());
36
        // 2. 通过SlidingWindow实现并行处理：多线程并行查询分页数据并写入Excel
37
        // SlidingWindow是一个并行处理工具，用于控制并行任务的发送（查询）和接收（写入）
38
        SlidingWindow.<IPage<T>>create(
39
                new TypeReference<IPage<T>>(){},  // 泛型类型引用（指定窗口处理的数据类型）
40
                parallelNum,                       // 并行处理数量（同时执行的任务数）
41
                basePage.getPages()                // 总任务数（等于总页数，即需要查询的页数）
42
            )
43
            // 发送窗口：定义如何并行获取分页数据（并行执行查询任务）
44
            .sendWindow(pageNo -> {  // pageNo：当前处理的页码（从1开始）
45
                long pageSearchStartTime = System.currentTimeMillis();
46
                // 调用用户提供的pageFunction查询指定页码的数据
47
                // Page参数：current=pageNo（当前页码），size=pageSize（每页条数）
48
                IPage<T> page = pageFunction.apply(new Page<>(pageNo, basePage.getSize()));
49
                log.debug("fileName:{}, [读]pageNo:{}, total:{}, pageSize:{}, pageSearchTime:{}ms",
50
                          fileName, pageNo, page.getTotal(), page.getSize(),
51
                          System.currentTimeMillis() - pageSearchStartTime);
52
                return page;  // 将查询到的分页数据传递给接收窗口处理
53
            })
54
            // 接收窗口：定义如何处理查询到的分页数据（并行执行写Excel任务）
55
            .receiveWindow(page -> {  // page：sendWindow返回的分页数据
56
                long pageWriteStartTime = System.currentTimeMillis();
57
                // TODO: 假设EXCEL_SHEET_ROW_MAX_SIZE是类中定义的常量（如Excel单个Sheet最大行数限制，如65535）
58
                // 计算当前页数据应写入的Sheet编号（通过累计记录数/单Sheet最大行数）
59
                // 累计记录数 = (页码-1)*pageSize + 当前页记录数（这里简化为 pageNo * pageSize，需根据实际逻辑确认）
60
                long cumulativeRecords = (page.getCurrent() - 1) * page.getSize() + page.getRecords().size();
61
                int sheetNo = (int) (cumulativeRecords / EXCEL_SHEET_ROW_MAX_SIZE);  // 计算Sheet编号（从0开始）
62
                writeSheet.setSheetNo(sheetNo);  // 设置当前写入的Sheet编号
63
                writeSheet.setSheetName("Sheet" + sheetNo);  // 设置Sheet名称
64
                // 将当前分页数据写入Excel的指定Sheet
65
                excelWriter.write(page.getRecords(), writeSheet);
66

67
                log.debug("fileName:{}, [写]pageNo:{}, sheetNo:{}, pageWriteTime:{}ms",
68
                          fileName, page.getCurrent(), sheetNo,
69
                          System.currentTimeMillis() - pageWriteStartTime);
70
            })
71
            // 启动并行处理流程
72
            .start();
73
    }  // ExcelWriter会在此处自动关闭，释放资源
74
    // 记录任务总耗时
75
    log.debug("fileName:{}, excel writer done, totalTime:{}ms",
76
              fileName, System.currentTimeMillis() - start);
77
}

1
/**
2
 * 导出Excel（并发查询，串行写入）<br>
3
 * 注意：实际应用中，pageSize和parallelNum参数不应对外开放，此处为方便测试，或pageSize需要设置上限，防止恶意用户传一个很大的pageSize值，而撑满内存。
4
 * @param response 响应
5
 * @param parallelNum 并发查询线程数
6
 * @param pageSize 页大小
7
 * @throws IOException
8
 * @throws InterruptedException
9
 */
10
@GetMapping("/writeExcelForParallel")
11
public void writeExcelForParallel(HttpServletResponse response,
12
                              @RequestParam(value = "parallelNum", defaultValue = "3") int parallelNum,
13
                              @RequestParam(value = "pageSize", defaultValue = "10000") int pageSize) throws IOException, InterruptedException {
14
    LambdaQueryWrapper<Demo> queryWrapper = Wrappers.lambdaQuery(Demo.class);
15
    demoService.writeExcelForParallel(excelOutput(response, "测试"), parallelNum, pageSize, queryWrapper);

1
/**
2
 * 核心并行Excel写入实现（私有工具方法）
3
 * <p>使用并行方式查询数据页并写入Excel，支持自动分sheet（当单sheet行数超限）</p>
4
 * @param excelWriter EasyExcel的写入器对象（负责Excel文件生成）
5
 * @param parallelNum 并行处理线程数
6
 * @param totalPage 总页数（需查询的数据总页数）
7
 * @param pageListFunction 函数式接口：根据页码获取对应页数据列表
8
 * @param <T> 数据实体类型
9
 * @throws InterruptedException 当并行处理被中断时抛出
10
 */
11
private static <T> void pageExcelWriterParallel(ExcelWriter excelWriter, int parallelNum, long totalPage, LongFunction<List<T>> pageListFunction) throws InterruptedException {
12
    // try-with-resources自动关闭excelWriter，确保资源释放（无论是否发生异常）
13
    try (excelWriter) {
14
        // 1. 无数据时（总页数<=0），写入空数据（仅保留表头）
15
        if (totalPage <= 0) {
16
            excelWriter.write(Collections.emptyList(), EasyExcel.writerSheet().build());
17
            return;
18
        }
19
        // 2. 初始化计数器和Sheet配置
20
        AtomicLong count = new AtomicLong(); // 累计写入记录数，用于分sheet判断
21
        WriteSheet writeSheet = EasyExcel.writerSheet(1, "Sheet1").build(); // 初始sheet配置（序号1，名称"Sheet1"）
22
        // 3. 并行处理数据查询与写入
23
        // ParallelUtil.parallel：创建并行任务（指定泛型类型、并行数、总页数）
24
        // asyncProducer：异步生产者，根据页码并行查询数据页（线程安全的多线程查询）
25
        // syncConsumer：同步消费者，按顺序写入数据到Excel（避免并发写入冲突）
26
        ParallelUtil.parallel(new TypeReference<List<T>>(){}, parallelNum, totalPage)
27
            .asyncProducer(pageListFunction)  // 异步生产数据：调用pageListFunction获取指定页数据
28
            .syncConsumer(pageList -> {       // 同步消费数据：将数据写入Excel
29
                // 计算当前累计写入记录数，动态调整sheet
30
                long currentCount = count.addAndGet(pageList.size());
31
                // EXCEL_SHEET_ROW_MAX_SIZE为常量（如Excel默认单sheet最大65536行），超过则创建新sheet
32
                int sheetNo = (int) (currentCount / EXCEL_SHEET_ROW_MAX_SIZE + 1);
33
                writeSheet.setSheetNo(sheetNo);
34
                writeSheet.setSheetName("Sheet" + sheetNo);
35
                // 将当前数据页写入指定sheet
36
                excelWriter.write(pageList, writeSheet);
37
            }).start(); // 启动并行任务
38
    }
39
}

1
/**
2
 * 多线程批量导出 excel
3
 *
4
 * @param response 用于浏览器下载
5
 * @throws InterruptedException
6
 */
7
public void threadExcel(HttpServletResponse response) {
8
    long start = System.currentTimeMillis();
9
    initQueue();
10
    //异步转同步，等待所有线程都执行完毕返回 主线程才会结束
11
    try {
12
        Queue<Map<String, Object>> queue = queueThreadLocal.get();
13
        CountDownLatch cdl = new CountDownLatch(queue.size());
14
        while (queue.size() > 0) {
15
            asynExportExcelService.excuteAsyncTask(queue.poll(), cdl);
16
        }
17
        cdl.await();
18
        log.info("excel导出完成·······················");
19
        //压缩文件
20
        File zipFile = new File(filePath.substring(0, filePath.length() - 1) + ".zip");
21
        FileOutputStream fos1 = new FileOutputStream(zipFile);
22
        //压缩文件目录
23
        ZipUtils.toZip(filePath, fos1, true);
24
        //发送zip包
25
        ZipUtils.sendZip(response, zipFile);
26
    } catch (Exception e) {
27
        log.error("excel导出异常", e);
28
    } finally {
29
        // 使用完ThreadLocal对象之后清除数据，防止内存泄露
30
        queueThreadLocal.remove();
31
    }
32
    long end = System.currentTimeMillis();
33
    log.info("任务执行完毕共消耗：  " + (end - start) + "ms");
34
}

1
@Async("taskExecutor")
2
public void excuteAsyncTask(Map<String, Object> map, CountDownLatch cdl) {
3
    long start = System.currentTimeMillis();
4
    int currentPage = (int) map.get("page");
5
    int pageSize = (int) map.get("limit");
6
    List<KjGoods> list = kjGoodsMapper.selectList(new QueryWrapper<>());
7
    List subList = new ArrayList(page(list, pageSize, currentPage));
8
    int count = subList.size();
9
    System.out.println("线程：" + Thread.currentThread().getName() + " , 读取数据，耗时 ：" + (System.currentTimeMillis() - start) + "ms");
10
    StringBuilder filePath = new StringBuilder(map.get("path").toString());
11
    filePath.append("线程").append(Thread.currentThread().getName()).append("-")
12
            .append("页码").append(map.get("page")).append(".xlsx");
13
    // 调用导出的文件方法
14
    Workbook workbook = MyExcelExportUtil.getWorkbook("商品数据", "商品", KjGoods.class, subList, ExcelType.XSSF);
15
    File file = new File(filePath.toString());
16
    MyExcelExportUtil.exportExcel2(workbook, file);
17
    long end = System.currentTimeMillis();
18
    System.out.println("线程：" + Thread.currentThread().getName() + " , 导出excel" + map.get("page") + ".xlsx成功 , 导出数据：" + count + " ,耗时 ：" + (end - start) + "ms");
19
    // 执行完线程数减1
20
    cdl.countDown();
21
    System.out.println("剩余任务数  ===========================> " + cdl.getCount());
22
}