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     ... (getter\setter)

    @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.