java 注解方式 写入数据到Excel文件中

之前有写过一点关于java实现写Excel文件的方法，但是现在看来，那种方式用起来不是太舒服，还很麻烦。所以最近又参考其他，就写了一个新版，用起来不要太爽。

代码不需要解释，惯例直接贴下来：

public class ExcelExport implements Closeable {

    private static final Logger LOGGER = LoggerFactory.getLogger(ExcelExport.class);

    public static final String EXCEL_SUFFIX = ".xlsx"; // 目前只支持xlsx格式

    private static final String SHEET_FONT_TYPE = "Arial";

    private Workbook workbook;

    private Sheet sheet;

    private int rowNum;

    private Map<String, CellStyle> styles;

    private List<ColumnField> columns;

    public ExcelExport createSheet(String sheetName, String title, Class<?> clazz) throws Exception {
        this.workbook = createWorkbook();
        this.columns = createColumns();
        Field[] fields = clazz.getDeclaredFields();
        for (Field field : fields) {
            ExcelField excelField = field.getAnnotation(ExcelField.class);
            if (excelField != null) {
                this.columns.add(new ColumnField(excelField.title(), field.getName(), field.getType(), excelField.width()));
            }
        }
        if (CollectionUtils.isEmpty(this.columns)) throw new Exception("Excel's headerList are undefined");
        this.sheet = workbook.createSheet(StringUtils.defaultString(sheetName, StringUtils.defaultString(title, "Sheet1")));
        this.styles = createStyles(workbook);
        this.rowNum = 0;
        if (StringUtils.isNotBlank(title)) {
            Row titleRow = sheet.createRow(rowNum++);
            titleRow.setHeightInPoints(30);
            Cell titleCell = titleRow.createCell(0);
            titleCell.setCellStyle(styles.get("title"));
            titleCell.setCellValue(title);
            sheet.addMergedRegion(new CellRangeAddress(titleRow.getRowNum(), titleRow.getRowNum(), titleRow.getRowNum(),
                    this.columns.size() - 1));
        }
        Row headerRow = sheet.createRow(rowNum++);
        headerRow.setHeightInPoints(16);
        for (int i = 0; i < this.columns.size(); i++) {
            int width = this.columns.get(i).width;
            this.sheet.setColumnWidth(i, 256 * width + 184);
            Cell cell = headerRow.createCell(i);
            cell.setCellStyle(styles.get("header"));
            cell.setCellValue(this.columns.get(i).title);
        }
        return this;
    }

    public <E> ExcelExport setDataList(List<E> dataList) throws IllegalAccessException {
        for (E data : dataList) {
            int column = 0;
            Row row = this.addRow();
            Map<String, Object> map = toMap(data);
            for (ColumnField field : this.columns) {
                Class<?> paramType = field.getParamType();
                if (map.containsKey(field.getParam())) {
                    Object value = map.get(field.getParam());
                    this.addCell(row, column++, value, paramType);
                }
            }
        }
        LOGGER.debug("add data into {} success", this.sheet.getSheetName());
        return this;
    }

    private Cell addCell(Row row, int column, Object value, Class<?> type) {
        Cell cell = row.createCell(column);
        if (value == null) {
            cell.setCellValue("");
        } else if (type.isAssignableFrom(String.class)) {
            cell.setCellValue((String) value);
        } else if (type.isAssignableFrom(Integer.class)) {
            cell.setCellValue((Integer) value);
        } else if (type.isAssignableFrom(Double.class)) {
            cell.setCellValue((Double) value);
        } else if (type.isAssignableFrom(Long.class)) {
            cell.setCellValue((Long) value);
        } else if (type.isAssignableFrom(Float.class)) {
            cell.setCellValue((Float) value);
        } else if (type.isAssignableFrom(Date.class)) {
            Date time = (Date) value;
            String timer = DateUtils.formatDate(time, "yyyy-MM-dd HH:mm:ss");
            cell.setCellValue(timer);
        } else {
            cell.setCellValue(Objects.toString(value));
        }
        cell.setCellStyle(styles.get("data"));
        return cell;
    }

    private Map<String, Object> toMap(Object entity) throws IllegalAccessException {
        Map<String, Object> row = Maps.newHashMap();
        if (null == entity) return row;
        Class clazz = entity.getClass();
        Field[] fields = clazz.getDeclaredFields();
        for (Field field : fields) {
            field.setAccessible(true);
            row.put(field.getName(), field.get(entity));
        }
        return row;
    }

    private Row addRow() {
        return sheet.createRow(rowNum++);
    }

    public ExcelExport write(OutputStream os) {
        try {
            workbook.write(os);
        } catch (IOException ex) {
            LOGGER.error(ex.getMessage(), ex);
        } finally {
            if (null != os) {
                try {
                    os.close();
                } catch (IOException e) {
                    LOGGER.error("close Output Stream failed: {}", e.getMessage());
                }
            }
        }
        return this;
    }

    public ExcelExport write(HttpServletResponse response, String fileName) {
        response.reset();
        try {
            response.setContentType("application/octet-stream; charset=utf-8");
            response.setHeader("Content-Disposition", "attachment; filename=" + URLEncoder.encode(fileName, UTF8));
            write(response.getOutputStream());
        } catch (IOException ex) {
            LOGGER.error(ex.getMessage(), ex);
        }
        return this;
    }

    public ExcelExport writeFile(String name) throws IOException {
        FileOutputStream os = new FileOutputStream(name);
        this.write(os);
        return this;
    }

