导出Excel工具类

新到一家公司，看以前的代码，很多重复，光一个到处excel就有好几处写法，为了代码简洁高效，所以想写一个导出的工具类，话不多说，上代码

package com.zijinph.core.util.excel;

import java.io.IOException;
import java.io.OutputStream;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Comparator;
import java.util.Date;
import java.util.Iterator;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import javax.servlet.http.HttpServletResponse;

import org.apache.commons.lang3.StringUtils;
import org.apache.poi.hssf.usermodel.HSSFCell;
import org.apache.poi.hssf.usermodel.HSSFCellStyle;
import org.apache.poi.hssf.usermodel.HSSFFont;
import org.apache.poi.hssf.usermodel.HSSFRichTextString;
import org.apache.poi.hssf.usermodel.HSSFRow;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.usermodel.HorizontalAlignment;
import org.apache.poi.xssf.usermodel.XSSFCell;
import org.apache.poi.xssf.usermodel.XSSFCellStyle;
import org.apache.poi.xssf.usermodel.XSSFColor;
import org.apache.poi.xssf.usermodel.XSSFFont;
import org.apache.poi.xssf.usermodel.XSSFRichTextString;
import org.apache.poi.xssf.usermodel.XSSFRow;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;

import com.zijinph.core.annotation.BeanFieldAnnotation;
import com.zijinph.core.util.StringUtil;
import com.zijinph.core.util.excel.enums.ExcelVersionEnum;
import com.zijinph.core.util.time.consts.DateTimeFormat;

import lombok.extern.log4j.Log4j2;

@Log4j2
@SuppressWarnings("rawtypes") 
public class ExportExcelUtil {
        
    static Pattern p = Pattern.compile("^//d+(//.//d+)?$");
    
    /**
     * <p>
     * 导出无头部标题行Excel <br>
     * 时间格式默认：yyyy-MM-dd hh:mm:ss <br>
     * </p>
     * 
     * @param <T>
     * 
     * @param <T> T需要为javaBean 如果需要自定义表格头部需要加BeanFieldAnnotation注解
     * 以便反射读取字段时，顺序和你表格头部一致
     * 
     * @param title 表格标题
     * @param dataset 数据集合
     * @param out 输出流
     * @param version 2003 或者 2007，不传时默认生成2003版本
     */
    public static <T> void exportExcel(String title, Collection<T> dataset, HttpServletResponse res, String version) {
        if (StringUtils.isEmpty(version) || String.valueOf(ExcelVersionEnum.EXCEL_2003.getVersion()).equals(version.trim())) {
            exportExcel2003(title, null, dataset, res, DateTimeFormat.Pattern.YYYY_MM_DD_HH_MM_SS);
        } else {
            exportExcel2007(title, null, dataset, res, DateTimeFormat.Pattern.YYYY_MM_DD_HH_MM_SS);
        }
    }

    /**
     * <p>
     * 导出带有头部标题行的Excel <br>
     * 时间格式默认：yyyy-MM-dd hh:mm:ss <br>
     * </p>
     * 
     * @param <T>
     * 
     * @param title 表格标题
     * @param headers 头部标题集合
     * @param dataset 数据集合
     * @param out 输出流
     * @param version 2003 或者 2007，不传时默认生成2003版本
     */
    public static <T> void exportExcel(String title, String[] headers, Collection<T> dataset, HttpServletResponse res,
        String version) {
        if (StringUtils.isBlank(version) || String.valueOf(ExcelVersionEnum.EXCEL_2003.getVersion()).equals(version.trim())) {
            exportExcel2003(title, headers, dataset, res, DateTimeFormat.Pattern.YYYY_MM_DD_HH_MM_SS);
        } else {
            exportExcel2007(title, headers, dataset, res, DateTimeFormat.Pattern.YYYY_MM_DD_HH_MM_SS);
        }
    }

