SpringBoot系列之集成EasyExcel实现百万级别的数据导入导出实践

Spring Boot 系列：集成 EasyExcel 实现百万级数据导入导出实战

• SpringBoot与微服务实践系列博客
  

本文基于开源项目 springboot-easyexcel-batch 进行解析与扩展，手把手教你如何在 Spring Boot 2.2.1 中集成 Alibaba EasyExcel，轻松实现 百万级数据的导入与导出。

目录

• 项目结构概览
  
• 核心依赖
  
• 百万级导出实战
  
• 百万级导入实战
  
• 性能优化技巧
  
• 常见问题 & 解决方案
  
• 总结
  

项目结构概览

1. springboot-easyexcel-batch
2. ├── src/main/java/com/example/easyexcel
3. │   ├── controller/      # 导入导出接口
4. │   ├── listener/        # 导入监听器
5. │   ├── model/           # 实体类
6. │   ├── service/         # 业务逻辑
7. │   └── Application.java # 启动类
8. └── src/main/resources
9.     ├── application.yml  # 线程池配置
10.     └── templates/       # 前端demo

复制代码

核心依赖

1. <parent>
2.     <groupId>org.springframework.boot</groupId>
3.     spring-boot-starter-parent</artifactId>
4.     <version>2.2.1.RELEASE</version>
5. </parent>
8. <dependency>
9.     <groupId>com.alibaba</groupId>
10.     easyexcel</artifactId>
11.     <version>2.2.11</version>
12. </dependency>

复制代码

百万级导出实战

1️⃣ 场景

需求数据量策略导出用户表100万+分Sheet + 分批查询 + 边查边写2️⃣ 核心代码

