Springboot整合Poi导出excel（注解版）

Myth丶恋晨 2023-10-02 09:39 57阅读 0赞

简介  
博客专栏：

Springboot整合Poi导出excel（简单版）  
Springboot整合Poi导出excel（注解版）  
上文提到通过poi简单导出Excel后，很多读者反应需要解决导出自适应和设置各种样式，并且频繁导出需要写各种map导致代码过于繁琐。故笔者借鉴了一下自定义注解的写法，提供一种简介又快速的导出Excel方法。

1.导入依赖  
和上文中提到的依赖一样，只不过添加了lombok插件简化了代码,可按需要导入这个插件。

<dependency>  
<groupId>org.apache.poi</groupId>  
<artifactId>poi</artifactId>  
<version>3.14</version>  
</dependency>  
<dependency>  
<groupId>org.apache.poi</groupId>  
<artifactId>poi-ooxml</artifactId>  
<version>3.14</version>  
</dependency>

<dependency>  
<groupId>org.projectlombok</groupId>  
<artifactId>lombok</artifactId>  
</dependency>  
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
2.自定义注解  
为了避免和上文一样频繁的用map来注入数据，导致方法复用难，这里引入自定义注解。首先定义注解，有两个属性，一个是数据库中列名，另一个是java中实体属性名。

package org.emall.website.anno;  
import java.lang.annotation.\*;

