• POI报表的高级应用

     POI报表的高级应用

    掌握基于模板打印的POI报表导出理解自定义工具类的执行流程

    熟练使用SXSSFWorkbook完成百万数据报表打印理解基于事件驱动的POI报表导入

    模板打印

    概述

    自定义生成Excel报表文件还是有很多不尽如意的地方，特别是针对复杂报表头，单元格样式，字体等操作。手写这些代码不仅费时费力，有时候效果还不太理想。那怎么样才能更方便的对报表样式，报表头进行处理呢？答案是 使用已经准备好的Excel模板，只需要关注模板中的数据即可。

    模板打印的操作步骤

    • 制作模版文件（模版文件的路径）
    • 导入（加载）模版文件，从而得到一个工作簿
    • 读取工作表
    • 读取行
    • 读取单元格
    • 读取单元格样式
    • 设置单元格内容
    • 其他单元格就可以使用读到的样式了

    代码实现

    1.    /**
    2.      * 采用模板打印的形式完成报表生成
    3.      *      模板
    4.      *  参数：
    5.      *      年月-月（2018-02%）
    6.      *
    7.      *      sxssf对象不支持模板打印
    8.      */
    9.     @RequestMapping(value = "/export/{month}", method = RequestMethod.GET)
    10.     public void export(@PathVariable String month) throws Exception {
    11.         //1.获取报表数据
    12.         List<EmployeeReportResult> list = userCompanyPersonalService.findByReport(companyId,month);
    13.  
    14.         //2.加载模板
    15.         Resource resource = new ClassPathResource("excel-template/hr-demo.xlsx");
    16.         FileInputStream fis = new FileInputStream(resource.getFile());
    17.  
    18.         //3.通过工具类完成下载
    19. //        new ExcelExportUtil(EmployeeReportResult.class,2,2).
    20. //                export(response,fis,list,month+"人事报表.xlsx");
    21.  
    22.  
    23.         //3.根据模板创建工作簿
    24.         Workbook wb = new XSSFWorkbook(fis);
    25.         //4.读取工作表
    26.         Sheet sheet = wb.getSheetAt(0);
    27.         //5.抽取公共样式
    28.         Row row = sheet.getRow(2);
    29.         CellStyle styles [] = new CellStyle[row.getLastCellNum()];
    30.         for(int i=0;i<row.getLastCellNum();i++) {
    31.             Cell cell = row.getCell(i);
    32.             styles[i] = cell.getCellStyle();
    33.         }
    34.         //6.构造单元格
    35.         int rowIndex = 2;
    36.         Cell cell=null;
    37.         for(int i=0;i<10000;i++) {
    38.             for (EmployeeReportResult employeeReportResult : list) {
    39.                 row = sheet.createRow(rowIndex++);
    40.                 // 编号,
    41.                 cell = row.createCell(0);
    42.                 cell.setCellValue(employeeReportResult.getUserId());
    43.                 cell.setCellStyle(styles[0]);
    44.                 // 姓名,
    45.                 cell = row.createCell(1);
    46.                 cell.setCellValue(employeeReportResult.getUsername());
    47.                 cell.setCellStyle(styles[1]);
    48.                 // 手机,
    49.                 cell = row.createCell(2);
    50.                 cell.setCellValue(employeeReportResult.getMobile());
    51.                 cell.setCellStyle(styles[2]);
    52.                 // 最高学历,
    53.                 cell = row.createCell(3);
    54.                 cell.setCellValue(employeeReportResult.getTheHighestDegreeOfEducation());
    55.                 cell.setCellStyle(styles[3]);
    56.                 // 国家地区,
    57.                 cell = row.createCell(4);
    58.                 cell.setCellValue(employeeReportResult.getNationalArea());
    59.                 cell.setCellStyle(styles[4]);
    60.                 // 护照号,
    61.                 cell = row.createCell(5);
    62.                 cell.setCellValue(employeeReportResult.getPassportNo());
    63.                 cell.setCellStyle(styles[5]);
    64.                 // 籍贯,
    65.                 cell = row.createCell(6);
    66.                 cell.setCellValue(employeeReportResult.getNativePlace());
    67.                 cell.setCellStyle(styles[6]);
    68.                 // 生日,
    69.                 cell = row.createCell(7);
    70.                 cell.setCellValue(employeeReportResult.getBirthday());
    71.                 cell.setCellStyle(styles[7]);
    72.                 // 属相,
    73.                 cell = row.createCell(8);
    74.                 cell.setCellValue(employeeReportResult.getZodiac());
    75.                 cell.setCellStyle(styles[8]);
    76.                 // 入职时间,
    77.                 cell = row.createCell(9);
    78.                 cell.setCellValue(employeeReportResult.getTimeOfEntry());
    79.                 cell.setCellStyle(styles[9]);
    80.                 // 离职类型,
    81.                 cell = row.createCell(10);
    82.                 cell.setCellValue(employeeReportResult.getTypeOfTurnover());
    83.                 cell.setCellStyle(styles[10]);
    84.                 // 离职原因,
    85.                 cell = row.createCell(11);
    86.                 cell.setCellValue(employeeReportResult.getReasonsForLeaving());
    87.                 cell.setCellStyle(styles[11]);
    88.                 // 离职时间
    89.                 cell = row.createCell(12);
    90.                 cell.setCellValue(employeeReportResult.getResignationTime());
    91.                 cell.setCellStyle(styles[12]);
    92.             }
    93.         }
    94.         //7.下载
    95.         //3.完成下载
    96.         ByteArrayOutputStream os = new ByteArrayOutputStream();
    97.         wb.write(os);
    98.         new DownloadUtils().download(os,response,month+"人事报表.xlsx");
    99.     }

    骚戴理解：学会了一个小技巧，怎么获取模板数据？

    1. Resource resource = new ClassPathResource("excel-template/hr-demo.xlsx");
    2. FileInputStream fis = new FileInputStream(resource.getFile());
    3. Workbook wb = new XSSFWorkbook(fis);

    同时这里的 for(int i=0;i<10000;i++) 其实是为了造数据，数据库本来查询到的数据有90多条，然后循环10000次自然就是90多万条，接近百万数据量

    自定义工具类

    自定义注解ExcelAttribute

    1. package com.ihrm.domain.poi;
    2.  
    3. import java.lang.annotation.ElementType;
    4. import java.lang.annotation.Retention;
    5. import java.lang.annotation.RetentionPolicy;
    6. import java.lang.annotation.Target;
    7.  
    8. @Retention(RetentionPolicy.RUNTIME)
    9. @Target(ElementType.FIELD)
    10. public @interface ExcelAttribute {
    11.     /** 对应的列名称 */
    12.     String name() default "";
    13.  
    14.     /** 列序号 */
    15.     int sort();
    16.  
    17.     /** 字段类型对应的格式 */
    18.     String format() default "";
    19.  
    20. }

    导出工具类

    1. package com.ihrm.common.poi.utils;
    2.  
    3. import com.ihrm.domain.poi.ExcelAttribute;
    4. import lombok.Getter;
    5. import lombok.Setter;
    6. import org.apache.poi.hssf.usermodel.*;
    7. import org.apache.poi.poifs.filesystem.POIFSFileSystem;
    8. import org.apache.poi.ss.formula.functions.T;
    9. import org.apache.poi.ss.usermodel.*;
    10. import org.apache.poi.xssf.usermodel.XSSFWorkbook;
    11.  
    12. import javax.servlet.http.HttpServletResponse;
    13. import java.io.File;
    14. import java.io.FileOutputStream;
    15. import java.io.IOException;
    16. import java.io.InputStream;
    17. import java.lang.reflect.Field;
    18. import java.net.URLEncoder;
    19. import java.util.ArrayList;
    20. import java.util.LinkedList;
    21. import java.util.List;
    22. import java.util.concurrent.atomic.AtomicInteger;
    23.  
    24. @Getter
    25. @Setter
    26. public class ExcelExportUtil {
    27.  
    28.     private int rowIndex;
    29.     private int styleIndex;
    30.     private String templatePath;
    31.     private Class clazz;
    32.     private  Field fields[];
    33.  
    34.     public ExcelExportUtil(Class clazz,int rowIndex,int styleIndex) {
    35.         this.clazz = clazz;
    36.         this.rowIndex = rowIndex;
    37.         this.styleIndex = styleIndex;
    38.         fields = clazz.getDeclaredFields();
    39.     }
    40.  
    41.     /**
    42.      * 基于注解导出
    43.      */
    44.     public void export(HttpServletResponse response,InputStream is, List objs,String fileName) throws Exception {
    45.  
    46.         XSSFWorkbook workbook = new XSSFWorkbook(is);
    47.         Sheet sheet = workbook.getSheetAt(0);
    48.  
    49.         CellStyle[] styles = getTemplateStyles(sheet.getRow(styleIndex));
    50.  
    51.         AtomicInteger datasAi = new AtomicInteger(rowIndex);
    52.         for (T t : objs) {
    53.             Row row = sheet.createRow(datasAi.getAndIncrement());
    54.             for(int i=0;i
    55.                 Cell cell = row.createCell(i);
    56.                 cell.setCellStyle(styles[i]);
    57.                 for (Field field : fields) {
    58.                     if(field.isAnnotationPresent(ExcelAttribute.class)){
    59.                         field.setAccessible(true);
    60.                         ExcelAttribute ea = field.getAnnotation(ExcelAttribute.class);
    61.                         if(i == ea.sort()) {
    62.                             cell.setCellValue(field.get(t).toString());
    63.                         }
    64.                     }
    65.                 }
    66.             }
    67.         }
    68.         fileName = URLEncoder.encode(fileName, "UTF-8");
    69.         response.setContentType("application/octet-stream");
    70.         response.setHeader("content-disposition", "attachment;filename=" + new String(fileName.getBytes("ISO8859-1")));
    71.         response.setHeader("filename", fileName);
    72.         workbook.write(response.getOutputStream());
    73.     }
    74.  
    75.     public CellStyle[] getTemplateStyles(Row row) {
    76.         CellStyle [] styles = new CellStyle[row.getLastCellNum()];
    77.         for(int i=0;i
    78.             styles[i] = row.getCell(i).getCellStyle();
    79.         }
    80.         return styles;
    81.     }
    82. }

    导入工具类

    1. package com.ihrm.common.poi.utils;
    2.  
    3. import com.ihrm.domain.poi.ExcelAttribute;
    4. import org.apache.poi.hssf.usermodel.*;
    5. import org.apache.poi.poifs.filesystem.POIFSFileSystem;
    6. import org.apache.poi.ss.format.CellFormat;
    7. import org.apache.poi.ss.usermodel.Cell;
    8. import org.apache.poi.ss.usermodel.DateUtil;
    9. import org.apache.poi.ss.usermodel.Row;
    10. import org.apache.poi.ss.usermodel.Sheet;
    11. import org.apache.poi.xssf.usermodel.XSSFWorkbook;
    12.  
    13. import java.io.FileInputStream;
    14. import java.io.InputStream;
    15. import java.lang.reflect.Field;
    16. import java.math.BigDecimal;
    17. import java.text.ParseException;
    18. import java.text.SimpleDateFormat;
    19. import java.util.ArrayList;
    20. import java.util.Date;
    21. import java.util.List;
    22.  
    23.  
    24. public class ExcelImportUtil<T> {
    25.  
    26.     private Class clazz;
    27.     private  Field fields[];
    28.  
    29.     public ExcelImportUtil(Class clazz) {
    30.         this.clazz = clazz;
    31.         fields = clazz.getDeclaredFields();
    32.     }
    33.  
    34.     /**
    35.      * 基于注解读取excel
    36.      */
    37.     public List<T> readExcel(InputStream is, int rowIndex,int cellIndex) {
    38.         List<T> list = new ArrayList<T>();
    39.         T entity = null;
    40.         try {
    41.             XSSFWorkbook workbook = new XSSFWorkbook(is);
    42.             Sheet sheet = workbook.getSheetAt(0);
    43.             // 不准确
    44.             int rowLength = sheet.getLastRowNum();
    45.  
    46.             System.out.println(sheet.getLastRowNum());
    47.             for (int rowNum = rowIndex; rowNum <= sheet.getLastRowNum(); rowNum++) {
    48.                 Row row = sheet.getRow(rowNum);
    49.                 entity = (T) clazz.newInstance();
    50.                 System.out.println(row.getLastCellNum());
    51.                 for (int j = cellIndex; j < row.getLastCellNum(); j++) {
    52.                     Cell cell = row.getCell(j);
    53.                     for (Field field : fields) {
    54.                         if(field.isAnnotationPresent(ExcelAttribute.class)){
    55.                             field.setAccessible(true);
    56.                             ExcelAttribute ea = field.getAnnotation(ExcelAttribute.class);
    57.                             if(j == ea.sort()) {
    58.                                 field.set(entity, covertAttrType(field, cell));
    59.                             }
    60.                         }
    61.                     }
    62.                 }
    63.                 list.add(entity);
    64.             }
    65.         } catch (Exception e) {
    66.             e.printStackTrace();
    67.         }
    68.         return list;
    69.     }
    70.  
    71.  
    72.     /**
    73.      * 类型转换 将cell 单元格格式转为 字段类型
    74.      */
    75.     private Object covertAttrType(Field field, Cell cell) throws Exception {
    76.         String fieldType = field.getType().getSimpleName();
    77.         if ("String".equals(fieldType)) {
    78.             return getValue(cell);
    79.         }else if ("Date".equals(fieldType)) {
    80.             return new SimpleDateFormat("yyyy-MM-dd hh:mm:ss").parse(getValue(cell)) ;
    81.         }else if ("int".equals(fieldType) || "Integer".equals(fieldType)) {
    82.             return Integer.parseInt(getValue(cell));
    83.         }else if ("double".equals(fieldType) || "Double".equals(fieldType)) {
    84.             return Double.parseDouble(getValue(cell));
    85.         }else {
    86.             return null;
    87.         }
    88.     }
    89.  
    90.  
    91.     /**
    92.      * 格式转为String
    93.      * @param cell
    94.      * @return
    95.      */
    96.     public String getValue(Cell cell) {
    97.         if (cell == null) {
    98.             return "";
    99.         }
    100.         switch (cell.getCellType()) {
    101.             case STRING:
    102.                 return cell.getRichStringCellValue().getString().trim();
    103.             case NUMERIC:
    104.                 if (DateUtil.isCellDateFormatted(cell)) {
    105.                     Date dt = DateUtil.getJavaDate(cell.getNumericCellValue());
    106.                     return new SimpleDateFormat("yyyy-MM-dd hh:mm:ss").format(dt);
    107.                 } else {
    108.                     // 防止数值变成科学计数法
    109.                     String strCell = "";
    110.                     Double num = cell.getNumericCellValue();
    111.                     BigDecimal bd = new BigDecimal(num.toString());
    112.                     if (bd != null) {
    113.                         strCell = bd.toPlainString();
    114.                     }
    115.                     // 去除 浮点型 自动加的 .0
    116.                     if (strCell.endsWith(".0")) {
    117.                         strCell = strCell.substring(0, strCell.indexOf("."));
    118.                     }
    119.                     return strCell;
    120.                 }
    121.             case BOOLEAN:
    122.                 return String.valueOf(cell.getBooleanCellValue());
    123.             default:
    124.                 return "";
    125.         }
    126.     }
    127. }

    工具类完成导入导出

    导入数据

    给导入的User实体类上面加上自定义注解 @ExcelAttribute

    1. package com.ihrm.domain.system;
    2.  
    3. import com.fasterxml.jackson.annotation.JsonIgnore;
    4. import com.ihrm.domain.poi.ExcelAttribute;
    5. import lombok.Getter;
    6. import lombok.NoArgsConstructor;
    7. import lombok.Setter;
    8.  
    9. import javax.persistence.*;
    10. import java.io.Serializable;
    11. import java.text.DecimalFormat;
    12. import java.util.Date;
    13. import java.util.HashSet;
    14. import java.util.Set;
    15.  
    16. /**
    17.  * 用户实体类
    18.  */
    19. @Entity
    20. @Table(name = "bs_user")
    21. @Getter
    22. @Setter
    23. @NoArgsConstructor
    24. public class User implements Serializable {
    25.     private static final long serialVersionUID = 4297464181093070302L;
    26.     /**
    27.      * ID
    28.      */
    29.     @Id
    30.     private String id;
    31.     /**
    32.      * 手机号码
    33.      */
    34.     @ExcelAttribute(sort = 2)
    35.     private String mobile;
    36.     /**
    37.      * 用户名称
    38.      */
    39.     @ExcelAttribute(sort = 1)
    40.     private String username;
    41.     /**
    42.      * 密码
    43.      */
    44.     private String password;
    45.  
    46.     /**
    47.      * 启用状态 0为禁用 1为启用
    48.      */
    49.     private Integer enableState;
    50.     /**
    51.      * 创建时间
    52.      */
    53.     private Date createTime;
    54.  
    55.     private String companyId;
    56.  
    57.     private String companyName;
    58.  
    59.     /**
    60.      * 部门ID
    61.      */
    62.     @ExcelAttribute(sort = 6)
    63.     private String departmentId;
    64.  
    65.     /**
    66.      * 入职时间
    67.      */
    68.     @ExcelAttribute(sort = 5)
    69.     private Date timeOfEntry;
    70.  
    71.     /**
    72.      * 聘用形式
    73.      */
    74.     @ExcelAttribute(sort = 4)
    75.     private Integer formOfEmployment;
    76.  
    77.     /**
    78.      * 工号
    79.      */
    80.     @ExcelAttribute(sort = 3)
    81.     private String workNumber;
    82.  
    83.     /**
    84.      * 管理形式
    85.      */
    86.     private String formOfManagement;
    87.  
    88.     /**
    89.      * 工作城市
    90.      */
    91.     private String workingCity;
    92.  
    93.     /**
    94.      * 转正时间
    95.      */
    96.     private Date correctionTime;
    97.  
    98.     /**
    99.      * 在职状态 1.在职  2.离职
    100.      */
    101.     private Integer inServiceStatus;
    102.  
    103.     private String departmentName;
    104.  
    105.     /**
    106.      * level
    107.      *     String
    108.      *          saasAdmin：saas管理员具备所有权限
    109.      *          coAdmin：企业管理（创建租户企业的时候添加）
    110.      *          user：普通用户（需要分配角色）
    111.      */
    112.     private String level;
    113.  
    114.     private String staffPhoto;  //用户头像
    115.  
    116.     public User(Object [] values) {
    117.         //用户名    手机号    工号    聘用 形式    入职 时间    部门编码
    118.         this.username = values[1].toString();
    119.         this.mobile = values[2].toString();
    120.         this.workNumber = new DecimalFormat("#").format(values[3]);
    121.         this.formOfEmployment =((Double) values[4]).intValue();
    122.         this.timeOfEntry = (Date) values[5];
    123.         this.departmentId = values[6].toString(); //部门编码 != 部门id
    124.     }
    125.  
    126.     /**
    127.      *  JsonIgnore
    128.      *     : 忽略json转化
    129.      */
    130.     @JsonIgnore
    131.     @ManyToMany
    132.     @JoinTable(name="pe_user_role",joinColumns={@JoinColumn(name="user_id",referencedColumnName="id")},
    133.             inverseJoinColumns={@JoinColumn(name="role_id",referencedColumnName="id")}
    134.     )
    135.     private Set<Role> roles = new HashSet<Role>();//用户与角色   多对多
    136. }
    • 在UserController中importUser方法用工具类来导入数据
    1.     /**
    2.      * 导入Excel,添加用户
    3.      */
    4.     @RequestMapping(value = "/user/import" , method = RequestMethod.POST)
    5.     public Result importUser(@RequestParam(name = "file") MultipartFile file) throws Exception {
    6.         List<User> list = new ExcelImportUtil(User.class).readExcel(file.getInputStream(), 1, 1);
    7.         //3.批量保存用户
    8.         userService.saveAll(list , companyId , companyName);
    9.         return new Result(ResultCode.SUCCESS);
    10.     }

    骚戴理解：这里也只要知道怎么用这个工具类即可

    • User.class是指的导出实体类的字节码
    • file.getInputStream()是指的传入文件的IO输入流
    • 第一个1是指从模板的第二行开始读数据
    • 第二个1是指从模板的第二列开始读数据

    导出数据

    给导出的实体类上面加上自定义注解 @ExcelAttribute

    1. package com.ihrm.domain.employee.response;
    2.  
    3. import com.ihrm.domain.employee.EmployeeResignation;
    4. import com.ihrm.domain.employee.UserCompanyPersonal;
    5. import com.ihrm.domain.poi.ExcelAttribute;
    6. import lombok.Getter;
    7. import lombok.NoArgsConstructor;
    8. import lombok.Setter;
    9. import lombok.ToString;
    10. import org.springframework.beans.BeanUtils;
    11.  
    12. @Getter
    13. @Setter
    14. @NoArgsConstructor
    15. @ToString
    16. public class EmployeeReportResult {
    17.  
    18.     @ExcelAttribute(sort = 0)
    19.     private String userId;
    20.  
    21.     @ExcelAttribute(sort = 1)
    22.     private String username;
    23.  
    24.     private String departmentName;
    25.  
    26.     @ExcelAttribute(sort = 2)
    27.     private String mobile;
    28.  
    29.     @ExcelAttribute(sort = 9)
    30.     private String timeOfEntry;
    31.  
    32.     private String companyId;
    33.  
    34.     private String sex;
    35.     /**
    36.      * 出生日期
    37.      */
    38.     private String dateOfBirth;
    39.     /**
    40.      * 最高学历
    41.      */
    42.     @ExcelAttribute(sort = 3)
    43.     private String theHighestDegreeOfEducation;
    44.     /**
    45.      * 国家地区
    46.      */
    47.     @ExcelAttribute(sort = 4)
    48.     private String nationalArea;
    49.     /**
    50.      * 护照号
    51.      */
    52.     @ExcelAttribute(sort = 5)
    53.     private String passportNo;
    54.     /**
    55.      * 身份证号
    56.      */
    57.     private String idNumber;
    58.     /**
    59.      * 身份证照片-正面
    60.      */
    61.     private String idCardPhotoPositive;
    62.     /**
    63.      * 身份证照片-背面
    64.      */
    65.     private String idCardPhotoBack;
    66.     /**
    67.      * 籍贯
    68.      */
    69.     @ExcelAttribute(sort = 6)
    70.     private String nativePlace;
    71.     /**
    72.      * 民族
    73.      */
    74.     private String nation;
    75.     /**
    76.      * 英文名
    77.      */
    78.     private String englishName;
    79.     /**
    80.      * 婚姻状况
    81.      */
    82.     private String maritalStatus;
    83.     /**
    84.      * 员工照片
    85.      */
    86.     private String staffPhoto;
    87.     /**
    88.      * 生日
    89.      */
    90.     @ExcelAttribute(sort = 7)
    91.     private String birthday;
    92.     /**
    93.      * 属相
    94.      */
    95.     @ExcelAttribute(sort = 8)
    96.     private String zodiac;
    97.     /**
    98.      * 年龄
    99.      */
    100.     private String age;
    101.     /**
    102.      * 星座
    103.      */
    104.     private String constellation;
    105.     /**
    106.      * 血型
    107.      */
    108.     private String bloodType;
    109.     /**
    110.      * 户籍所在地
    111.      */
    112.     private String domicile;
    113.     /**
    114.      * 政治面貌
    115.      */
    116.     private String politicalOutlook;
    117.     /**
    118.      * 入党时间
    119.      */
    120.     private String timeToJoinTheParty;
    121.     /**
    122.      * 存档机构
    123.      */
    124.     private String archivingOrganization;
    125.     /**
    126.      * 子女状态
    127.      */
    128.     private String stateOfChildren;
    129.     /**
    130.      * 子女有无商业保险
    131.      */
    132.     private String doChildrenHaveCommercialInsurance;
    133.     /**
    134.      * 有无违法违纪行为
    135.      */
    136.     private String isThereAnyViolationOfLawOrDiscipline;
    137.     /**
    138.      * 有无重大病史
    139.      */
    140.     private String areThereAnyMajorMedicalHistories;
    141.     /**
    142.      * QQ
    143.      */
    144.     private String qq;
    145.     /**
    146.      * 微信
    147.      */
    148.     private String wechat;
    149.     /**
    150.      * 居住证城市
    151.      */
    152.     private String residenceCardCity;
    153.     /**
    154.      * 居住证办理日期
    155.      */
    156.     private String dateOfResidencePermit;
    157.     /**
    158.      * 居住证截止日期
    159.      */
    160.     private String residencePermitDeadline;
    161.     /**
    162.      * 现居住地
    163.      */
    164.     private String placeOfResidence;
    165.     /**
    166.      * 通讯地址
    167.      */
    168.     private String postalAddress;
    169.     /**
    170.      * 联系手机
    171.      */
    172.     private String contactTheMobilePhone;
    173.     /**
    174.      * 个人邮箱
    175.      */
    176.     private String personalMailbox;
    177.     /**
    178.      * 紧急联系人
    179.      */
    180.     private String emergencyContact;
    181.     /**
    182.      * 紧急联系电话
    183.      */
    184.     private String emergencyContactNumber;
    185.     /**
    186.      * 社保电脑号
    187.      */
    188.     private String socialSecurityComputerNumber;
    189.     /**
    190.      * 公积金账号
    191.      */
    192.     private String providentFundAccount;
    193.     /**
    194.      * 银行卡号
    195.      */
    196.     private String bankCardNumber;
    197.     /**
    198.      * 开户行
    199.      */
    200.     private String openingBank;
    201.     /**
    202.      * 学历类型
    203.      */
    204.     private String educationalType;
    205.     /**
    206.      * 毕业学校
    207.      */
    208.     private String graduateSchool;
    209.     /**
    210.      * 入学时间
    211.      */
    212.     private String enrolmentTime;
    213.     /**
    214.      * 毕业时间
    215.      */
    216.     private String graduationTime;
    217.     /**
    218.      * 专业
    219.      */
    220.     private String major;
    221.     /**
    222.      * 毕业证书
    223.      */
    224.     private String graduationCertificate;
    225.     /**
    226.      * 学位证书
    227.      */
    228.     private String certificateOfAcademicDegree;
    229.     /**
    230.      * 上家公司
    231.      */
    232.     private String homeCompany;
    233.     /**
    234.      * 职称
    235.      */
    236.     private String title;
    237.     /**
    238.      * 简历
    239.      */
    240.     private String resume;
    241.     /**
    242.      * 有无竞业限制
    243.      */
    244.     private String isThereAnyCompetitionRestriction;
    245.     /**
    246.      * 前公司离职证明
    247.      */
    248.     private String proofOfDepartureOfFormerCompany;
    249.     /**
    250.      * 备注
    251.      */
    252.     private String remarks;
    253.  
    254.     /**
    255.      * 离职时间
    256.      */
    257.     @ExcelAttribute(sort = 12)
    258.     private String resignationTime;
    259.     /**
    260.      * 离职类型
    261.      */
    262.     @ExcelAttribute(sort = 10)
    263.     private String typeOfTurnover;
    264.     /**
    265.      * 申请离职原因
    266.      */
    267.     @ExcelAttribute(sort = 11)
    268.     private String reasonsForLeaving;
    269.  
    270.     public EmployeeReportResult(UserCompanyPersonal personal, EmployeeResignation resignation) {
    271.         BeanUtils.copyProperties(personal,this);
    272.         if(resignation != null) {
    273.             BeanUtils.copyProperties(resignation,this);
    274.         }
    275.     }
    276. }

    骚戴理解： @ExcelAttribute注解就是用来定义实体类属性在模板中列的位置，例如模板中姓名对应的列号是1，所以 @ExcelAttribute(sort = 1) private String username;里的sort = 1，注意列号是从0开始的

    在export方法里使用导入工具类

    1.     @RequestMapping(value = "/export/{month}", method = RequestMethod.GET)
    2.     public void export(@PathVariable String month) throws Exception {
    3.         //1.获取报表数据
    4.         List<EmployeeReportResult> list = userCompanyPersonalService.findByReport(companyId,month+"%");
    5.  
    6.         //2.加载模板
    7.         Resource resource = new ClassPathResource("excel-template/hr-demo.xlsx");
    8.         FileInputStream fis = new FileInputStream(resource.getFile());
    9.  
    10.         //3.通过工具类完成下载
    11.         new ExcelExportUtil(EmployeeReportResult.class,2,2).
    12.                 export(response,fis,list,month+"人事报表.xlsx");
    13.  
    14. }

    骚戴理解：下面的工具类会用就行，知道传入的参数是什么就可以了

    new ExcelExportUtil(EmployeeReportResult.class,2,2).export(response,fis,list,month+"人事报表.xlsx");
    • EmployeeReportResult.class是导出的实体类的字节码，也就是从数据库中查询到的数据集合的实体类的字节码
    • 第一个2是指的行号，也就是把数据集合中的数据从第几行开始写到Excel表格中，注意这个2是指的把数据从第3行开始写入，因为下标是从0开始的
    • 第二个2是指的样式的行号，可以看到我希望所有的数据样式都是如下面的第三行的样式一样，所以这个2是指的第三行的样式

    • response其实就是HttpServletResponse
    • fis是模板样式的文件输入IO流
     FileInputStream fis = new FileInputStream(resource.getFile());
    • list是需要导出数据库中查询到的所有集合数据
      List<EmployeeReportResult> list = userCompanyPersonalService.findByReport(companyId,month+"%");
    • month+"人事报表.xlsx"是导出文件的名称

    百万数据报表概述

    概述

    我们都知道Excel可以分为早期的Excel2003版本（使用POI的HSSF对象操作）和Excel2007版本（使用POI的XSSF 操作），两者对百万数据的支持如下：

    • Excel 2003：在POI中使用HSSF对象时，excel 2003最多只允许存储65536条数据，一般用来处理较少的数据量。这时对于百万级别数据，Excel肯定容纳不了。
    • Excel 2007：当POI升级到XSSF对象时，它可以直接支持excel2007以上版本，因为它采用ooxml格式。这时excel可以支持1048576条数据，单个sheet表就支持近百万条数据。但实际运行时还可能存在问题，原因是执 行POI报表所产生的行对象，单元格对象，字体对象，他们都不会销毁，这就导致OOM的风险。

    JDK性能监控工具介绍

    没有性能监控工具一切推论都只能停留在理论阶段，我们可以使用Java的性能监控工具来监视程序的运行情况，包 括CUP,垃圾回收，内存的分配和使用情况，这让程序的运行阶段变得更加可控，也可以用来证明我们的推测。这里我们使用JDK提供的性能工具Jvisualvm来监控程序运行。

    Jvisualvm概述

    VisualVM 是Netbeans的profile子项目，已在JDK6.0 update 7 中自带，能够监控线程，内存情况，查看方法的CPU时间和内存中的对 象，已被GC的对象，反向查看分配的堆栈

    Jvisualvm的位置

    Jvisualvm位于JAVA_HOME/bin目录下，直接双击就可以打开该程序。如果只是监控本地的java进程，是不需要配 置参数的，直接打开就能够进行监控。首先我们需要在本地打开一个Java程序，例如我打开员工微服务进程，这时 在jvisualvm界面就可以看到与IDEA相关的Java进程了：

    骚戴理解：我的Jvisualvm默认路径在C:\Program Files\Java\jdk1.8.0_351\bin\jvisualvm.exe

    Jvisualvm的使用

    Jvisualvm使用起来比较简单，双击点击当前运行的进程即可进入到程序的监控界面

    概述：可以看到进程的启动参数。

    监视：

    • 左上：cpu利用率，gc状态的监控
    • 右上：堆利用率，永久内存区的利用率
    • 左下：类的监控
    • 右下： 线程的监控

    线程：能够显示线程的名称和运行的状态，在调试多线程时必不可少，而且可以点进一个线程查看这个线程 的详细运行情况

    解决方案分析

    对于百万数据量的Excel导入导出，只讨论基于Excel2007的解决方法。在ApachePoi 官方提供了对操作大数据量的导入导出的工具和解决办法，操作Excel2007使用XSSF对象，可以分为三种模式：

    • 用户模式：用户模式有许多封装好的方法操作简单，但创建太多的对象，非常耗内存（之前使用的方法）
    • 事件模式：基于SAX方式解析XML，SAX全称Simple API for XML，它是一个接口，也是一个软件包。它是一种XML解析的替代方法，不同于DOM解析XML文档时把所有内容一次性加载到内存中的方式，它逐行扫描文 档，一边扫描，一边解析。
    • SXSSF对象：是用来生成海量excel数据文件，主要原理是借助临时存储空间生成excel

    这是一张Apache POI官方提供的图片，描述了基于用户模式，事件模式，以及使用SXSSF三种方式操作Excel的特性以及CUP和内存占用情况。

    骚戴理解：用户模式就是之前写的那种代码就是用户模式，如下所示就是用户模式

    1.    /**
    2.      * 采用模板打印的形式完成报表生成
    3.      *      模板
    4.      *  参数：
    5.      *      年月-月（2018-02%）
    6.      *
    7.      *      sxssf对象不支持模板打印
    8.      */
    9.     @RequestMapping(value = "/export/{month}", method = RequestMethod.GET)
    10.     public void export(@PathVariable String month) throws Exception {
    11.         //1.获取报表数据
    12.         List<EmployeeReportResult> list = userCompanyPersonalService.findByReport(companyId,month);
    13.  
    14.         //2.加载模板
    15.         Resource resource = new ClassPathResource("excel-template/hr-demo.xlsx");
    16.         FileInputStream fis = new FileInputStream(resource.getFile());
    17.  
    18.         //3.通过工具类完成下载
    19. //        new ExcelExportUtil(EmployeeReportResult.class,2,2).
    20. //                export(response,fis,list,month+"人事报表.xlsx");
    21.  
    22.  
    23.         //3.根据模板创建工作簿
    24.         Workbook wb = new XSSFWorkbook(fis);
    25.         //4.读取工作表
    26.         Sheet sheet = wb.getSheetAt(0);
    27.         //5.抽取公共样式
    28.         Row row = sheet.getRow(2);
    29.         CellStyle styles [] = new CellStyle[row.getLastCellNum()];
    30.         for(int i=0;i<row.getLastCellNum();i++) {
    31.             Cell cell = row.getCell(i);
    32.             styles[i] = cell.getCellStyle();
    33.         }
    34.         //6.构造单元格
    35.         int rowIndex = 2;
    36.         Cell cell=null;
    37.         for(int i=0;i<10000;i++) {
    38.             for (EmployeeReportResult employeeReportResult : list) {
    39.                 row = sheet.createRow(rowIndex++);
    40.                 // 编号,
    41.                 cell = row.createCell(0);
    42.                 cell.setCellValue(employeeReportResult.getUserId());
    43.                 cell.setCellStyle(styles[0]);
    44.                 // 姓名,
    45.                 cell = row.createCell(1);
    46.                 cell.setCellValue(employeeReportResult.getUsername());
    47.                 cell.setCellStyle(styles[1]);
    48.                 // 手机,
    49.                 cell = row.createCell(2);
    50.                 cell.setCellValue(employeeReportResult.getMobile());
    51.                 cell.setCellStyle(styles[2]);
    52.                 // 最高学历,
    53.                 cell = row.createCell(3);
    54.                 cell.setCellValue(employeeReportResult.getTheHighestDegreeOfEducation());
    55.                 cell.setCellStyle(styles[3]);
    56.                 // 国家地区,
    57.                 cell = row.createCell(4);
    58.                 cell.setCellValue(employeeReportResult.getNationalArea());
    59.                 cell.setCellStyle(styles[4]);
    60.                 // 护照号,
    61.                 cell = row.createCell(5);
    62.                 cell.setCellValue(employeeReportResult.getPassportNo());
    63.                 cell.setCellStyle(styles[5]);
    64.                 // 籍贯,
    65.                 cell = row.createCell(6);
    66.                 cell.setCellValue(employeeReportResult.getNativePlace());
    67.                 cell.setCellStyle(styles[6]);
    68.                 // 生日,
    69.                 cell = row.createCell(7);
    70.                 cell.setCellValue(employeeReportResult.getBirthday());
    71.                 cell.setCellStyle(styles[7]);
    72.                 // 属相,
    73.                 cell = row.createCell(8);
    74.                 cell.setCellValue(employeeReportResult.getZodiac());
    75.                 cell.setCellStyle(styles[8]);
    76.                 // 入职时间,
    77.                 cell = row.createCell(9);
    78.                 cell.setCellValue(employeeReportResult.getTimeOfEntry());
    79.                 cell.setCellStyle(styles[9]);
    80.                 // 离职类型,
    81.                 cell = row.createCell(10);
    82.                 cell.setCellValue(employeeReportResult.getTypeOfTurnover());
    83.                 cell.setCellStyle(styles[10]);
    84.                 // 离职原因,
    85.                 cell = row.createCell(11);
    86.                 cell.setCellValue(employeeReportResult.getReasonsForLeaving());
    87.                 cell.setCellStyle(styles[11]);
    88.                 // 离职时间
    89.                 cell = row.createCell(12);
    90.                 cell.setCellValue(employeeReportResult.getResignationTime());
    91.                 cell.setCellStyle(styles[12]);
    92.             }
    93.         }
    94.         //7.下载
    95.         //3.完成下载
    96.         ByteArrayOutputStream os = new ByteArrayOutputStream();
    97.         wb.write(os);
    98.         new DownloadUtils().download(os,response,month+"人事报表.xlsx");
    99.     }

    事件模式适用于大数据量的导入操作，SXSSF对象适用于大数据量的导出操作

    百万数据报表导出

    需求分析

    使用Apache POI完成百万数据量的Excel报表导出

    解决方案

    思路分析

    基于XSSFWork导出Excel报表，是通过将所有单元格对象保存到内存中，当所有的Excel单元格全部创建完成之后 一次性写入到Excel并导出。当百万数据级别的Excel导出时，随着表格的不断创建，内存中对象越来越多，直至内 存溢出。Apache Poi提供了SXSSFWork对象，专门用于处理大数据量Excel报表导出。

    原理分析

    在实例化SXSSFWork这个对象时，可以指定在内存中所产生的POI导出相关对象的数量（默认100），一旦内存中的对象的个数达到这个指定值时，就将内存中的这些对象的内容写入到磁盘中（XML的临时文件格式），就可以将这些对象从内存中销毁，以后只要达到这个值，就会以类似的处理方式处理，直至Excel导出完成。

    代码实现

    在原有代码的基础上替换之前的XSSFWorkbook，使用SXSSFWorkbook完成创建过程即可

    1.    /**
    2.      * 采用模板打印的形式完成报表生成
    3.      *      模板
    4.      *  参数：
    5.      *      年月-月（2018-02%）
    6.      *
    7.      *      sxssf对象不支持模板打印
    8.      */
    9.     @RequestMapping(value = "/export/{month}", method = RequestMethod.GET)
    10.     public void export(@PathVariable String month) throws Exception {
    11.         //1.获取报表数据
    12.         List<EmployeeReportResult> list = userCompanyPersonalService.findByReport(companyId,month);
    13.  
    14.         //2.加载模板
    15.         Resource resource = new ClassPathResource("excel-template/hr-demo.xlsx");
    16.         FileInputStream fis = new FileInputStream(resource.getFile());
    17.  
    18.         //3.通过工具类完成下载
    19. //        new ExcelExportUtil(EmployeeReportResult.class,2,2).
    20. //                export(response,fis,list,month+"人事报表.xlsx");
    21.  
    22.  
    23.         //3.根据模板创建工作簿
    24.         SXSSFWorkbook wb = new SXSSFWorkbook(fis);
    25.         //4.读取工作表
    26.         Sheet sheet = wb.getSheetAt(0);
    27.         //5.抽取公共样式
    28.         Row row = sheet.getRow(2);
    29.         CellStyle styles [] = new CellStyle[row.getLastCellNum()];
    30.         for(int i=0;i<row.getLastCellNum();i++) {
    31.             Cell cell = row.getCell(i);
    32.             styles[i] = cell.getCellStyle();
    33.         }
    34.         //6.构造单元格
    35.         int rowIndex = 2;
    36.         Cell cell=null;
    37.         for(int i=0;i<10000;i++) {
    38.             for (EmployeeReportResult employeeReportResult : list) {
    39.                 row = sheet.createRow(rowIndex++);
    40.                 // 编号,
    41.                 cell = row.createCell(0);
    42.                 cell.setCellValue(employeeReportResult.getUserId());
    43.                 cell.setCellStyle(styles[0]);
    44.                 // 姓名,
    45.                 cell = row.createCell(1);
    46.                 cell.setCellValue(employeeReportResult.getUsername());
    47.                 cell.setCellStyle(styles[1]);
    48.                 // 手机,
    49.                 cell = row.createCell(2);
    50.                 cell.setCellValue(employeeReportResult.getMobile());
    51.                 cell.setCellStyle(styles[2]);
    52.                 // 最高学历,
    53.                 cell = row.createCell(3);
    54.                 cell.setCellValue(employeeReportResult.getTheHighestDegreeOfEducation());
    55.                 cell.setCellStyle(styles[3]);
    56.                 // 国家地区,
    57.                 cell = row.createCell(4);
    58.                 cell.setCellValue(employeeReportResult.getNationalArea());
    59.                 cell.setCellStyle(styles[4]);
    60.                 // 护照号,
    61.                 cell = row.createCell(5);
    62.                 cell.setCellValue(employeeReportResult.getPassportNo());
    63.                 cell.setCellStyle(styles[5]);
    64.                 // 籍贯,
    65.                 cell = row.createCell(6);
    66.                 cell.setCellValue(employeeReportResult.getNativePlace());
    67.                 cell.setCellStyle(styles[6]);
    68.                 // 生日,
    69.                 cell = row.createCell(7);
    70.                 cell.setCellValue(employeeReportResult.getBirthday());
    71.                 cell.setCellStyle(styles[7]);
    72.                 // 属相,
    73.                 cell = row.createCell(8);
    74.                 cell.setCellValue(employeeReportResult.getZodiac());
    75.                 cell.setCellStyle(styles[8]);
    76.                 // 入职时间,
    77.                 cell = row.createCell(9);
    78.                 cell.setCellValue(employeeReportResult.getTimeOfEntry());
    79.                 cell.setCellStyle(styles[9]);
    80.                 // 离职类型,
    81.                 cell = row.createCell(10);
    82.                 cell.setCellValue(employeeReportResult.getTypeOfTurnover());
    83.                 cell.setCellStyle(styles[10]);
    84.                 // 离职原因,
    85.                 cell = row.createCell(11);
    86.                 cell.setCellValue(employeeReportResult.getReasonsForLeaving());
    87.                 cell.setCellStyle(styles[11]);
    88.                 // 离职时间
    89.                 cell = row.createCell(12);
    90.                 cell.setCellValue(employeeReportResult.getResignationTime());
    91.                 cell.setCellStyle(styles[12]);
    92.             }
    93.         }
    94.         //7.下载
    95.         //3.完成下载
    96.         ByteArrayOutputStream os = new ByteArrayOutputStream();
    97.         wb.write(os);
    98.         new DownloadUtils().download(os,response,month+"人事报表.xlsx");
    99.     }

    对比测试

    • XSSFWorkbook生成百万数据报表

    使用XSSFWorkbook生成Excel报表，时间较长，随着时间推移，内存占用原来越多，直至内存溢出

    • SXSSFWorkbook生成百万数据报表

    使用SXSSFWorkbook生成Excel报表，内存占用比较平缓

    骚戴理解：可以看到SXSSFWorkbook的堆内存变化，即蓝色的曲线图，可以看出它是一个个的山峰一样的图形，上升后会下降，下降的原因是因为对象达到了SXSSFWorkbook设置的阈值，默认是100，也就是达到了100个对象后就会把对象写到临时的xml文件里面，然后销毁掉内存中的这部分对象，所以才会下降，这样的确可以实现百万数据量的导出，但是也是有一些问题的，由于内存速度速度和磁盘速度是不一样的，首先主线程会把所有的对象创建好放到内存里，然后达到阈值才会写入xml临时文件，这是两个过程，然后通常内存写入的速度远远快于磁盘写入xml临时文件的速度，所以如果数据量是很多，例如千万级别的数据量的时候还是会把内存给挤爆，然后报错OOM内存溢出！

    百万数据报表读取

    需求分析

    使用POI基于事件模式解析案例提供的Excel文件

    解决方案

    思路分析

    用户模式：加载并读取Excel时，是通过一次性的将所有数据加载到内存中再去解析每个单元格内容。当Excel 数据量较大时，由于不同的运行环境可能会造成内存不足甚至OOM异常。

    事件模式：它逐行扫描文档，一边扫描一边解析。由于应用程序只是在读取数据时检查数据，因此不需要将数据完全存储在内存中，这对于大型文档的解析是个巨大优势。

    步骤分析

    • 设置POI的事件模式
      • 根据Excel获取文件流
      • 根据文件流创建OPCPackage
      • 创建XSSFReader对象
    • Sax解析
      • 自定义Sheet处理器
      • 创建Sax的XmlReader对象
      • 设置Sheet的事件处理器
      • 逐行读取

    原理分析

    我们都知道对于Excel2007的实质是一种特殊的XML存储数据，那就可以使用基于SAX的方式解析XML完成Excel的读取。SAX提供了一种从XML文档中读取数据的机制。它逐行扫描文档，一边扫描一边解析。由于应用程序只是在读取数据时检查数据，因此不需要将数据完全存储在内存中，这对于大型文档的解析是个巨大优势

    骚戴理解：事件驱动就是一边解析一边用，所以数据不完全放内存里，即拿即用，用完就删，所以对内存的占用很少，但是只能解析一次，因为数据会被删掉，不可逆！

    代码实现

    自定义处理器

    1. package cn.itcast.poi.entity.cn.itcast.poi.handler;
    2.  
    3. import cn.itcast.poi.entity.PoiEntity;
    4. import org.apache.poi.xssf.eventusermodel.XSSFSheetXMLHandler;
    5. import org.apache.poi.xssf.usermodel.XSSFComment;
    6.  
    7. /**
    8.  * 自定义的事件处理器
    9.  *  处理每一行数据读取
    10.  *      实现接口
    11.  */
    12. public class SheetHandler implements XSSFSheetXMLHandler.SheetContentsHandler {
    13.  
    14.     private PoiEntity entity;
    15.     /**
    16.      * 当开始解析某一行的时候触发
    17.      *      i:行索引
    18.      */
    19.     @Override
    20.     public void startRow(int i) {
    21.         //实例化对象
    22.         if(i>0) {
    23.             entity = new PoiEntity();
    24.         }
    25.     }
    26.  
    27.     /**
    28.      * 当结束解析某一行的时候触发
    29.      *      i:行索引
    30.      */
    31.     @Override
    32.     public void endRow(int i) {
    33.         //使用对象进行业务操作
    34.         System.out.println(entity);
    35.     }
    36.  
    37.     /**
    38.      * 对行中的每一个表格进行处理
    39.      *      cellReference: 单元格名称
    40.      *      value：数据
    41.      *      xssfComment：批注
    42.      */
    43.     @Override
    44.     public void cell(String cellReference, String value, XSSFComment xssfComment) {
    45.         //对对象属性赋值
    46.         if(entity != null) {
    47.             String pix = cellReference.substring(0,1);
    48.             switch (pix) {
    49.                 case "A":
    50.                     entity.setId(value);
    51.                     break;
    52.                 case "B":
    53.                     entity.setBreast(value);
    54.                     break;
    55.                 case "C":
    56.                     entity.setAdipocytes(value);
    57.                     break;
    58.                 case "D":
    59.                     entity.setNegative(value);
    60.                     break;
    61.                 case "E":
    62.                     entity.setStaining(value);
    63.                     break;
    64.                 case "F":
    65.                     entity.setSupportive(value);
    66.                     break;
    67.                 default:
    68.                     break;
    69.             }
    70.         }
    71.     }
    72. }

    骚戴理解：String pix = cellReference.substring(0,1);是获取单元格名称的第一个字符，也就是标识列名的字母。在Excel中，单元格名称通常由列名字母和行号组成（例如A1、B2等），这里使用substring方法截取单元格名称的第一个字符来标识列名从而确定对应属性进行赋值操作。

    自定义解析

    1. package cn.itcast.poi.test;
    2.  
    3. import cn.itcast.poi.entity.cn.itcast.poi.handler.SheetHandler;
    4. import org.apache.poi.openxml4j.exceptions.InvalidFormatException;
    5. import org.apache.poi.openxml4j.opc.OPCPackage;
    6. import org.apache.poi.openxml4j.opc.PackageAccess;
    7. import org.apache.poi.xssf.eventusermodel.XSSFReader;
    8. import org.apache.poi.xssf.eventusermodel.XSSFSheetXMLHandler;
    9. import org.apache.poi.xssf.model.SharedStringsTable;
    10. import org.apache.poi.xssf.model.StylesTable;
    11. import org.apache.poi.xssf.usermodel.XSSFWorkbook;
    12. import org.xml.sax.InputSource;
    13. import org.xml.sax.XMLReader;
    14. import org.xml.sax.helpers.XMLReaderFactory;
    15.  
    16. import java.io.InputStream;
    17. import java.util.Iterator;
    18.  
    19. /**
    20.  * 使用事件模型解析百万数据excel报表
    21.  */
    22. public class PoiTest06 {
    23.  
    24.     public static void main(String[] args) throws Exception {
    25.         String path = "C:\\Users\\ThinkPad\\Desktop\\ihrm\\day8\\资源\\百万数据报表\\demo.xlsx";
    26.  
    27.         //1.根据excel报表获取OPCPackage
    28.         OPCPackage opcPackage = OPCPackage.open(path, PackageAccess.READ);
    29.         //2.创建XSSFReader
    30.         XSSFReader reader = new XSSFReader(opcPackage);
    31.         //3.获取SharedStringTable对象
    32.         SharedStringsTable table = reader.getSharedStringsTable();
    33.         //4.获取styleTable对象
    34.         StylesTable stylesTable = reader.getStylesTable();
    35.         //5.创建Sax的xmlReader对象
    36.         XMLReader xmlReader = XMLReaderFactory.createXMLReader();
    37.         //6.注册事件处理器
    38.         XSSFSheetXMLHandler xmlHandler = new XSSFSheetXMLHandler(stylesTable,table,new SheetHandler(),false);
    39.         xmlReader.setContentHandler(xmlHandler);
    40.         //7.逐行读取
    41.         XSSFReader.SheetIterator sheetIterator = (XSSFReader.SheetIterator) reader.getSheetsData();
    42.         while (sheetIterator.hasNext()) {
    43.             InputStream stream = sheetIterator.next(); //每一个sheet的流数据
    44.             InputSource is = new InputSource(stream);
    45.             xmlReader.parse(is);
    46.         }
    47.     }
    48. }

    骚戴理解：

    • OPCPackage opcPackage = OPCPackage.open(path, PackageAccess.READ);这行代码的作用是打开并读取一个指定路径的Office Open XML (OOXML)包文件，该文件通常是.xlsx或.xlsm格式的Excel文件。具体来说，OPCPackage类可以从本地文件系统、InputStream或URL中打开OOXML包，并提供了读取、修改和创建OOXML文档的方法。其中，path参数表示要打开的OOXML包文件的路径；PackageAccess.READ表示采用仅读取模式的方式打开该文件。通过OPCPackage对象的实例，Java程序可以访问包中的各种元素，如workbook、sharedStrings等，以及它们的内容，继而进行相应的处理操作。
    • XSSFReader reader = new XSSFReader(opcPackage);这行代码的作用是基于已打开的OOXML包文件，创建一个XSSFReader对象。在Apache POI中，XSSFReader类是用于读取Excel2007及以上版本文件（即.xlsx格式）的类，提供了对工作簿、工作表和单元格等元素的读取操作。reader变量是一个XSSFReader对象的引用，可以通过它访问某个.xlsx文件的所有部件（Parts）并读取其中的数据内容，如工作簿、电子表格、样式集等。具体来说，该代码中的opcPackage参数表示已经打开的.xlsx文件所对应的OPCPackage对象。通过该对象创建XSSFReader对象之后，程序就可以通过调用XSSFReader对象的相应方法，完成Excel文件的解析和读取工作。
    • SharedStringsTable table = reader.getSharedStringsTable();这行代码的作用是通过XSSFReader对象获取Excel文件中的共享字符串表（SharedStringsTable）对象。在Excel2007及以上版本中，相比于早期的.xls格式，.xlsx格式的文件更加节省空间，其中一个原因是采用了共享字符串表来存储重复的字符串值，而非直接将它们写入每个单元格。共享字符串表主要用于存储文本型数据类型，包括文字和数字等。因此，在解析.xlsx格式的文件时，需要先将其包含的共享字符串表加载到内存中，才能通过索引查找对应字符串并读取单元格的值。该代码中的reader参数表示已经创建的XSSFReader对象，程序通过调用其getSharedStringsTable()方法，可以获取Excel文件中的共享字符串表对象，从而实现读取其中存储的字符串值及其索引的功能。得到共享字符串表对象之后，程序可以根据需要使用它的API进行相关的字符串操作，如添加、删除、修改、查询等。
    • StylesTable stylesTable = reader.getStylesTable();这行代码的作用是通过XSSFReader对象获取Excel2007及以上版本文件中的样式表（StylesTable）对象。在Excel文件中，单元格的样式是由一系列属性和特征组成的。通常情况下，如果多个单元格具有相同的样式属性，则可以将它们定义为一个公共的样式引用，并在样式表中记录它们所包含的所有属性信息。样式表主要用于描述单元格、字体、背景色、边框、对齐方式等样式的各种属性和特征。该代码中的reader参数表示已经创建的XSSFReader对象，程序通过调用其getStylesTable()方法，可以获取Excel文件中的样式表对象，从而实现读取其中存储的样式信息的功能。得到样式表对象之后，程序可以根据需要使用它的API对样式进行相关的操作，如添加、修改、删除、查询等。获取样式表对象也是解析Excel2007及以上版本文件的关键步骤之一，因为对单元格的格式化和样式设置直接依赖于样式表。
    • XMLReader xmlReader = XMLReaderFactory.createXMLReader();这行代码的作用是创建一个基于SAX（Simple API for XML）实现的XML解析器对象，该解析器由Java自带的XMLReaderFactory工厂类生成。在Java中，处理XML文档通常有两种方式：DOM和SAX。其中，DOM是一种基于树形结构的解析方式，可以将整个XML文档加载到内存中，并以树形结构表示出来；而SAX则是一种基于事件驱动的解析方式，它会在XML文件解析时产生一系列的事件，我们可以注册回调方法来获取并处理这些事件。由于SAX不需要将XML文档完全加载到内存中，所以对于大型XML文件的处理更加高效和灵活。该代码中使用了Java标准库提供的XMLReaderFactory类生成一个默认配置的SAX解析器对象xmlReader，程序可以通过该对象的相关API实现读取和解析Excel2007及以上版本的xlsx文件。通常情况下，在通过XSSFReader对象获取Excel文件各个部分数据之前，需要先通过该解析器对象将对应部分的XML内容解析为可读格式，再调用相应API进行访问和操作。
    1.  XSSFSheetXMLHandler xmlHandler = new XSSFSheetXMLHandler(stylesTable,table,new SheetHandler(),false);
    2.  xmlReader.setContentHandler(xmlHandler);
    • 这两行代码的作用是将读取到的Excel表格数据与对应的样式信息进行关联，并设置XMLReader对象的内容处理器为XSSFSheetXMLHandler对象，进而实现解析.xlsx文件中单个sheet页数据及其样式的功能。其中，参数stylesTable表示Excel文件的样式表对象（StylesTable），参数table表示Excel文件的 共享字符串表对象（SharedStringsTable）。这两个对象是在之前获取Excel数据（包括字符串和样式）时得到的。参数new SheetHandler()表示自定义的SheetHandler对象，该对象继承自DefaultHandler类，实现了XML文档解析时产生的各种事件的回调方法，以便程序能够相应地读取和处理表格中的数据。参数false表示XSSFSheetXMLHandler对象的构造函数不需要启用日期格式化功能，默认为关闭状态。接着，通过xmlReader.setContentHandler(xmlHandler)方法将XSSFSheetXMLHandler对象设置为XMLReader对象的内容处理器。当程序开始解析Excel文件时，XPath表达式会逐一匹配XML文档中的各个节点，当遇到符合条件的节点时，会触发XMLReader对象相应的解析事件，调用XSSFSheetXMLHandler对象对应的回调方法来进行解析、读取和处理。从而实现读取并解析Excel文件中单个表格页数据及其样式的操作。
    1.     XSSFReader.SheetIterator sheetIterator = (XSSFReader.SheetIterator) reader.getSheetsData();
    2.     while (sheetIterator.hasNext()) {
    3.         InputStream stream = sheetIterator.next(); //每一个sheet的流数据
    4.         InputSource is = new InputSource(stream);
    5.         xmlReader.parse(is);
    6.     }
    • 这行代码的作用是使用XSSFReader对象获取Excel文件中所有sheet页数据流信息，并封装成SheetIterator迭代器对象，以便程序可以遍历和访问其中的每个sheet页。在Excel文件中，一个.xlsx格式的文件通常包含多个sheet页，每个sheet页由若干行和列构成，其中存储着实际的数据内容。为了读取和处理这些数据内容，需要将各个sheet页数据流信息分别提取出来，并进行相应的解析和操作。该代码中，通过调用reader.getSheetsData()方法得到的SheetIterator对象，可以对sheet页数据流进行逐一迭代，并返回每个sheet页数据的相关信息，如名称、ID、XML路径等。程序可以通过该对象的hasNext()方法检查是否还有下一个sheet页待读取，然后再调用next()方法获取当前sheet页的输入流（InputStream），并对其进行相应的数据读取和解析。在while循环中，每次从迭代器中获取当前sheet页的输入流，并创建一个InputSource对象，以帮助XMLReader对象解析该输入流。然后调用xmlReader.parse(is)方法启动XMLReader对象解析输入流并触发各种回调事件，程序根据解析得到的事件来读取相应的表格数据和样式信息。由于Excel2007及以上版本采用了基于XML标准的文件格式，故在解析时需要借助SAX解析器进行读取。因此，在解析每个sheet页的XML数据之前，需要通过XSSFSheetXMLHandler对象将各个单元格的值与样式进行匹配。

    对比测试

    用户模式下读取测试Excel文件直接内存溢出，测试Excel文件映射到内存中还是占用了不少内存；事件模式下可以 流畅的运行。

    • 使用用户模型解析

    • 使用事件模型解析

    总结

    通过简单的分析以及运行两种模式进行比较，可以看到用户模式下使用更简单的代码实现了Excel读取，但是在读 取大文件时CPU和内存都不理想；而事件模式虽然代码写起来比较繁琐，但是在读取大文件时CPU和内存更加占优。

  • 相关阅读:
    SpringBoot-27-springSecurity（安全:认证授权）
    20_ue4实现键盘控制物体自转（蓝图通讯2）
    空间数据结构管理---RTree（上篇）
    GO语言网络编程（并发编程）runtime包
    TS编译选项——编译TS文件同时对JS文件进行编译
    eclipse
    解决前端恶意代码侵入的一些思考
    【Linux】进程控制,进程替换
    4种经典的限流算法与集群限流
    宠物之家网站大学生网页制作教程 学生HTML静态宠物网页设计作业成品 DIV布局简单动物网页制作代码
  • 原文地址：https://blog.csdn.net/qq_50954361/article/details/131336227