1. package com.example.easyexcel.service;
3. import com.alibaba.excel.EasyExcel;
4. import com.alibaba.excel.ExcelWriter;
5. import com.alibaba.excel.write.metadata.WriteSheet;
6. import com.example.easyexcel.model.User;
7. import lombok.extern.slf4j.Slf4j;
8. import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
9. import org.springframework.stereotype.Service;
11. import javax.servlet.http.HttpServletResponse;
12. import java.io.IOException;
13. import java.io.OutputStream;
14. import java.net.URLEncoder;
15. import java.util.ArrayList;
16. import java.util.List;
17. import java.util.concurrent.CompletableFuture;
19. @Service
20. @Slf4j
21. public class ExcelExportService {
23.     private final ThreadPoolTaskExecutor excelExecutor;
24.     private final UserService userService;
26.     // 每个Sheet的数据量
27.     private static final int DATA_PER_SHEET = 100000;
29.     // 每次查询的数据量
30.     private static final int QUERY_BATCH_SIZE = 10000;
32.     public ExcelExportService(ThreadPoolTaskExecutor excelExecutor, UserService userService) {
33.         this.excelExecutor = excelExecutor;
34.         this.userService = userService;
35.     }
37.     /**
38.      * 导出百万级用户数据（优化内存版本）
39.      */
40.     public void exportMillionUsers(HttpServletResponse response, long totalCount) throws IOException {
41.         // 设置响应头
42.         response.setContentType("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
43.         response.setCharacterEncoding("utf-8");
44.         String fileName = URLEncoder.encode("百万用户数据", "UTF-8").replaceAll("\\+", "%20");
45.         response.setHeader("Content-disposition", "attachment;filename*=utf-8''" + fileName + ".xlsx");
46.         response.setHeader("Cache-Control", "no-store, no-cache, must-revalidate");
47.         response.setHeader("Pragma", "no-cache");
48.         response.setDateHeader("Expires", 0);
50.         // 计算总Sheet数
51.         int sheetCount = (int) (totalCount / DATA_PER_SHEET + (totalCount % DATA_PER_SHEET > 0 ? 1 : 0));
52.         log.info("需要生成的Sheet总数：{}", sheetCount);
54.         try (OutputStream os = response.getOutputStream()) {
55.             // 创建ExcelWriter，直接写入响应输出流
56.             ExcelWriter excelWriter = EasyExcel.write(os, User.class).build();
58.             // 用于保证Sheet写入顺序的前一个Future
59.             CompletableFuture<Void> previousFuture = CompletableFuture.completedFuture(null);
61.             for (int sheetNo = 0; sheetNo < sheetCount; sheetNo++) {
62.                 final int currentSheetNo = sheetNo;
63.                 long start = currentSheetNo * (long) DATA_PER_SHEET;
64.                 long end = Math.min((currentSheetNo + 1) * (long) DATA_PER_SHEET, totalCount);
66.                 // 每个Sheet的处理依赖于前一个Sheet完成，保证顺序
67.                 previousFuture = previousFuture.thenRunAsync(() -> {
68.                     try {
69.                         log.info("开始处理Sheet {} 的数据（{} - {}）", currentSheetNo, start, end);
70.                         writeSheetData(excelWriter, currentSheetNo, start, end);
71.                         log.info("完成处理Sheet {} 的数据", currentSheetNo);
72.                     } catch (Exception e) {
73.                         log.error("处理Sheet {} 数据失败", currentSheetNo, e);
74.                         throw new RuntimeException("处理Sheet " + currentSheetNo + " 数据失败", e);
75.                     }
76.                 }, excelExecutor);
77.             }
79.             // 等待所有Sheet处理完成
80.             previousFuture.join();
82.             // 完成写入
83.             excelWriter.finish();
84.             log.info("所有Sheet写入完成");
86.         } catch (Exception e) {
87.             log.error("Excel导出失败", e);
88.             throw e;
89.         }
90.     }
92.     /**
93.      * 写入单个Sheet的数据
94.      */
95.     private void writeSheetData(ExcelWriter excelWriter, int sheetNo, long start, long end) {
96.         String sheetName = "用户数据" + (sheetNo + 1);
97.         WriteSheet writeSheet = EasyExcel.writerSheet(sheetNo, sheetName).build();
99.         long totalToQuery = end - start;
100.         int totalWritten = 0;
102.         // 分批查询并写入，每批查询后立即写入，不缓存大量数据
103.         for (long i = 0; i < totalToQuery; i += QUERY_BATCH_SIZE) {
104.             long currentStart = start + i;
105.             long currentEnd = Math.min(start + i + QUERY_BATCH_SIZE, end);
107.             // 调用UserService查询数据
108.             List<User> batchData = userService.findUsersByRange(currentStart, currentEnd);
110.             if (batchData == null || batchData.isEmpty()) {
111.                 log.info("{} - {} 范围没有数据", currentStart, currentEnd);
112.                 break; // 没有更多数据，提前退出
113.             }
115.             // 直接写入这一批数据
116.             excelWriter.write(batchData, writeSheet);
117.             totalWritten += batchData.size();
119.             log.info("Sheet {} 已写入 {} - {} 范围的数据，累计 {} 条",
120.                     sheetName, currentStart, currentEnd, totalWritten);
122.             // 清除引用，帮助GC
123.             batchData = new ArrayList<>();
124.         }
126.         log.info("Sheet {} 写入完成，共 {} 条数据", sheetName, totalWritten);
127.     }
128. }

复制代码

3️⃣ 效果

指标优化前优化后内存峰值1.2GB100MB耗时45s18s百万级导入实战

1️⃣ 场景

需求数据量策略导入用户表100万+分Sheet + 监听器 + 批量插入2️⃣ 监听器和Service（核心）

1. package com.example.easyexcel.listener;
3. import com.alibaba.excel.context.AnalysisContext;
4. import com.alibaba.excel.event.AnalysisEventListener;
5. import com.example.easyexcel.model.User;
6. import com.example.easyexcel.service.UserService;
7. import lombok.extern.slf4j.Slf4j;
9. import java.util.ArrayList;
10. import java.util.List;
11. import java.util.concurrent.atomic.AtomicLong;
13. /**
14. * 用户数据导入监听器（独立类实现）
15. */
16. @Slf4j
17. public class UserImportListener extends AnalysisEventListener<User> {
19.     // 批量保存阈值（可根据内存调整）
20.     private static final int BATCH_SIZE = 5000;
21.    
22.     // 临时存储批次数据
23.     private final List<User> batchList = new ArrayList<>(BATCH_SIZE);
24.    
25.     // 导入结果统计
26.     private final AtomicLong successCount = new AtomicLong(0);
27.     private final AtomicLong failCount = new AtomicLong(0);
28.    
29.     // 业务服务（通过构造器注入）
30.     private final UserService userService;
32.     public UserImportListener(UserService userService) {
33.         this.userService = userService;
34.     }
36.     /**
37.      * 每读取一行数据触发
38.      */
39.     @Override
40.     public void invoke(User user, AnalysisContext context) {
41.         // 数据验证
42.         if (validateUser(user)) {
43.             batchList.add(user);
44.             successCount.incrementAndGet();
45.             
46.             // 达到批次大小则保存
47.             if (batchList.size() >= BATCH_SIZE) {
48.                 saveBatchData();
49.                 // 清空列表释放内存
50.                 batchList.clear();
51.             }
52.         } else {
53.             failCount.incrementAndGet();
54.             log.warn("数据验证失败: {}", user);
55.         }
56.     }
58.     /**
59.      * 所有数据读取完成后触发
60.      */
61.     @Override
62.     public void doAfterAllAnalysed(AnalysisContext context) {
63.         // 处理剩余数据
64.         if (!batchList.isEmpty()) {
65.             saveBatchData();
66.             batchList.clear();
67.         }
68.         log.info("当前Sheet导入结束，成功: {}, 失败: {}", successCount.get(), failCount.get());
69.     }
71.     /**
72.      * 批量保存数据
73.      */
74.     private void saveBatchData() {
75.         try {
76.             // 调用业务层批量保存（带事务）
77.             userService.batchSaveUsers(batchList);
78.             log.debug("批量保存成功，数量: {}", batchList.size());
79.         } catch (Exception e) {
80.             log.error("批量保存失败，数量: {}", batchList.size(), e);
81.             // 失败处理：可记录失败数据到文件或数据库
82.             handleSaveFailure(batchList);
83.         }
84.     }
86.     /**
87.      * 数据验证逻辑
88.      */
89.     private boolean validateUser(User user) {
90.         // 基础字段验证（根据实际业务调整）
91.         if (user == null) return false;
92.         if (user.getId() == null) return false;
93.         if (user.getName() == null || user.getName().trim().isEmpty()) return false;
94.         return true;
95.     }
97.     /**
98.      * 处理保存失败的数据
99.      */
100.     private void handleSaveFailure(List<User> failedData) {
101.         // 实现失败数据的处理逻辑（例如写入失败日志表）
102.         // userService.saveFailedData(failedData);
103.     }
105.     // Getter方法用于统计结果
106.     public long getSuccessCount() {
107.         return successCount.get();
108.     }
110.     public long getFailCount() {
111.         return failCount.get();
112.     }
113. }

复制代码

导入Service类

1. package com.example.easyexcel.service;
3. import com.alibaba.excel.EasyExcel;
4. import com.alibaba.excel.support.ExcelTypeEnum;
5. import com.example.easyexcel.listener.SheetCountListener;
6. import com.example.easyexcel.listener.UserImportListener;
7. import com.example.easyexcel.model.User;
8. import lombok.extern.slf4j.Slf4j;
9. import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
10. import org.springframework.stereotype.Service;
11. import org.springframework.web.multipart.MultipartFile;
13. import java.io.IOException;
14. import java.io.InputStream;
15. import java.util.ArrayList;
16. import java.util.List;
17. import java.util.concurrent.CompletableFuture;
18. import java.util.concurrent.atomic.AtomicLong;
21. /**
22. * 百万级Excel数据导入服务
23. */
24. @Service
25. @Slf4j
26. public class ExcelImportService {
28.     private final ThreadPoolTaskExecutor excelExecutor;
29.     private final UserService userService;
31.     public ExcelImportService(ThreadPoolTaskExecutor excelExecutor, UserService userService) {
32.         this.excelExecutor = excelExecutor;
33.         this.userService = userService;
35.     }
37.     /**
38.      * 多线程导入百万级用户数据（每个Sheet一个线程）
39.      */
40.     public void importMillionUsers(MultipartFile file) throws IOException {
41.         // 1. 保存成临时文件，避免多线程共用 InputStream
42.         java.io.File tmpFile = java.io.File.createTempFile("excel_", ".xlsx");
43.         file.transferTo(tmpFile);          // Spring 提供的零拷贝
44.         tmpFile.deleteOnExit();            // JVM 退出时自动清理
46.         ExcelTypeEnum excelType = getExcelType(file.getOriginalFilename());
48.         // 2. 拿 sheet 数量
49.         int sheetCount;
50.         try (InputStream in = new java.io.FileInputStream(tmpFile)) {
51.             sheetCount = getSheetCount(in);
52.         }
53.         log.info("开始导入，总 Sheet 数: {}", sheetCount);
55.         // 3. 并发读，每个 Sheet 独立 FileInputStream
56.         AtomicLong totalSuccess = new AtomicLong(0);
57.         AtomicLong totalFail    = new AtomicLong(0);
59.         List<CompletableFuture<Void>> futures = new ArrayList<>(sheetCount);
60.         for (int sheetNo = 0; sheetNo < sheetCount; sheetNo++) {
61.             final int idx = sheetNo;
62.             futures.add(CompletableFuture.runAsync(() -> {
63.                 try (InputStream in = new java.io.FileInputStream(tmpFile)) {
64.                     UserImportListener listener = new UserImportListener(userService);
65.                     EasyExcel.read(in, User.class, listener)
66.                             .excelType(excelType)
67.                             .sheet(idx)
68.                             .doRead();
70.                     totalSuccess.addAndGet(listener.getSuccessCount());
71.                     totalFail.addAndGet(listener.getFailCount());
72.                     log.info("Sheet {} 完成，成功: {}, 失败: {}", idx, listener.getSuccessCount(), listener.getFailCount());
73.                 } catch (IOException e) {
74.                     throw new RuntimeException("Sheet " + idx + " 读取失败", e);
75.                 }
76.             }, excelExecutor));
77.         }
79.         CompletableFuture.allOf(futures.toArray(new CompletableFuture[0])).join();
80.         log.info("全部导入完成，总成功: {}，总失败: {}", totalSuccess.get(), totalFail.get());
81.     }
83.     /**
84.      * 获取Excel中的Sheet数量
85.      */
86.     private int getSheetCount(InputStream inputStream) {
87.         SheetCountListener countListener = new SheetCountListener();
88.         EasyExcel.read(inputStream)
89.                 .registerReadListener(countListener)
90.                 .doReadAll();
91.         return countListener.getSheetCount();
92.     }
94.     /**
95.      * 获取Excel文件类型
96.      *
97.      */
98.     public ExcelTypeEnum getExcelType(String fileName) {
99.         if (fileName == null) return null;
100.         if (fileName.toLowerCase().endsWith(".xlsx")) {
101.             return ExcelTypeEnum.XLSX;
102.         } else if (fileName.toLowerCase().endsWith(".xls")) {
103.             return ExcelTypeEnum.XLS;
104.         }
105.         return null;
106.     }
109. }

复制代码

3️⃣ Controller

1. @PostMapping("/import")
2. @ApiOperation("导入用户数据")
3. public ResponseEntity<String> importUsers(@RequestParam("file") MultipartFile file) {
4.     try {
5.         if (file.isEmpty()) {
6.             return ResponseEntity.badRequest().body("请选择要导入的文件");
7.         }
9.         String fileName = file.getOriginalFilename();
10.         ExcelTypeEnum excelType = importService.getExcelType(fileName);
11.         if (excelType == null) {
12.             return ResponseEntity.badRequest().body("不支持的文件类型，文件名：" +  fileName);
13.         }
15.         importService.importMillionUsers(file);
16.         return ResponseEntity.ok("文件导入成功，正在后台处理数据");
17.     } catch (Exception e) {
18.         log.error("导入用户数据失败", e);
19.         return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
20.                 .body("导入失败：" + e.getMessage());
21.     }
22. }

复制代码

性能优化技巧

技巧说明分批查询避免一次性加载全表分批写入每5k条批量插入临时文件并发读时先 MultipartFile.transferTo(tmp)线程池配置专用线程池，隔离业务线程

1. # application.yml
2. spring:
3.   task:
4.     execution:
5.       pool:
6.         core-size: 10
7.         max-size: 30
8.         queue-capacity: 1000

复制代码

常见问题 & 解决方案

问题解决方案Can not create temporary file!并发读时先保存临时文件，再独立流读取Stream Closed每个任务独立 InputStreamOutOfMemoryError分批处理 + 及时 clear()总结


✅ Spring Boot + EasyExcel 在 零侵入 的情况下即可完成百万级数据的导入导出。
✅ 通过 分批、并发、顺序写 等技巧，内存占用降低 90% 以上。

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！