Easyexcel（8-通用工具类）

EasyExcelUtils

提供常见的文件同步和异步读取、文件导出、模板添补、自定义表头、自定义内容、从指定行开始读取数据、多Sheet导出等方法

1. public class EasyExcelUtils {
3.     /**
4.      * 同步无模型读（默认读取sheet0,从第2行开始读）
5.      *
6.      * @param filePath excel文件的绝对路径
7.      */
8.     public static List<Map<Integer, String>> syncRead(String filePath) {
9.         return EasyExcelFactory.read(filePath).sheet().doReadSync();
10.     }
12.     /**
13.      * 同步无模型读（默认读取sheet0,从第2行开始读）
14.      *
15.      * @param inputStream excel文件的输入流
16.      */
17.     public static List<Map<Integer, String>> syncRead(InputStream inputStream) {
18.         return EasyExcelFactory.read(inputStream).sheet().doReadSync();
19.     }
21.     /**
22.      * 同步无模型读（默认读取sheet0,从第2行开始读）
23.      *
24.      * @param file excel文件
25.      */
26.     public static List<Map<Integer, String>> syncRead(File file) {
27.         return EasyExcelFactory.read(file).sheet().doReadSync();
28.     }
30.     /**
31.      * 同步无模型读（自定义读取sheetX，从第2行开始读）
32.      *
33.      * @param filePath excel文件的绝对路径
34.      * @param sheetNo  sheet页号，从0开始
35.      */
36.     public static List<Map<Integer, String>> syncRead(String filePath, Integer sheetNo) {
37.         return EasyExcelFactory.read(filePath).sheet(sheetNo).doReadSync();
38.     }
40.     /**
41.      * 同步无模型读（自定义读取sheetX，从第2行开始读）
42.      *
43.      * @param inputStream excel文件的输入流
44.      * @param sheetNo  sheet页号，从0开始
45.      */
46.     public static List<Map<Integer, String>> syncRead(InputStream inputStream, Integer sheetNo) {
47.         return EasyExcelFactory.read(inputStream).sheet(sheetNo).doReadSync();
48.     }
50.     /**
51.      * 同步无模型读（自定义读取sheetX，从第2行开始读）
52.      *
53.      * @param file excel文件
54.      * @param sheetNo  sheet页号，从0开始
55.      */
56.     public static List<Map<Integer, String>> syncRead(File file, Integer sheetNo) {
57.         return EasyExcelFactory.read(file).sheet(sheetNo).doReadSync();
58.     }
60.     /**
61.      * 同步无模型读（指定sheet和表头占的行数）
62.      *
63.      * @param filePath
64.      * @param sheetNo    sheet页号，从0开始
65.      * @param headRowNum 表头占的行数，从0开始（如果要连表头一起读出来则传0）
66.      */
67.     public static List<Map<Integer, String>> syncRead(String filePath, Integer sheetNo, Integer headRowNum) {
68.         return EasyExcelFactory.read(filePath).sheet(sheetNo).headRowNumber(headRowNum).doReadSync();
69.     }
71.     /**
72.      * 同步无模型读（指定sheet和表头占的行数）
73.      *
74.      * @param inputStream
75.      * @param sheetNo     sheet页号，从0开始
76.      * @param headRowNum  表头占的行数，从0开始（如果要连表头一起读出来则传0）
77.      */
78.     public static List<Map<Integer, String>> syncRead(InputStream inputStream, Integer sheetNo, Integer headRowNum) {
79.         return EasyExcelFactory.read(inputStream).sheet(sheetNo).headRowNumber(headRowNum).doReadSync();
80.     }
82.     /**
83.      * 同步无模型读（指定sheet和表头占的行数）
84.      *
85.      * @param file
86.      * @param sheetNo    sheet页号，从0开始
87.      * @param headRowNum 表头占的行数，从0开始（如果要连表头一起读出来则传0）
88.      */
89.     public static List<Map<Integer, String>> syncRead(File file, Integer sheetNo, Integer headRowNum) {
90.         return EasyExcelFactory.read(file).sheet(sheetNo).headRowNumber(headRowNum).doReadSync();
91.     }
93.     /**
94.      * 同步按模型读（默认读取sheet0,从第2行开始读）
95.      *
96.      * @param filePath
97.      * @param clazz    模型的类类型（excel数据会按该类型转换成对象）
98.      */
99.     public static <T> List<T> syncReadModel(String filePath, Class clazz) {
100.         return EasyExcelFactory.read(filePath).sheet().head(clazz).doReadSync();
101.     }
103.     /**
104.      * 同步按模型读（默认读取sheet0,从第2行开始读）
105.      *
106.      * @param inputStream
107.      * @param clazz    模型的类类型（excel数据会按该类型转换成对象）
108.      */
109.     public static <T> List<T> syncReadModel(InputStream inputStream, Class clazz) {
110.         return EasyExcelFactory.read(inputStream).sheet().head(clazz).doReadSync();
111.     }
113.     /**
114.      * 同步按模型读（默认读取sheet0,从第2行开始读）
115.      *
116.      * @param file
117.      * @param clazz    模型的类类型（excel数据会按该类型转换成对象）
118.      */
119.     public static <T> List<T> syncReadModel(File file, Class clazz) {
120.         return EasyExcelFactory.read(file).sheet().head(clazz).doReadSync();
121.     }
123.     /**
124.      * 同步按模型读（默认表头占一行，从第2行开始读）
125.      *
126.      * @param filePath
127.      * @param clazz    模型的类类型（excel数据会按该类型转换成对象）
128.      * @param sheetNo  sheet页号，从0开始
129.      */
130.     public static <T> List<T> syncReadModel(String filePath, Class clazz, Integer sheetNo) {
131.         return EasyExcelFactory.read(filePath).sheet(sheetNo).head(clazz).doReadSync();
132.     }
134.     /**
135.      * 同步按模型读（默认表头占一行，从第2行开始读）
136.      *
137.      * @param inputStream
138.      * @param clazz    模型的类类型（excel数据会按该类型转换成对象）
139.      * @param sheetNo  sheet页号，从0开始
140.      */
141.     public static <T> List<T> syncReadModel(InputStream inputStream, Class clazz, Integer sheetNo) {
142.         return EasyExcelFactory.read(inputStream).sheet(sheetNo).head(clazz).doReadSync();
143.     }
145.     /**
146.      * 同步按模型读（默认表头占一行，从第2行开始读）
147.      *
148.      * @param file
149.      * @param clazz    模型的类类型（excel数据会按该类型转换成对象）
150.      * @param sheetNo  sheet页号，从0开始
151.      */
152.     public static <T> List<T> syncReadModel(File file, Class clazz, Integer sheetNo) {
153.         return EasyExcelFactory.read(file).sheet(sheetNo).head(clazz).doReadSync();
154.     }
156.     /**
157.      * 同步按模型读（指定sheet和表头占的行数）
158.      *
159.      * @param filePath
160.      * @param clazz      模型的类类型（excel数据会按该类型转换成对象）
161.      * @param sheetNo    sheet页号，从0开始
162.      * @param headRowNum 表头占的行数，从0开始（如果要连表头一起读出来则传0）
163.      */
164.     public static <T> List<T> syncReadModel(String filePath, Class clazz, Integer sheetNo, Integer headRowNum) {
165.         return EasyExcelFactory.read(filePath).sheet(sheetNo).headRowNumber(headRowNum).head(clazz).doReadSync();
166.     }
168.     /**
169.      * 同步按模型读（指定sheet和表头占的行数）
170.      *
171.      * @param inputStream
172.      * @param clazz       模型的类类型（excel数据会按该类型转换成对象）
173.      * @param sheetNo     sheet页号，从0开始
174.      * @param headRowNum  表头占的行数，从0开始（如果要连表头一起读出来则传0）
175.      */
176.     public static <T> List<T> syncReadModel(InputStream inputStream, Class clazz, Integer sheetNo, Integer headRowNum) {
177.         return EasyExcelFactory.read(inputStream).sheet(sheetNo).headRowNumber(headRowNum).head(clazz).doReadSync();
178.     }
180.     /**
181.      * 同步按模型读（指定sheet和表头占的行数）
182.      *
183.      * @param file
184.      * @param clazz      模型的类类型（excel数据会按该类型转换成对象）
185.      * @param sheetNo    sheet页号，从0开始
186.      * @param headRowNum 表头占的行数，从0开始（如果要连表头一起读出来则传0）
187.      */
188.     public static <T> List<T> syncReadModel(File file, Class clazz, Integer sheetNo, Integer headRowNum) {
189.         return EasyExcelFactory.read(file).sheet(sheetNo).headRowNumber(headRowNum).head(clazz).doReadSync();
190.     }
192.     /**
193.      * 异步无模型读（默认读取sheet0,从第2行开始读）
194.      *
195.      * @param excelListener 监听器，在监听器中可以处理行数据LinkedHashMap，表头数据，异常处理等
196.      * @param filePath      表头占的行数，从0开始（如果要连表头一起读出来则传0）
197.      */
198.     public static <T> void asyncRead(String filePath, AnalysisEventListener<T> excelListener) {
199.         EasyExcelFactory.read(filePath, excelListener).sheet().doRead();
200.     }
202.     /**
203.      * 异步无模型读（默认读取sheet0,从第2行开始读）
204.      *
205.      * @param excelListener 监听器，在监听器中可以处理行数据LinkedHashMap，表头数据，异常处理等
206.      * @param inputStream      表头占的行数，从0开始（如果要连表头一起读出来则传0）
207.      */
208.     public static <T> void asyncRead(InputStream inputStream, AnalysisEventListener<T> excelListener) {
209.         EasyExcelFactory.read(inputStream, excelListener).sheet().doRead();
210.     }
212.     /**
213.      * 异步无模型读（默认读取sheet0,从第2行开始读）
214.      *
215.      * @param excelListener 监听器，在监听器中可以处理行数据LinkedHashMap，表头数据，异常处理等
216.      * @param file      表头占的行数，从0开始（如果要连表头一起读出来则传0）
217.      */
218.     public static <T> void asyncRead(File file, AnalysisEventListener<T> excelListener) {
219.         EasyExcelFactory.read(file, excelListener).sheet().doRead();
220.     }
222.     /**
223.      * 异步无模型读（默认表头占一行，从第2行开始读）
224.      *
225.      * @param filePath      表头占的行数，从0开始（如果要连表头一起读出来则传0）
226.      * @param excelListener 监听器，在监听器中可以处理行数据LinkedHashMap，表头数据，异常处理等
227.      * @param sheetNo       sheet页号，从0开始
228.      */
229.     public static <T> void asyncRead(String filePath, AnalysisEventListener<T> excelListener, Integer sheetNo) {
230.         EasyExcelFactory.read(filePath, excelListener).sheet(sheetNo).doRead();
231.     }
233.     /**
234.      * 异步无模型读（默认表头占一行，从第2行开始读）
235.      *
236.      * @param inputStream      表头占的行数，从0开始（如果要连表头一起读出来则传0）
237.      * @param excelListener 监听器，在监听器中可以处理行数据LinkedHashMap，表头数据，异常处理等
238.      * @param sheetNo       sheet页号，从0开始
239.      */
240.     public static <T> void asyncRead(InputStream inputStream, AnalysisEventListener<T> excelListener, Integer sheetNo) {
241.         EasyExcelFactory.read(inputStream, excelListener).sheet(sheetNo).doRead();
242.     }
244.     /**
245.      * 异步无模型读（默认表头占一行，从第2行开始读）
246.      *
247.      * @param file      表头占的行数，从0开始（如果要连表头一起读出来则传0）
248.      * @param excelListener 监听器，在监听器中可以处理行数据LinkedHashMap，表头数据，异常处理等
249.      * @param sheetNo       sheet页号，从0开始
250.      */
251.     public static <T> void asyncRead(File file, AnalysisEventListener<T> excelListener, Integer sheetNo) {
252.         EasyExcelFactory.read(file, excelListener).sheet(sheetNo).doRead();
253.     }
255.     /**
256.      * 异步无模型读（指定sheet和表头占的行数）
257.      *
258.      * @param filePath
259.      * @param excelListener 监听器，在监听器中可以处理行数据LinkedHashMap，表头数据，异常处理等
260.      * @param sheetNo       sheet页号，从0开始
261.      * @param headRowNum    表头占的行数，从0开始（如果要连表头一起读出来则传0）
262.      * @return
263.      */
264.     public static <T> void asyncRead(String filePath, AnalysisEventListener<T> excelListener, Integer sheetNo, Integer headRowNum) {
265.         EasyExcelFactory.read(filePath, excelListener).sheet(sheetNo).headRowNumber(headRowNum).doRead();
266.     }
268.     /**
269.      * 异步无模型读（指定sheet和表头占的行数）
270.      *
271.      * @param inputStream
272.      * @param excelListener 监听器，在监听器中可以处理行数据LinkedHashMap，表头数据，异常处理等
273.      * @param sheetNo       sheet页号，从0开始
274.      * @param headRowNum    表头占的行数，从0开始（如果要连表头一起读出来则传0）
275.      */
276.     public static <T> void asyncRead(InputStream inputStream, AnalysisEventListener<T> excelListener, Integer sheetNo, Integer headRowNum) {
277.         EasyExcelFactory.read(inputStream, excelListener).sheet(sheetNo).headRowNumber(headRowNum).doRead();
278.     }
280.     /**
281.      * 异步无模型读（指定sheet和表头占的行数）
282.      *
283.      * @param file
284.      * @param excelListener 监听器，在监听器中可以处理行数据LinkedHashMap，表头数据，异常处理等
285.      * @param sheetNo       sheet页号，从0开始
286.      * @param headRowNum    表头占的行数，从0开始（如果要连表头一起读出来则传0）
287.      */
288.     public static <T> void asyncRead(File file, AnalysisEventListener<T> excelListener, Integer sheetNo, Integer headRowNum) {
289.         EasyExcelFactory.read(file, excelListener).sheet(sheetNo).headRowNumber(headRowNum).doRead();
290.     }
292.     /**
293.      * 异步按模型读取（默认读取sheet0,从第2行开始读）
294.      *
295.      * @param filePath
296.      * @param excelListener 监听器，在监听器中可以处理行数据LinkedHashMap，表头数据，异常处理等
297.      * @param clazz         模型的类类型（excel数据会按该类型转换成对象）
298.      */
299.     public static <T> void asyncReadModel(String filePath, AnalysisEventListener<T> excelListener, Class clazz) {
300.         EasyExcelFactory.read(filePath, clazz, excelListener).sheet().doRead();
301.     }
303.     /**
304.      * 异步按模型读取（默认读取sheet0,从第2行开始读）
305.      *
306.      * @param inputStream
307.      * @param excelListener 监听器，在监听器中可以处理行数据LinkedHashMap，表头数据，异常处理等
308.      * @param clazz         模型的类类型（excel数据会按该类型转换成对象）
309.      */
310.     public static <T> void asyncReadModel(InputStream inputStream, AnalysisEventListener<T> excelListener, Class clazz) {
311.         EasyExcelFactory.read(inputStream, clazz, excelListener).sheet().doRead();
312.     }
314.     /**
315.      * 异步按模型读取（默认读取sheet0,从第2行开始读）
316.      *
317.      * @param file
318.      * @param excelListener 监听器，在监听器中可以处理行数据LinkedHashMap，表头数据，异常处理等
319.      * @param clazz         模型的类类型（excel数据会按该类型转换成对象）
320.      */
321.     public static <T> void asyncReadModel(File file, AnalysisEventListener<T> excelListener, Class clazz) {
322.         EasyExcelFactory.read(file, clazz, excelListener).sheet().doRead();
323.     }
325.     /**
326.      * 异步按模型读取（默认表头占一行，从第2行开始读）
327.      *
328.      * @param filePath
329.      * @param excelListener 监听器，在监听器中可以处理行数据LinkedHashMap，表头数据，异常处理等
330.      * @param clazz         模型的类类型（excel数据会按该类型转换成对象）
331.      * @param sheetNo       sheet页号，从0开始
332.      */
333.     public static <T> void asyncReadModel(String filePath, AnalysisEventListener<T> excelListener, Class clazz, Integer sheetNo) {
334.         EasyExcelFactory.read(filePath, clazz, excelListener).sheet(sheetNo).doRead();
335.     }
337.     /**
338.      * 异步按模型读取（默认表头占一行，从第2行开始读）
339.      *
340.      * @param inputStream
341.      * @param excelListener 监听器，在监听器中可以处理行数据LinkedHashMap，表头数据，异常处理等
342.      * @param clazz         模型的类类型（excel数据会按该类型转换成对象）
343.      * @param sheetNo       sheet页号，从0开始
344.      */
345.     public static <T> void asyncReadModel(InputStream inputStream, AnalysisEventListener<T> excelListener, Class clazz, Integer sheetNo) {
346.         EasyExcelFactory.read(inputStream, clazz, excelListener).sheet(sheetNo).doRead();
347.     }
349.     /**
350.      * 异步按模型读取（默认表头占一行，从第2行开始读）
351.      *
352.      * @param file
353.      * @param excelListener 监听器，在监听器中可以处理行数据LinkedHashMap，表头数据，异常处理等
354.      * @param clazz         模型的类类型（excel数据会按该类型转换成对象）
355.      * @param sheetNo       sheet页号，从0开始
356.      */
357.     public static <T> void asyncReadModel(File file, AnalysisEventListener<T> excelListener, Class clazz, Integer sheetNo) {
358.         EasyExcelFactory.read(file, clazz, excelListener).sheet(sheetNo).doRead();
359.     }
361.     /**
362.      * 异步按模型读取
363.      *
364.      * @param filePath
365.      * @param excelListener 监听器，在监听器中可以处理行数据LinkedHashMap，表头数据，异常处理等
366.      * @param clazz         模型的类类型（excel数据会按该类型转换成对象）
367.      * @param sheetNo       sheet页号，从0开始
368.      * @param headRowNum    表头占的行数，从0开始（如果要连表头一起读出来则传0）
369.      */
370.     public static <T> void asyncReadModel(String filePath, AnalysisEventListener<T> excelListener, Class clazz, Integer sheetNo, Integer headRowNum) {
371.         EasyExcelFactory.read(filePath, clazz, excelListener).sheet(sheetNo).headRowNumber(headRowNum).doRead();
372.     }
374.     /**
375.      * 异步按模型读取
376.      *
377.      * @param inputStream
378.      * @param excelListener 监听器，在监听器中可以处理行数据LinkedHashMap，表头数据，异常处理等
379.      * @param clazz         模型的类类型（excel数据会按该类型转换成对象）
380.      * @param sheetNo       sheet页号，从0开始
381.      * @param headRowNum    表头占的行数，从0开始（如果要连表头一起读出来则传0）
382.      */
383.     public static <T> void asyncReadModel(InputStream inputStream, AnalysisEventListener<T> excelListener, Class clazz, Integer sheetNo, Integer headRowNum) {
384.         EasyExcelFactory.read(inputStream, clazz, excelListener).sheet(sheetNo).headRowNumber(headRowNum).doRead();
385.     }
387.     /**
388.      * 异步按模型读取
389.      *
390.      * @param file
391.      * @param excelListener 监听器，在监听器中可以处理行数据LinkedHashMap，表头数据，异常处理等
392.      * @param clazz         模型的类类型（excel数据会按该类型转换成对象）
393.      * @param sheetNo       sheet页号，从0开始
394.      * @param headRowNum    表头占的行数，从0开始（如果要连表头一起读出来则传0）
395.      */
396.     public static <T> void asyncReadModel(File file, AnalysisEventListener<T> excelListener, Class clazz, Integer sheetNo, Integer headRowNum) {
397.         EasyExcelFactory.read(file, clazz, excelListener).sheet(sheetNo).headRowNumber(headRowNum).doRead();
398.     }
400.     /**
401.      * 无模板写文件
402.      *
403.      * @param filePath
404.      * @param head     表头数据
405.      * @param data     表内容数据
406.      */
407.     public static void write(String filePath, List<List<String>> head, List<List<Object>> data) {
408.         EasyExcel.write(filePath).head(head).sheet().doWrite(data);
409.     }
411.     /**
412.      * 无模板写文件
413.      *
414.      * @param outputStream
415.      * @param head     表头数据
416.      * @param data     表内容数据
417.      */
418.     public static void write(OutputStream outputStream, List<List<String>> head, List<List<Object>> data) {
419.         EasyExcel.write(outputStream).head(head).sheet().doWrite(data);
420.     }
422.     /**
423.      * 无模板写文件
424.      *
425.      * @param filePath
426.      * @param head      表头数据
427.      * @param data      表内容数据
428.      * @param sheetNo   sheet页号，从0开始
429.      */
430.     public static void write(String filePath, List<List<String>> head, List<List<Object>> data, Integer sheetNo) {
431.         EasyExcel.write(filePath).head(head).sheet(sheetNo).doWrite(data);
432.     }
434.     /**
435.      * 无模板写文件
436.      *
437.      * @param outputStream
438.      * @param head      表头数据
439.      * @param data      表内容数据
440.      * @param sheetNo   sheet页号，从0开始
441.      */
442.     public static void write(OutputStream outputStream, List<List<String>> head, List<List<Object>> data, Integer sheetNo) {
443.         EasyExcel.write(outputStream).head(head).sheet(sheetNo).doWrite(data);
444.     }
446.     /**
447.      * 无模板写文件
448.      *
449.      * @param filePath
450.      * @param head      表头数据
451.      * @param data      表内容数据
452.      * @param sheetNo   sheet页号，从0开始
453.      * @param sheetName sheet名称
454.      */
455.     public static void write(String filePath, List<List<String>> head, List<List<Object>> data, Integer sheetNo, String sheetName) {
456.         EasyExcel.write(filePath).head(head).sheet(sheetNo, sheetName).doWrite(data);
457.     }
459.     /**
460.      * 无模板写文件
461.      *
462.      * @param outputStream
463.      * @param head      表头数据
464.      * @param data      表内容数据
465.      * @param sheetNo   sheet页号，从0开始
466.      * @param sheetName sheet名称
467.      */
468.     public static void write(OutputStream outputStream, List<List<String>> head, List<List<Object>> data, Integer sheetNo, String sheetName) {
469.         EasyExcel.write(outputStream).head(head).sheet(sheetNo, sheetName).doWrite(data);
470.     }
472.     /**
473.      * 根据excel模板文件写入文件
474.      *
475.      * @param filePath
476.      * @param templateFileName
477.      * @param data
478.      */
479.     public static void writeTemplate(String filePath, String templateFileName, List data) {
480.         EasyExcel.write(filePath).withTemplate(templateFileName).sheet().doFill(data);
481.     }
483.     /**
484.      * 根据excel模板文件写入文件
485.      *
486.      * @param outputStream
487.      * @param templateFileName
488.      * @param data
489.      */
490.     public static void writeTemplate(OutputStream outputStream, String templateFileName, List data) {
491.         EasyExcel.write(outputStream).withTemplate(templateFileName).sheet().doFill(data);
492.     }
493.    
494.     /**
495.      * 根据excel模板文件写入文件
496.      *
497.      * @param file
498.      * @param templateFileName
499.      * @param data
500.      */
501.     public static void writeTemplate(File file, String templateFileName, List data) {
502.         EasyExcel.write(file).withTemplate(templateFileName).sheet().doFill(data);
503.     }
505.     /**
506.      * 根据excel模板文件写入文件
507.      *
508.      * @param filePath
509.      * @param templateFileName
510.      * @param headClazz
511.      * @param data
512.      */
513.     public static void writeTemplate(String filePath, String templateFileName, Class headClazz, List data) {
514.         EasyExcel.write(filePath, headClazz).withTemplate(templateFileName).sheet().doFill(data);
515.     }
517.     /**
518.      * 根据excel模板文件写入文件
519.      *
520.      * @param outputStream
521.      * @param templateFileName
522.      * @param headClazz
523.      * @param data
524.      */
525.     public static void writeTemplate(OutputStream outputStream, String templateFileName, Class headClazz, List data) {
526.         EasyExcel.write(outputStream, headClazz).withTemplate(templateFileName).sheet().doFill(data);
527.     }
528.    
529.     /**
530.      * 根据excel模板文件写入文件
531.      *
532.      * @param file
533.      * @param templateFileName
534.      * @param headClazz
535.      * @param data
536.      */
537.     public static void writeTemplate(File file, String templateFileName, Class headClazz, List data) {
538.         EasyExcel.write(file, headClazz).withTemplate(templateFileName).sheet().doFill(data);
539.     }
541.     /**
542.      * 按模板写文件
543.      *
544.      * @param filePath
545.      * @param headClazz 表头模板
546.      * @param data      数据
547.      */
548.     public static void write(String filePath, Class headClazz, List data) {
549.         EasyExcel.write(filePath, headClazz).sheet().doWrite(data);
550.     }
552.     /**
553.      * 按模板写文件
554.      *
555.      * @param outputStream
556.      * @param headClazz 表头模板
557.      * @param data      数据
558.      */
559.     public static void write(OutputStream outputStream, Class headClazz, List data) {
560.         EasyExcel.write(outputStream, headClazz).sheet().doWrite(data);
561.     }
563.     /**
564.      * 按模板写文件
565.      *
566.      * @param file
567.      * @param headClazz 表头模板
568.      * @param data      数据
569.      */
570.     public static void write(File file, Class headClazz, List data) {
571.         EasyExcel.write(file, headClazz).sheet().doWrite(data);
572.     }
574.     /**
575.      * 按模板写文件
576.      *
577.      * @param filePath
578.      * @param headClazz 表头模板
579.      * @param data      数据
580.      * @param sheetNo   sheet页号，从0开始
581.      */
582.     public static void write(String filePath, Class headClazz, List data, Integer sheetNo) {
583.         EasyExcel.write(filePath, headClazz).sheet(sheetNo).doWrite(data);
584.     }
586.     /**
587.      * 按模板写文件
588.      *
589.      * @param outputStream
590.      * @param headClazz 表头模板
591.      * @param data      数据
592.      * @param sheetNo   sheet页号，从0开始
593.      */
594.     public static void write(OutputStream outputStream, Class headClazz, List data, Integer sheetNo) {
595.         EasyExcel.write(outputStream, headClazz).sheet(sheetNo).doWrite(data);
596.     }
597.    
598.         /**
599.      * 按模板写文件
600.      *
601.      * @param file
602.      * @param headClazz 表头模板
603.      * @param data      数据
604.      * @param sheetNo   sheet页号，从0开始
605.      */
606.     public static void write(File file, Class headClazz, List data, Integer sheetNo) {
607.         EasyExcel.write(file, headClazz).sheet(sheetNo).doWrite(data);
608.     }
610.     /**
611.      * 按模板写文件
612.      *
613.      * @param filePath
614.      * @param headClazz 表头模板
615.      * @param data      数据
616.      * @param sheetNo   sheet页号，从0开始
617.      * @param sheetName sheet名称
618.      */
619.     public static void write(String filePath, Class headClazz, List data, Integer sheetNo, String sheetName) {
620.         EasyExcel.write(filePath, headClazz).sheet(sheetNo, sheetName).doWrite(data);
621.     }
623.     /**
624.      * 按模板写文件
625.      *
626.      * @param outputStream
627.      * @param headClazz 表头模板
628.      * @param data      数据
629.      * @param sheetNo   sheet页号，从0开始
630.      * @param sheetName sheet名称
631.      */
632.     public static void write(OutputStream outputStream, Class headClazz, List data, Integer sheetNo, String sheetName) {
633.         EasyExcel.write(outputStream, headClazz).sheet(sheetNo, sheetName).doWrite(data);
634.     }
635.    
636.         /**
637.      * 按模板写文件
638.      *
639.      * @param file
640.      * @param headClazz 表头模板
641.      * @param data      数据
642.      * @param sheetNo   sheet页号，从0开始
643.      * @param sheetName sheet名称
644.      */
645.     public static void write(File file, Class headClazz, List data, Integer sheetNo, String sheetName) {
646.         EasyExcel.write(file, headClazz).sheet(sheetNo, sheetName).doWrite(data);
647.     }
649.     /**
650.      * 按模板写文件
651.      *
652.      * @param filePath
653.      * @param headClazz    表头模板
654.      * @param data         数据
655.      * @param writeHandler 自定义的处理器，比如设置table样式，设置超链接、单元格下拉框等等功能都可以通过这个实现（需要注册多个则自己通过链式去调用）
656.      * @param sheetNo      sheet页号，从0开始
657.      * @param sheetName    sheet名称
658.      */
659.     public static void write(String filePath, Class headClazz, List data, WriteHandler writeHandler, Integer sheetNo, String sheetName) {
660.         EasyExcel.write(filePath, headClazz).registerWriteHandler(writeHandler).sheet(sheetNo, sheetName).doWrite(data);
661.     }
663.     /**
664.      * 按模板写文件（包含某些字段）
665.      *
666.      * @param filePath
667.      * @param headClazz   表头模板
668.      * @param data        数据
669.      * @param includeCols 包含字段集合，根据字段名称显示
670.      * @param sheetNo     sheet页号，从0开始
671.      * @param sheetName   sheet名称
672.      */
673.     public static void writeInclude(String filePath, Class headClazz, List data, Set<String> includeCols, Integer sheetNo, String sheetName) {
674.         EasyExcel.write(filePath, headClazz).includeColumnFieldNames(includeCols).sheet(sheetNo, sheetName).doWrite(data);
675.     }
677.     /**
678.      * 按模板写文件（排除某些字段）
679.      *
680.      * @param filePath
681.      * @param headClazz   表头模板
682.      * @param data        数据
683.      * @param excludeCols 过滤排除的字段，根据字段名称过滤
684.      * @param sheetNo     sheet页号，从0开始
685.      * @param sheetName   sheet名称
686.      */
687.     public static void writeExclude(String filePath, Class headClazz, List data, Set<String> excludeCols, Integer sheetNo, String sheetName) {
688.         EasyExcel.write(filePath, headClazz).excludeColumnFieldNames(excludeCols).sheet(sheetNo, sheetName).doWrite(data);
689.     }
691.     /**
692.      * 多个sheet页的数据链式写入
693.      * ExcelUtil.writeWithSheets(outputStream)
694.      * .writeModel(ExcelModel.class, excelModelList, "sheetName1")
695.      * .write(headData, data,"sheetName2")
696.      * .finish();
697.      *
698.      * @param outputStream
699.      */
700.     public static EasyExcelWriterFactory writeWithSheets(OutputStream outputStream) {
701.         EasyExcelWriterFactory excelWriter = new EasyExcelWriterFactory(outputStream);
702.         return excelWriter;
703.     }
705.     /**
706.      * 多个sheet页的数据链式写入
707.      * ExcelUtil.writeWithSheets(file)
708.      * .writeModel(ExcelModel.class, excelModelList, "sheetName1")
709.      * .write(headData, data,"sheetName2")
710.      * .finish();
711.      *
712.      * @param file
713.      */
714.     public static EasyExcelWriterFactory writeWithSheets(File file) {
715.         EasyExcelWriterFactory excelWriter = new EasyExcelWriterFactory(file);
716.         return excelWriter;
717.     }
719.     /**
720.      * 多个sheet页的数据链式写入
721.      * ExcelUtil.writeWithSheets(filePath)
722.      * .writeModel(ExcelModel.class, excelModelList, "sheetName1")
723.      * .write(headData, data,"sheetName2")
724.      * .finish();
725.      *
726.      * @param filePath
727.      */
728.     public static EasyExcelWriterFactory writeWithSheets(String filePath) {
729.         EasyExcelWriterFactory excelWriter = new EasyExcelWriterFactory(filePath);
730.         return excelWriter;
731.     }
733.     /**
734.      * 多个sheet页的数据链式写入（失败了会返回一个有部分数据的Excel）
735.      * ExcelUtil.writeWithSheets(response, exportFileName)
736.      * .writeModel(ExcelModel.class, excelModelList, "sheetName1")
737.      * .write(headData, data,"sheetName2")
738.      * .finish();
739.      *
740.      * @param response
741.      * @param exportFileName 导出的文件名称
742.      */
743.     public static EasyExcelWriterFactory writeWithSheetsWeb(HttpServletResponse response, String exportFileName) throws IOException {
744.         response.setContentType("application/vnd.ms-excel");
745.         response.setCharacterEncoding("utf-8");
746.         // 这里URLEncoder.encode可以防止中文乱码
747.         String fileName = URLEncoder.encode(exportFileName, "UTF-8");
748.         response.setHeader("Content-disposition", "attachment;filename=" + fileName + ".xlsx");
749.         EasyExcelWriterFactory excelWriter = new EasyExcelWriterFactory(response.getOutputStream());
750.         return excelWriter;
751.     }
752. }

