java 导出Excel 大数据量，自己经验总结！（二）

在上一次的基础上加上了样式，以及中文列名

 package com.tommy.fundation.util;

 import java.io.OutputStream;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;

 import javax.servlet.http.HttpServletResponse;

 import org.apache.poi.hssf.usermodel.HSSFWorkbook;
 import org.apache.poi.hssf.usermodel.HSSFSheet;
 import org.apache.poi.hssf.usermodel.HSSFCellStyle;
 import org.apache.poi.hssf.usermodel.HSSFFont;
 import org.apache.poi.hssf.usermodel.HSSFRow;
 import org.apache.poi.hssf.usermodel.HSSFCell;
 import org.apache.poi.ss.usermodel.CellStyle;
 import org.apache.poi.ss.usermodel.Font;
 import org.apache.poi.ss.usermodel.IndexedColors;

 public class ExportExcel<T> {
     public void doExcel(HttpServletResponse response, List<T> list, String fileName) throws Exception {
         String[] columnNames = new String[0];
         doExcel(response, list , columnNames, fileName);
     }
     /**
      * 导出多张excel表,解决xls格式行数65535的限制
      * @author OnlyOne
      * @param response
      * @param list 需要处理的list数据集合
      * @param columnNames 与实体属性一一对应的列名
      * @param fileName 文件名
      * @throws Exception
      */
     public void doExcel(HttpServletResponse response, List<T> list, String[] columnNames, String fileName) throws Exception {
         OutputStream os = response.getOutputStream();//获取输出流
         response.reset();
         // 设置下载头部信息。Content-disposition为属性名。attachment表示以附件方式下载，如果要在页面中打开，则改为inline。filename为文件名
         response.setContentType("application/vnd.ms-excel;charset=utf-8");
         response.setHeader("Content-disposition", "attachment;filename="+ new String((fileName + ".xls").getBytes(), "iso-8859-1"));

         //将数据集合按65000个进行分割成多个子集合
         Map<Integer, List<T>> sheetMap = doSheets(list);
         // 创建excel工作簿
         HSSFWorkbook wb = new HSSFWorkbook();
         //将map集合转换成set集合
         Set<Integer> keys = sheetMap.keySet();

         // 创建两种单元格格式
         HSSFCellStyle cs = wb.createCellStyle();
         HSSFCellStyle cs2 = wb.createCellStyle();

         // 创建两种字体
         HSSFFont f = wb.createFont();
         HSSFFont f2 = wb.createFont();

         // 创建第一种字体样式（用于列名）
         f.setFontHeightInPoints((short) 10);
         f.setColor(IndexedColors.BLACK.getIndex());
         f.setBoldweight(Font.BOLDWEIGHT_BOLD);

         // 创建第二种字体样式（用于值）
         f2.setFontHeightInPoints((short) 10);
         f2.setColor(IndexedColors.BLACK.getIndex());

         // 设置第一种单元格的样式（用于列名）
         cs.setFont(f);
         cs.setBorderLeft(CellStyle.BORDER_THIN);
         cs.setBorderRight(CellStyle.BORDER_THIN);
         cs.setBorderTop(CellStyle.BORDER_THIN);
         cs.setBorderBottom(CellStyle.BORDER_THIN);
         cs.setAlignment(CellStyle.ALIGN_CENTER);

         // 设置第二种单元格的样式（用于值）
         cs2.setFont(f2);
         cs2.setBorderLeft(CellStyle.BORDER_THIN);
         cs2.setBorderRight(CellStyle.BORDER_THIN);
         cs2.setBorderTop(CellStyle.BORDER_THIN);
         cs2.setBorderBottom(CellStyle.BORDER_THIN);
         cs2.setAlignment(CellStyle.ALIGN_CENTER);

         //对set集合进行遍历
         for (Iterator<Integer> iterator = keys.iterator(); iterator.hasNext();) {
             //获取遍历的下标
             Integer sheetKey = iterator.next();
             // 创建一个sheet（页），并命名
             HSSFSheet sheet = wb.createSheet("sheet"+sheetKey);
             //获取一页的数据
             List<T> sheetData = sheetMap.get(sheetKey);
             //创建列名的行
             HSSFRow firstRow = sheet.createRow(0);
             //如果columnNames有值，则作为列名；如果没有，则实体的属性名作为列名
             if(columnNames.length == 0){
                 T en = (T) sheetData.get(0);
                 List<Object> titleList = RelectUtil.<T>reflectEntityAttribute(en);
                 for(int m=0; m<titleList.size(); m++){
                     HSSFCell cell = firstRow.createCell(m);
                     cell.setCellValue(titleList.get(m+1).toString());
                     cell.setCellStyle(cs);
                 }
             }else{
                 for(int m=0; m<columnNames.length; m++){
                     HSSFCell cell = firstRow.createCell(m);
                     cell.setCellValue(columnNames[m]);
                     cell.setCellStyle(cs);
                 }
             }

             // 手动设置列宽。第一个参数表示要为第几列设；，第二个参数表示列的宽度，n为列高的像素数。
             for(int i=0;i<columnNames.length;i++){
                 sheet.setColumnWidth((short) i, (short) (35.7 * 100));
             }

             //遍历一页的数据集合
             for (int i = 0, len = sheetData.size(); i < len; i++) {
                 //获取数据实体
                 T en = (T) sheetData.get(i);
                 //反射获取行数据
                 List<Object> dataList = RelectUtil.<T>reflectEntity(en, en.getClass());
                 //创建数据行，以第二行开始，第一行作为列名使用
                 HSSFRow row = sheet.createRow(i+1);
                 for(int m=0; m<dataList.size(); m++){
                     HSSFCell cell = row.createCell(m);
                     cell.setCellValue(dataList.get(m).toString());
                     cell.setCellStyle(cs2);
                 }

             }
         }
         wb.write(os);
         os.flush();
         os.close();
     }
     /**
      * 此方法将数据集合按65000个进行分割成多个子集合
      * @author OnlyOne
      * @param list 需要处理的list数据集合
      * @return
      */
     public Map<Integer, List<T>> doSheets(List<T> list){
         int count = list.size()/65000;
         int yu = list.size() % 65000;
         Map<Integer, List<T>> map = new HashMap<Integer, List<T>>();
         for (int i = 0; i <= count; i++) {
             List<T> subList = new ArrayList<T>();
             if (i == count) {
                 subList = list.subList(i * 65000, 65000 * i + yu);
             } else {
                 subList = list.subList(i * 65000, 65000 * (i + 1));
             }
             map.put(i, subList);
         }
         return map;
     }
 }