    /**
     * <p>
     * 通用Excel导出方法,利用反射机制遍历对象的所有字段，将数据写入Excel文件中 <br>
     * 此版本生成2007以上版本的文件 (文件后缀：xlsx)
     * </p>
     * 
     * @param title
     *        表格标题名
     * @param headers
     *        表格头部标题集合
     * @param dataset
     *        需要显示的数据集合,集合中一定要放置符合JavaBean风格的类的对象。此方法支持的
     *        JavaBean属性的数据类型有基本数据类型及String,Date
     * @param out
     *        与输出设备关联的流对象，可以将EXCEL文档导出到本地文件或者网络中
     * @param pattern
     *        如果有时间数据，设定输出格式。默认为"yyyy-MM-dd hh:mm:ss"
     */
    public static <T> void exportExcel2007(String title, String[] headers, Collection<T> dataset,
        HttpServletResponse res, String pattern) {
        try (XSSFWorkbook workbook = new XSSFWorkbook(); OutputStream out = res.getOutputStream()) {
            // 生成一个表格
            XSSFSheet sheet = workbook.createSheet(title);
            // 设置表格默认列宽度为15个字节
            sheet.setDefaultColumnWidth(20);
            // 生成一个样式
            XSSFCellStyle style = workbook.createCellStyle();
            // 设置这些样式
            style.setFillForegroundColor(new XSSFColor(java.awt.Color.gray));
            style.setAlignment(HorizontalAlignment.CENTER);
            // 生成一个字体
            XSSFFont font = workbook.createFont();
            font.setFontName("宋体");
            font.setColor(new XSSFColor(java.awt.Color.BLACK));
            font.setFontHeightInPoints((short) 11);
            // 把字体应用到当前的样式
            style.setFont(font);
            // 生成并设置另一个样式
            // 产生表格标题行
            XSSFRow row = sheet.createRow(0);
            XSSFCell cellHeader;
            for (int i = 0; i < headers.length; i++) {
                cellHeader = row.createCell(i);
                cellHeader.setCellStyle(style);
                cellHeader.setCellValue(new XSSFRichTextString(headers[i]));
            }
            // 遍历集合数据，产生数据行
            Iterator<T> it = dataset.iterator();
            int index = 0;           
            SimpleDateFormat sdf = new SimpleDateFormat(pattern);
            doExcel2007(sheet, style, it, index, sdf);
            workbook.write(out);
        } catch (SecurityException e) {
            log.error("exportExcel2007 SecurityException : {}", StringUtil.getExceptionMessage(e));
        } catch (NoSuchMethodException e) {
            log.error("exportExcel2007 NoSuchMethodException : {}", StringUtil.getExceptionMessage(e));
        } catch (IllegalArgumentException e) {
            log.error("exportExcel2007 IllegalArgumentException : {}", StringUtil.getExceptionMessage(e));
        } catch (IllegalAccessException e) {
            log.error("exportExcel2007 IllegalAccessException : {}", StringUtil.getExceptionMessage(e));
        } catch (InvocationTargetException e) {
            log.error("exportExcel2007 InvocationTargetException : {}", StringUtil.getExceptionMessage(e));
        } catch (IOException e) {
            log.error("exportExcel2007 IOException : {}", StringUtil.getExceptionMessage(e));
        }
    }

    private static <T> int doExcel2007(XSSFSheet sheet, XSSFCellStyle style, Iterator<T> it, int index,
        SimpleDateFormat sdf) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException {
        XSSFRow row;
        while (it.hasNext()) {
            index++;
            row = sheet.createRow(index);
            T t = it.next();
            // 利用反射，根据JavaBean属性的先后顺序，动态调用getXxx()方法得到属性值
            List<Field> fields = getOrderedField(t.getClass().getDeclaredFields());
            for (int i = 0; i < fields.size(); i++) {
                XSSFCell cell = row.createCell(i);
                cell.setCellStyle(style);
                Class tCls = t.getClass();
                Field field = fields.get(i);
                String fieldName = field.getName();
                String getMethodName = "get" + fieldName.substring(0, 1).toUpperCase() + fieldName.substring(1);
                @SuppressWarnings("unchecked")
                Method getMethod = tCls.getMethod(getMethodName, new Class[] {});
                Object value = getMethod.invoke(t);
                // 判断值的类型后进行强制类型转换
                String textValue = null;
                if (value instanceof Integer) {
                    cell.setCellValue((Integer) value);
                } else if (value instanceof Float) {
                    textValue = String.valueOf((Float) value);
                    cell.setCellValue(textValue);
                } else if (value instanceof Double) {
                    textValue = String.valueOf((Double) value);
                    cell.setCellValue(textValue);
                } else if (value instanceof Long) {
                    cell.setCellValue((Long) value);
                }
                if (value instanceof Boolean) {
                    textValue = "是";
                    if (!(Boolean) value) {
                        textValue = "否";
                    }
                } else if (value instanceof Date) {
                    textValue = sdf.format((Date) value);
                } else {
                    // 其它数据类型都当作字符串简单处理
                    if (value != null) {
                        textValue = value.toString();
                    }
                }
                if (textValue != null) {
                    Matcher matcher = p.matcher(textValue);
                    if (matcher.matches()) {
                        // 是数字当作double处理
                        cell.setCellValue(Double.parseDouble(textValue));
                    } else {
                        XSSFRichTextString richString = new XSSFRichTextString(textValue);
                        cell.setCellValue(richString);
                    }
                }

            }               
        }
        return index;
    }
    
