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

简介
博客专栏：

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();

            for (Field declaredField : declaredFields) {
                //获取注解对象
                ExportEntityMap declaredAnnotation = declaredField.getDeclaredAnnotation(ExportEntityMap.class);
                if (declaredAnnotation != null) {
                    fieldMap.put(declaredAnnotation.EnName(), declaredAnnotation.CnName());
                }
            }
1
2
3
4
5
6
7
8
9
10
fillSheet 方法是封装的导入数据方法，可以不做任何修改。

完整代码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