复制代码

EasyExcelWriterFactory

文件导出和模板添补实现多Sheet写入（链式利用）

1. public class EasyExcelWriterFactory {
3.     private int sheetNo = 0;
4.     private ExcelWriter excelWriter = null;
6.     public EasyExcelWriterFactory(OutputStream outputStream) {
7.         excelWriter = EasyExcel.write(outputStream).build();
8.     }
10.     public EasyExcelWriterFactory(File file) {
11.         excelWriter = EasyExcel.write(file).build();
12.     }
14.     public EasyExcelWriterFactory(String filePath) {
15.         excelWriter = EasyExcel.write(filePath).build();
16.     }
18.     /**
19.      * 链式模板表头写入
20.      *
21.      * @param headClazz 表头格式
22.      * @param data      数据 List<ExcelModel> 或者List<List<Object>>
23.      * @return
24.      */
25.     public EasyExcelWriterFactory writeModel(Class headClazz, List data) {
26.         excelWriter.write(data, EasyExcel.writerSheet(this.sheetNo++).head(headClazz).build());
27.         return this;
28.     }
31.     /**
32.      * 链式模板表头写入
33.      *
34.      * @param headClazz 表头格式
35.      * @param data      数据 List<ExcelModel> 或者List<List<Object>>
36.      * @return
37.      */
38.     public EasyExcelWriterFactory writeModel(Class headClazz, List data, String sheetName) {
39.         excelWriter.write(data, EasyExcel.writerSheet(this.sheetNo++, sheetName).head(headClazz).build());
40.         return this;
41.     }
43.     /**
44.      * 链式自定义表头写入
45.      *
46.      * @param head
47.      * @param data      数据 List<ExcelModel> 或者List<List<Object>>
48.      * @param sheetName
49.      * @return
50.      */
51.     public EasyExcelWriterFactory write(List<List<String>> head, List data, String sheetName) {
52.         excelWriter.write(data, EasyExcel.writerSheet(this.sheetNo++, sheetName).head(head).build());
53.         return this;
54.     }
56.     /**
57.      * 使用此类结束后，一定要关闭流
58.      */
59.     public void finish() {
60.         excelWriter.finish();
61.     }
62. }