辅助工具类

 package com.tommy.fundation.util;

 import java.lang.reflect.Field;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.util.ArrayList;
 import java.util.Date;
 import java.util.List;

 public class RelectUtil {
     public static <T> List<Object> reflectEntity(T model,Class<?> cals) throws NoSuchMethodException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, SecurityException, NoSuchFieldException{
         List<Object> list = new ArrayList<Object>();
         Field[] field = model.getClass().getDeclaredFields();        //获取实体类的所有属性，返回Field数组
         for(int j=0 ; j<field.length ; j++){     //遍历所有属性
             String nam = field[j].getName();    //获取属性的名字
             String name = nam;
             name  = name.substring(0,1).toUpperCase()+name.substring(1);
             String type = field[j].getGenericType().toString();    //获取属性的类型

             if(type.equals("class java.lang.String")){   //如果type是类类型，则前面包含"class "，后面跟类名
                 Method m = model.getClass().getMethod("get"+name);
                 String value = (String) m.invoke(model);    //调用getter方法获取属性值
                 if(value != null){
                    list.add(value);
                 }else{
                     list.add("");
                 }
             }

             if(type.equals("class java.lang.Integer") || type.equals("int")){
                 Method m = model.getClass().getMethod("get"+name);
                 Integer value = (Integer) m.invoke(model);
                 if(value != null){
                     list.add(value);
                 }else{
                     list.add("");
                 }
             }

             if(type.equals("class java.lang.Short") || type.equals("short")){
                 Method m = model.getClass().getMethod("get"+name);
                 Short value = (Short) m.invoke(model);
                 if(value != null){
                     list.add(value);
                 }else{
                     list.add("");
                 }
             }       

             if(type.equals("class java.lang.Double") || type.equals("double")){
                 Method m = model.getClass().getMethod("get"+name);
                 Double value = (Double) m.invoke(model);
                 if(value != null){
                     list.add(value);
                 }else{
                     list.add("");
                 }
             }                  

             if(type.equals("class java.lang.Boolean") || type.equals("boolean")){
                 Method m = model.getClass().getMethod("get"+name);
                 Boolean value = (Boolean) m.invoke(model);
                 if(value != null){
                     list.add(value);
                 }else{
                     list.add("");
                 }
             }

             if(type.equals("class java.util.Date")){
                 Method m = model.getClass().getMethod("get"+name);
                 Date value = (Date) m.invoke(model);
                 if(value != null){
                     list.add(value);
                 }else{
                     list.add("");
                 }
             }
         }
         return list;
     }
     public static <T> List<Object> reflectEntityAttribute(T model) throws NoSuchMethodException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, SecurityException, NoSuchFieldException {
         List<Object> list = new ArrayList<Object>();
         Field[] field = model.getClass().getDeclaredFields();        //获取实体类的所有属性，返回Field数组
         for (int j = 0; j < field.length; j++) {     //遍历所有属性
             String nam = field[j].getName();    //获取属性的名字
             list.add(nam);
         }
         return list;
     }
 }