    /**
     * <p>
     * 通用Excel导出方法,利用反射机制遍历对象的所有字段，将数据写入Excel文件中 <br>
     * 此方法生成2003版本的excel,文件名后缀：xls <br>
     * </p>
     * 
     * @param title
     *        表格标题名
     * @param headers
     *        表格头部标题集合
     * @param dataset
     *        需要显示的数据集合,集合中一定要放置符合JavaBean风格的类的对象。此方法支持的
     *        JavaBean属性的数据类型有基本数据类型及String,Date
     * @param out
     *        与输出设备关联的流对象，可以将EXCEL文档导出到本地文件或者网络中
     * @param pattern
     *        如果有时间数据，设定输出格式。默认为"yyyy-MM-dd hh:mm:ss"
     */
    public static <T> void exportExcel2003(String title, String[] headers, Collection<T> dataset,
        HttpServletResponse res, String pattern) {
        try (HSSFWorkbook workbook = new HSSFWorkbook(); OutputStream out = res.getOutputStream()) {
            // 生成一个表格
            HSSFSheet sheet = workbook.createSheet(title);
            // 设置表格默认列宽度为15个字节
            sheet.setDefaultColumnWidth(20);
            // 生成一个样式
            HSSFCellStyle style = workbook.createCellStyle();
            // 设置这些样式
            style.setAlignment(HorizontalAlignment.CENTER);
            // 生成一个字体
            HSSFFont font = workbook.createFont();
            font.setFontName("宋体");
            font.setFontHeightInPoints((short) 11);
            // 把字体应用到当前的样式
            style.setFont(font);
            // 产生表格标题行
            HSSFRow row = sheet.createRow(0);
            HSSFCell cellHeader;
            for (int i = 0; i < headers.length; i++) {
                cellHeader = row.createCell(i);
                cellHeader.setCellStyle(style);
                cellHeader.setCellValue(headers[i]);
            }
            // 遍历集合数据，产生数据行
            Iterator<T> it = dataset.iterator();
            int index = 0;
            SimpleDateFormat sdf = new SimpleDateFormat(pattern);
            index = doExcel2003(sheet, style, it, index, sdf);
            workbook.write(out);
        } catch (SecurityException e) {
            log.error("exportExcel2007 SecurityException : {}", StringUtil.getExceptionMessage(e));
        } catch (NoSuchMethodException e) {
            log.error("exportExcel2007 NoSuchMethodException : {}", StringUtil.getExceptionMessage(e));
        } catch (IllegalArgumentException e) {
            log.error("exportExcel2007 IllegalArgumentException : {}", StringUtil.getExceptionMessage(e));
        } catch (IllegalAccessException e) {
            log.error("exportExcel2007 IllegalAccessException : {}", StringUtil.getExceptionMessage(e));
        } catch (InvocationTargetException e) {
            log.error("exportExcel2007 InvocationTargetException : {}", StringUtil.getExceptionMessage(e));
        } catch (IOException e) {
            log.error("exportExcel2007 IOException : {}", StringUtil.getExceptionMessage(e));
        } 
    }