复制代码

ExcelListener

文件读取大数据和多Sheet导入监听器（利用线程池和批量插入方法）

1. public class ExcelListener extends AnalysisEventListener<T> {
3.     Logger log = LoggerFactory.getLogger(getClass());
5.     private static final Integer BATCH_SIZE = 1000;
7.     private Integer sheetNo;
9.     private Executor executor;
11.     private List<T> dataList = new ArrayList<>();
13.     public ExcelListener(Integer sheetNo, Executor executor) {
14.         this.sheetNo = sheetNo;
15.         this.executor = executor;
16.     }
18.     @Override
19.     public void invoke(T data, AnalysisContext analysisContext) {
20.         log.info("解析到一条数据：{}", JSON.toJSONString(data));
21.         dataList.add(data);
22.         if (dataList.size() >= BATCH_SIZE) {
23.             CompletableFuture.runAsync(() -> {
24.                 // 业务操作
25.                 // saveToDB(dataList);
26.             }, executor);
27.             dataList.clear();
28.         }
29.     }
31.     @Override
32.     public void doAfterAllAnalysed(AnalysisContext analysisContext) {
33.         log.info("已解析完所有数据!");
34.         if (!dataList.isEmpty()) {
35.             CompletableFuture.runAsync(() -> {
36.                 // 业务操作
37.                 // saveToDB(dataList);
38.             }, executor);
39.             dataList.clear();
40.         }
41.     }
43.     @Override
44.     public void onException(Exception exception, AnalysisContext context) throws Exception {
45.         if (exception instanceof ExcelDataConvertException) {
46.             ExcelDataConvertException convertException = (ExcelDataConvertException) exception;
47.             Integer row = convertException.getRowIndex();
48.             log.error("sheetNo：{}，第{}行数据转换失败，异常信息：{}", sheetNo, row, exception.getMessage());
49.         } else {
50.             log.error("导入其他异常信息：{}", exception.getMessage());
51.         }
52.     }
53. }