/\*\*  
\* @author created by zhangxin27695  
\* @Classname ExportEntityMap  
\* @Description  
\* @Date 2020-03-23 8:58  
\*/  
@Target(\{ElementType.FIELD\})  
@Retention(RetentionPolicy.RUNTIME)  
@Documented  
public @interface ExportEntityMap \{

String EnName() default "数据库列名";  
String CnName() default "实体映射名";

1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
3.定义实体  
在需要导出的实体上添加自定义注解，因为poi导出的map操作就是为了映射列名和属性名之间的关系：Excel对应的列头和对应的属数据库列名是写死的，如Excel的姓名对应的属性名是name，数据库中是name，poi设置map为（“name”，“姓名”）。频繁的map操作设置的是静态的数据，如下图。为了能够复用数据，所以编写自定义注解，简化代码。

注：@Data是lombok注解，可以自动创建get，set方法和构造方法，具体可参考网上lombok详细适用方法。如果没有引入，可以自己创建get，set方法。

package org.emall.website.entity;

import lombok.Data;  
import org.emall.website.anno.ExportEntityMap;

import java.math.BigInteger;

/\*\*  
\* @author created by zhangxin27695  
\* @Classname ExportDto  
\* @Description  
\* @Date 2020-03-23 9:07  
\*/  
@Data  
public class ExportDto \{

private BigInteger id;

private String order\_number;

@ExportEntityMap(CnName="价格",EnName="amount\_real")  
private String amount\_real;

@ExportEntityMap(CnName="日期",EnName="date\_add")  
private String date\_add;

@ExportEntityMap(CnName="订单状态",EnName="status\_str")  
private String status\_str;

@ExportEntityMap(CnName="姓名",EnName="link\_man")  
private String link\_man;

@ExportEntityMap(CnName="收货电话",EnName="mobie")  
private String mobie;

@ExportEntityMap(CnName="地址",EnName="address")  
private String address;

@ExportEntityMap(CnName="订单详情",EnName="detailValue")  
private String detailValue;

1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
21  
22  
23  
24  
25  
26  
27  
28  
29  
30  
31  
32  
33  
34  
35  
36  
37  
38  
39  
40  
41  
42  
43  
44  
45  
46  
4.创建导出工具类  
其中主要关注Export方法，包括以下几个知识点：

设置文件名  
设置文件格式  
创建workBook，对应一个excel文件  
在workbook中创建一个sheet，对应excel中的sheet（原理相当于java的swing，在画布上添加控件）  
设置边距，页眉，页脚  
设置打印方向，缩放，纸张大小  
创建单元格，设置表头和表头居中  
设置居中和字体  
自定义注解操作  
文件输出  
其中最重要的是对自定义注解的操作：  
//循环注解里面的值 填入Link集合  
Field\[\] declaredFields = c.getDeclaredFields();

完整代码ExportExcelUtils2 如下：

package org.emall.website.util;  
import org.apache.poi.hssf.usermodel.\*;  
import org.apache.poi.ss.usermodel.Footer;  
import org.apache.poi.ss.usermodel.Header;  
import org.emall.website.anno.ExportEntityMap;  
import org.slf4j.Logger;  
import org.slf4j.LoggerFactory;

import javax.servlet.http.HttpServletResponse;  
import java.io.OutputStream;  
import java.io.UnsupportedEncodingException;  
import java.lang.reflect.Field;  
import java.text.SimpleDateFormat;  
import java.util.\*;

/\*\*  
\* @ClassName : ExportExcelUtils2  
\* @Description :  
\* @Author : ASUS  
\* @Date 2020/3/18  
\* @Version 1.0  
\*\*/  
public class ExportExcelUtils2 \{  
// private static final Logger logger = LoggerFactory.getLogger(ExportUtil.class);

/\*\*  
\* 导出Excel  
\*  
\* @param excelName 要导出的excel名称  
\* @param list 要导出的数据集合  
\* @param c 中英文字段对应Map，即要导出的excel表头  
\* @param response 使用response可以导出到浏览器  
\* @param <T>  
\*/  
public static <T> void export(String excelName, List<T> list, Class<T> c, HttpServletResponse response) \{  
SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH：mm：ss");// 设置日期格式  
// 设置默认文件名为当前时间：年月日时分秒  
if (excelName == null || excelName == "") \{  
excelName = df.format(new Date()).toString();  
\} else \{  
excelName = excelName + df.format(new Date()).toString();  
\}  
// 设置response头信息  
response.reset();  
response.setContentType("application/vnd.ms-excel"); // 改成输出excel文件  
try \{  
response.setHeader("Content-disposition", "attachment; filename="  
\+ new String(excelName.getBytes("gb2312"), "ISO-8859-1") + ".xls");  
\} catch (UnsupportedEncodingException e1) \{  
//logger.info(e1.getMessage());  
\}

try \{  
//创建一个WorkBook,对应一个Excel文件  
HSSFWorkbook wb = new HSSFWorkbook();  
//在Workbook中，创建一个sheet，对应Excel中的工作薄（sheet）  
HSSFSheet sheet = wb.createSheet(excelName);  
//设置 边距、页眉、页脚

// HSSFPrintSetup printSetup = (HSSFPrintSetup) sheet.getPrintSetup();  
HSSFPrintSetup printSetup = sheet.getPrintSetup();  
打印方向，true：横向，false：纵向(默认)  
printSetup.setLandscape(true);  
printSetup.setHeaderMargin(0.2);  
printSetup.setFooterMargin(0.2);  
//设置打印缩放为88%  
//printSetup.setScale((short) 55);  
printSetup.setFitHeight((short) 0);  
printSetup.setFitWidth((short) 1);  
// printSetup.setLeftToRight(true);//列从左向右显示②  
printSetup.setPaperSize(HSSFPrintSetup.A4\_PAPERSIZE); // 纸张  
sheet.setMargin(HSSFSheet.BottomMargin, (double) 0.8);// 页边距（下）  
sheet.setMargin(HSSFSheet.LeftMargin, (double) 0);// 页边距（左）  
sheet.setMargin(HSSFSheet.RightMargin, (double) 0);// 页边距（右）  
sheet.setMargin(HSSFSheet.TopMargin, (double) 0.8);// 页边距（上）  
sheet.setHorizontallyCenter(true);//设置打印页面为水平居中  
sheet.setVerticallyCenter(true);  
sheet.setAutobreaks(false);  
sheet.setFitToPage(false);  
Footer footer = sheet.getFooter();  
//设置页数  
footer.setCenter("第" + HeaderFooter.page() + "页，共 " + HeaderFooter.numPages() + "页");  
Header header = sheet.getHeader();  
//自定义页眉,并设置页眉 左中右显示信息  
//居中  
// header.setCenter("Center Header");  
//靠左  
header.setLeft(HSSFHeader.font("宋体", "") +  
HSSFHeader.fontSize((short) 16) + excelName + ".xls");  
//靠右  
// header.setRight(HSSFHeader.font("Stencil-Normal", "Italic") +  
// HSSFHeader.fontSize((short) 16) + "Right w/ Stencil-Normal Italic font and size 16");

//创建单元格，并设置值表头 设置表头居中  
HSSFCellStyle style = wb.createCellStyle();  
//设置边框  
style.setBorderBottom(HSSFCellStyle.BORDER\_THIN); //下边框  
style.setBorderLeft(HSSFCellStyle.BORDER\_THIN);//左边框  
style.setBorderTop(HSSFCellStyle.BORDER\_THIN);//上边框  
style.setBorderRight(HSSFCellStyle.BORDER\_THIN);//右边框  
//自动换行  
//style.setWrapText(true);  
//创建一个居中格式  
style.setAlignment(HSSFCellStyle.ALIGN\_CENTER);  
style.setVerticalAlignment(HSSFCellStyle.VERTICAL\_CENTER);//上下居中  
//设置字体  
HSSFFont font = wb.createFont();  
font.setFontName("宋体");

style.setFont(font);  
// 填充工作表  
//获取需要转出的excel表头的map字段  
LinkedHashMap<String, String> fieldMap = new LinkedHashMap<>();  
//循环注解里面的值 填入Link集合  
Field\[\] declaredFields = c.getDeclaredFields();

for (Field declaredField : declaredFields) \{  
//获取注解对象  
ExportEntityMap declaredAnnotation = declaredField.getDeclaredAnnotation(ExportEntityMap.class);  
if (declaredAnnotation != null) \{  
fieldMap.put(declaredAnnotation.EnName(), declaredAnnotation.CnName());  
\}  
\}  
fillSheet(sheet, list, fieldMap, style);  
//将文件输出  
OutputStream ouputStream = response.getOutputStream();  
wb.write(ouputStream);  
ouputStream.flush();  
ouputStream.close();  
\} catch (Exception e) \{  
System.err.println("导出Excel失败！");  
System.err.println(e.getMessage());  
\}  
\}

/\*\*  
\* 根据字段名获取字段对象  
\*  
\* @param fieldName 字段名  
\* @param clazz 包含该字段的类  
\* @return 字段  
\*/  
public static Field getFieldByName(String fieldName, Class<?> clazz) \{  
//logger.info("根据字段名获取字段对象:getFieldByName()");  
// 拿到本类的所有字段  
Field\[\] selfFields = clazz.getDeclaredFields();  
// 如果本类中存在该字段，则返回  
for (Field field : selfFields) \{  
//如果本类中存在该字段，则返回  
if (field.getName().equals(fieldName)) \{  
return field;  
\}  
\}  
// 否则，查看父类中是否存在此字段，如果有则返回  
Class<?> superClazz = clazz.getSuperclass();  
if (superClazz != null && superClazz != Object.class) \{  
//递归  
return getFieldByName(fieldName, superClazz);  
\}  
// 如果本类和父类都没有，则返回空  
return null;  
\}

/\*\*  
\* 根据字段名获取字段值  
\*  
\* @param fieldName 字段名  
\* @param o 对象  
\* @return 字段值  
\* @throws Exception 异常  
\*/  
public static Object getFieldValueByName(String fieldName, Object o)  
throws Exception \{  
//logger.info("根据字段名获取字段值:getFieldValueByName()");  
Object value = null;  
//根据字段名得到字段对象  
Field field = getFieldByName(fieldName, o.getClass());  
//如果该字段存在，则取出该字段的值  
if (field != null) \{  
field.setAccessible(true);//类中的成员变量为private,在类外边使用属性值，故必须进行此操作  
value = field.get(o);//获取当前对象中当前Field的value  
\} else \{  
throw new Exception(o.getClass().getSimpleName() + "类不存在字段名 "  
\+ fieldName);  
\}  
return value;  
\}

/\*\*  
\* 根据带路径或不带路径的属性名获取属性值,即接受简单属性名，  
\* 如userName等，又接受带路径的属性名，如student.department.name等  
\*  
\* @param fieldNameSequence 带路径的属性名或简单属性名  
\* @param o 对象  
\* @return 属性值  
\* @throws Exception 异常  
\*/  
public static Object getFieldValueByNameSequence(String fieldNameSequence,  
Object o) throws Exception \{  
// logger.info("根据带路径或不带路径的属性名获取属性值,即接受简单属性名:getFieldValueByNameSequence()");  
Object value = null;  
// 将fieldNameSequence进行拆分  
String\[\] attributes = fieldNameSequence.split("\\\\.");  
if (attributes.length == 1) \{  
value = getFieldValueByName(fieldNameSequence, o);  
\} else \{  
// 根据数组中第一个连接属性名获取连接属性对象，如student.department.name  
Object fieldObj = getFieldValueByName(attributes\[0\], o);  
//截取除第一个属性名之后的路径  
String subFieldNameSequence = fieldNameSequence  
.substring(fieldNameSequence.indexOf(".") + 1);  
//递归得到最终的属性对象的值  
value = getFieldValueByNameSequence(subFieldNameSequence, fieldObj);  
\}  
return value;  
\}

/\*\*  
\* 向工作表中填充数据  
\*  
\* @param sheet excel的工作表名称  
\* @param list 数据源  
\* @param fieldMap 中英文字段对应关系的Map  
\* @param style 表格中的格式  
\* @throws Exception 异常  
\*/  
public static <T> void fillSheet(HSSFSheet sheet, List<T> list,  
LinkedHashMap<String, String> fieldMap, HSSFCellStyle style) throws Exception \{  
//logger.info("向工作表中填充数据:fillSheet()");  
// 定义存放英文字段名和中文字段名的数组  
String\[\] enFields = new String\[fieldMap.size()\];  
String\[\] cnFields = new String\[fieldMap.size()\];  
// 填充数组  
int count = 0;  
for (Map.Entry<String, String> entry : fieldMap.entrySet()) \{  
enFields\[count\] = entry.getKey();  
cnFields\[count\] = entry.getValue();  
count++;  
\}  
//存储最大列宽  
Map<Integer, Integer> maxWidth = new HashMap<>();  
HSSFRow row = sheet.createRow((int) 0);  
HSSFCell cell = null;  
// 填充表头  
for (int i = 0; i < cnFields.length; i++) \{  
cell = row.createCell(i);  
cell.setCellValue(cnFields\[i\]);  
cell.setCellStyle(style);  
sheet.autoSizeColumn(i);  
//设置自适应宽高  
maxWidth.put(i, cell.getStringCellValue().getBytes().length \* 256 + 200);  
\}  
// 填充内容  
for (int index = 0; index < list.size(); index++) \{  
row = sheet.createRow(index + 1);  
// 获取单个对象  
T item = list.get(index);  
int j = 0;  
for (int i = 0; i < enFields.length; i++) \{  
HSSFCell createCell = row.createCell(j);  
Object objValue = getFieldValueByNameSequence(enFields\[i\], item);  
String fieldValue = objValue == null ? "" : objValue.toString();  
cell = row.createCell(i);  
createCell.setCellValue(fieldValue);

int length = createCell.getStringCellValue().getBytes().length \* 256 + 200;  
//这里把宽度最大限制到15000  
if (length > 15000) \{  
length = 15000;  
\}  
maxWidth.put(j, Math.max(length, maxWidth.get(j)));  
j++;  
createCell.setCellStyle(style);  
\}  
\}

// 列宽自适应  
for (int i = 0; i < cnFields.length; i++) \{  
sheet.setColumnWidth(i,maxWidth.get(i));  
\}  
\}  
\}

1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
21  
22  
23  
24  
25  
26  
27  
28  
29  
30  
31  
32  
33  
34  
35  
36  
37  
38  
39  
40  
41  
42  
43  
44  
45  
46  
47  
48  
49  
50  
51  
52  
53  
54  
55  
56  
57  
58  
59  
60  
61  
62  
63  
64  
65  
66  
67  
68  
69  
70  
71  
72  
73  
74  
75  
76  
77  
78  
79  
80  
81  
82  
83  
84  
85  
86  
87  
88  
89  
90  
91  
92  
93  
94  
95  
96  
97  
98  
99  
100  
101  
102  
103  
104  
105  
106  
107  
108  
109  
110  
111  
112  
113  
114  
115  
116  
117  
118  
119  
120  
121  
122  
123  
124  
125  
126  
127  
128  
129  
130  
131  
132  
133  
134  
135  
136  
137  
138  
139  
140  
141  
142  
143  
144  
145  
146  
147  
148  
149  
150  
151  
152  
153  
154  
155  
156  
157  
158  
159  
160  
161  
162  
163  
164  
165  
166  
167  
168  
169  
170  
171  
172  
173  
174  
175  
176  
177  
178  
179  
180  
181  
182  
183  
184  
185  
186  
187  
188  
189  
190  
191  
192  
193  
194  
195  
196  
197  
198  
199  
200  
201  
202  
203  
204  
205  
206  
207  
208  
209  
210  
211  
212  
213  
214  
215  
216  
217  
218  
219  
220  
221  
222  
223  
224  
225  
226  
227  
228  
229  
230  
231  
232  
233  
234  
235  
236  
237  
238  
239  
240  
241  
242  
243  
244  
245  
246  
247  
248  
249  
250  
251  
252  
253  
254  
255  
256  
257  
258  
259  
260  
261  
262  
263  
264  
265  
266  
267  
268  
269  
270  
271  
272  
273  
274  
275  
276  
277  
278  
279  
280  
281  
282  
283  
284  
5.控制层调用  
首先通过调用自己的业务代码，得到list数据。ExportExcelUtils2有四个参数，包括  
excel名字，数据list，导出实体类的class，和HttpServletResponse请求。可以看下上文的控制层需要多次map导入列名，导致复用不便。

@RequestMapping(value = "/excel/exportBankCheckInfo", method = RequestMethod.GET)  
public void ExportBankCkeckInfo2(HttpServletResponse response, HttpServletRequest request) \{  
//得到所有要导出的数据  
List<ExportDto> orderlist = orderService.listexcel2(start, end);  
//定义导出的excel名字  
String excelName = "订单详情表";

//导出用户相关信息  
new ExportExcelUtils2().export(excelName, orderlist, ExportDto.class, response);  
\}  
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
总结  
通过注解和poi导出excel，易于操作，可复用性强。如果需要导入新的数据，只需要新建实体类，并加上自定义注解。最后在控制层，分别得到需要的list调用封装的工具类方法得到导出excel。最后导出来的效果如下：

推荐  
欢迎通过一下渠道，交流学习。  
github  
掘金  
Q群959706394  
————————————————  
版权声明：本文为CSDN博主「dazhuangzhang」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。  
原文链接：https://blog.csdn.net/qq\_35180973/article/details/105173750