    private static <T> int doExcel2003(HSSFSheet sheet, HSSFCellStyle style, Iterator<T> it, int index,
        SimpleDateFormat sdf) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException {
        HSSFRow row;
        while (it.hasNext()) {
            index++;
            row = sheet.createRow(index);
            T t = it.next();
            // 利用反射，根据JavaBean属性的先后顺序，动态调用getXxx()方法得到属性值
            List<Field> fields = getOrderedField(t.getClass().getDeclaredFields());
            for (int i = 0; i < fields.size(); i++) {
                HSSFCell cell = row.createCell(i);
                Class tCls = t.getClass();
                cell.setCellStyle(style);
                Field field = fields.get(i);
                String fieldName = field.getName();
                String getMethodName = "get" + fieldName.substring(0, 1).toUpperCase() + fieldName.substring(1);
                @SuppressWarnings("unchecked")
                Method getMethod = tCls.getMethod(getMethodName, new Class[]{});               
                Object value = getMethod.invoke(t);
                // 判断值的类型后进行强制类型转换
                String textValue = null;
                if (value instanceof Integer) {
                    cell.setCellValue((Integer) value);
                } else if (value instanceof Float) {
                    textValue = String.valueOf((Float) value);
                    cell.setCellValue(textValue);
                } else if (value instanceof Double) {
                    textValue = String.valueOf((Double) value);
                    cell.setCellValue(textValue);
                } else if (value instanceof Long) {
                    cell.setCellValue((Long) value);
                }
                if (value instanceof Boolean) {
                    textValue = "是";
                    if (!(Boolean) value) {
                        textValue = "否";
                    }
                } else if (value instanceof Date) {
                    textValue = sdf.format((Date) value);
                } else {
                    // 其它数据类型都当作字符串简单处理
                    if (value != null) {
                        textValue = value.toString();
                    }
                }
                if (textValue != null) {
                    Matcher matcher = p.matcher(textValue);
                    if (matcher.matches()) {
                        // 是数字当作double处理
                        cell.setCellValue(Double.parseDouble(textValue));
                    } else {
                        HSSFRichTextString richString = new HSSFRichTextString(textValue);
                        cell.setCellValue(richString);
                    }
                }
            }                
        }
        return index;
    }
    
    //排序Bean字段属性书序，前提加了BeanFieldAnnotation注解，已便和excel标题对应
    private static List<Field> getOrderedField(Field[] fields){
        List<Field> fieldList = new ArrayList<>();
        for(Field f:fields){
            if(f.getAnnotation(BeanFieldAnnotation.class)!=null){
                fieldList.add(f);
            }
        }
        fieldList.sort(Comparator.comparingInt(
                m -> m.getAnnotation(BeanFieldAnnotation.class).order()
                ));
        return fieldList;
    }

}

如果你需要设置表头标题，就要保证在写excel数据时顺序和javaBean属性顺序一致，但是 在JDK的API文档里明确标注了：不能保证getDeclaredFields()/getDeclaredMethods()返回的Fields[] 和 Methods[] 的顺序。注意是不能保证返回顺序，而不是返回是乱序：它完全可能是乱序，也还可能是按照声明顺序排布（JVM有权在编译时，自行决定类成员的顺序，不一定要按照代码中的声明顺序来进行编译。因此返回的顺序其实是class文件中的成员正向顺序，只不过在编译时这个顺序不一定等于声明时的顺序），所以，需要自定义一个注解来设置Bean的顺序以保证数据和标题一致性。

package com.zijinph.core.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
  * @author hankailin
  * @version 2018年10月24日 下午3:17:01
  * 此注解对导出excel中反射去字段顺序做支撑
  */


@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface BeanFieldAnnotation {
    
    int order();
    
}

javaBean：

package com.rain.contral;

public class Demo {

    @BeanFieldAnnotation(order = 1)
    private String name;

    @BeanFieldAnnotation(order = 2)
    private String address;

    @BeanFieldAnnotation(order = 3)
    private String cardId;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public String getCardId() {
        return cardId;
    }

    public void setCardId(String cardId) {
        this.cardId = cardId;
    }

}