    private Workbook createWorkbook() {
        return new SXSSFWorkbook();
    }

    private List<ColumnField> createColumns() {
        return Lists.newLinkedList();
    }

    private Map<String, CellStyle> createStyles(Workbook workbook) {
        Map<String, CellStyle> styleMap = Maps.newHashMap();

        CellStyle style = workbook.createCellStyle();
        style.setAlignment(HorizontalAlignment.CENTER);
        style.setVerticalAlignment(VerticalAlignment.CENTER);
        Font titleFont = workbook.createFont();
        titleFont.setFontName(SHEET_FONT_TYPE);
        titleFont.setFontHeightInPoints((short) 16);
        titleFont.setBold(true);
        style.setFont(titleFont);
        styleMap.put("title", style);

        style = workbook.createCellStyle();
        style.setVerticalAlignment(VerticalAlignment.CENTER);
        style.setBorderRight(BorderStyle.THIN);
        style.setRightBorderColor(IndexedColors.GREY_50_PERCENT.getIndex());
        style.setBorderLeft(BorderStyle.THIN);
        style.setLeftBorderColor(IndexedColors.GREY_50_PERCENT.getIndex());
        style.setBorderTop(BorderStyle.THIN);
        style.setTopBorderColor(IndexedColors.GREY_50_PERCENT.getIndex());
        style.setBorderBottom(BorderStyle.THIN);
        style.setBottomBorderColor(IndexedColors.GREY_50_PERCENT.getIndex());
        Font dataFont = workbook.createFont();
        dataFont.setFontName(SHEET_FONT_TYPE);
        dataFont.setFontHeightInPoints((short) 10);
        style.setFont(dataFont);
        styleMap.put("data", style);

        style = workbook.createCellStyle();
        style.cloneStyleFrom(styleMap.get("data"));
        style.setWrapText(true);
        style.setAlignment(HorizontalAlignment.CENTER);
        style.setFillForegroundColor(IndexedColors.GREY_25_PERCENT.getIndex());
        style.setFillPattern(FillPatternType.SOLID_FOREGROUND);
        Font headerFont = workbook.createFont();
        headerFont.setFontName(SHEET_FONT_TYPE);
        headerFont.setFontHeightInPoints((short) 10);
        headerFont.setBold(true);
        headerFont.setColor(IndexedColors.WHITE.getIndex());
        style.setFont(headerFont);
        style.setBorderRight(BorderStyle.THIN);
        styleMap.put("header", style);

        return styleMap;
    }

    public Workbook getWorkbook() {
        return workbook;
    }

    public void setWorkbook(Workbook workbook) {
        this.workbook = workbook;
    }

    public Sheet getSheet() {
        return sheet;
    }

    public void setSheet(Sheet sheet) {
        this.sheet = sheet;
    }

    public int getRowNum() {
        return rowNum;
    }

    public void setRowNum(int rowNum) {
        this.rowNum = rowNum;
    }

    public Map<String, CellStyle> getStyles() {
        return styles;
    }

    public void setStyles(Map<String, CellStyle> styles) {
        this.styles = styles;
    }

    public List<ColumnField> getColumns() {
        return columns;
    }

    public void setColumns(List<ColumnField> columns) {
        this.columns = columns;
    }

    @Override
    public void close() throws IOException {
        if (workbook instanceof SXSSFWorkbook && ((SXSSFWorkbook) workbook).dispose())
            workbook.close();
    }

    class ColumnField {
        private String title;
        private String param;
        private Class<?> paramType;
        private int width;

        ColumnField(String title, String param, Class<?> paramType, int width) {
            this.title = title;
            this.param = param;
            this.paramType = paramType;
            this.width = width;
        }

        public String getTitle() {
            return title;
        }

        public void setTitle(String title) {
            this.title = title;
        }

        public String getParam() {
            return param;
        }

        public void setParam(String param) {
            this.param = param;
        }

        public Class<?> getParamType() {
            return paramType;
        }

        public void setParamType(Class<?> paramType) {
            this.paramType = paramType;
        }

        public int getWidth() {
            return width;
        }

        public void setWidth(int width) {
            this.width = width;
        }
    }
}

以下是两个注解

@Target({ElementType.METHOD, ElementType.FIELD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface ExcelField {

    /**
     * 导出字段标题
     */
    String title();

    /**
     * 列宽
     */
    int width() default 10; // 后面还可以添加其他的属性，添加后再修改上面那个代码就行了
}

以上。

使用方式为：

import com.xxx.utils.ExcelField;

public class ExcelDataModel {

    @ExcelField(title = "ID", width = 4)
    private String id;

    @ExcelField(title = "序号", width = 4)
    private Integer serial;

    @ExcelField(title = "名字", width = 8)
    private String name;
13     ... (gettersetter)

    @GetMapping(value = "export/post")
    public void exportPost(@ModelAttribute RequestModel model, HttpServletResponse response) {
        try (
                ExcelExport excelExport = new ExcelExport();
                OutputStream out = response.getOutputStream()
        ) {
            List<ExcelDataModel> data = xxxService.selectExportData(model);
            response.setContentType("octets/stream");
            response.addHeader("Content-Disposition", "attachment;filename=" + URLEncoder.encode("xx列表", "UTF-8")
                    + DateUtils.formatDate(new Date(), "yyyyMMddHHmmss") + ExcelExport.EXCEL_SUFFIX);
            String title = "xx列表";
            excelExport.createSheet("xx列表", title, ExcelDataModel.class);
            excelExport.setDataList(data);
            excelExport.write(out);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

over.