复制代码

利用案例

1. @GetMapping("/download1")
2. public void download1(HttpServletResponse response) {
3.     try {
4.         response.setContentType("application/vnd.ms-excel");
5.         response.setCharacterEncoding("utf-8");
6.         // 这里URLEncoder.encode可以防止中文乱码 当然和easyexcel没有关系
7.         String fileName = URLEncoder.encode("测试", "UTF-8").replaceAll("\\+", "%20");
8.         response.setHeader("Content-disposition", "attachment;filename=" + fileName + ".xls");
10.         User user = new User();
11.         user.setUserId(123);
12.         user.setName("as");
13.         user.setPhone("15213");
14.         user.setEmail("5456");
15.         user.setCreateTime(new Date());
16.         EasyExcelUtils.write(response.getOutputStream(), User.class, Arrays.asList(user));
17.     } catch (Exception e) {
18.         e.printStackTrace();
19.     }
20. }
22. @GetMapping("/download2")
23. public void download2(HttpServletResponse response) {
24.     try {
25.         response.setContentType("application/vnd.ms-excel");
26.         response.setCharacterEncoding("utf-8");
27.         // 这里URLEncoder.encode可以防止中文乱码 当然和easyexcel没有关系
28.         String fileName = URLEncoder.encode("测试", "UTF-8").replaceAll("\\+", "%20");
29.         response.setHeader("Content-disposition", "attachment;filename=" + fileName + ".xls");
31.         User user = new User();
32.         user.setUserId(123);
33.         user.setName("as");
34.         user.setPhone("15213");
35.         user.setEmail("5456");
36.         user.setCreateTime(new Date());
37.         EasyExcelUtils.write(response.getOutputStream(), User.class, Arrays.asList(user), 2);
38.     } catch (Exception e) {
39.         e.printStackTrace();
40.     }
41. }
43. @GetMapping("/download3")
44. public void download3(HttpServletResponse response) {
45.     try {
46.         response.setContentType("application/vnd.ms-excel");
47.         response.setCharacterEncoding("utf-8");
48.         // 这里URLEncoder.encode可以防止中文乱码 当然和easyexcel没有关系
49.         String fileName = URLEncoder.encode("测试", "UTF-8").replaceAll("\\+", "%20");
50.         response.setHeader("Content-disposition", "attachment;filename=" + fileName + ".xls");
52.         User user = new User();
53.         user.setUserId(123);
54.         user.setName("as");
55.         user.setPhone("15213");
56.         user.setEmail("5456");
57.         user.setCreateTime(new Date());
58.         EasyExcelUtils.writeWithSheets(response.getOutputStream())
59.                 .writeModel(User.class, Arrays.asList(user))
60.                 .writeModel(User.class, Arrays.asList(user))
61.                 .finish();
62.     } catch (Exception e) {
63.         e.printStackTrace();
64.     }
65. }

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。