公司用到了easypoi导出，发现网上关于easypoi合并的例子真的很少，没找到，于是自己研究了下，项目是Spring Boot

    1.     <dependency>
    2.         <groupId>cn.afterturn</groupId>
    3.         <artifactId>easypoi-base</artifactId>
    4.         <version>3.0.1</version>
    5.     </dependency>
    6.     <dependency>
    7.         <groupId>cn.afterturn</groupId>
    8.         <artifactId>easypoi-web</artifactId>
    9.         <version>3.0.1</version>
    10.     </dependency>
    11.     <dependency>
    12.         <groupId>cn.afterturn</groupId>
    13.         <artifactId>easypoi-annotation</artifactId>
    14.         <version>3.0.1</version>
    15.     </dependency>

    合并单元格主要有两个注解
    1、@Excel这个是必不可少的，主要是要有一个参数设置needMerge = true
    源码这样解释的
    image.png
    2、@ExcelCollection此注解用于集合这种的多行
    image.png
    案例: CustomerCluesExportVo
    image.png
    案例：DealInfoExportVo
    image.png
    使用方法

    1. 一方的@Excel设置needMerge = true，框架默认是false,多方List(其他集合)使用@ExcelCollection,@ExcelCollection默认ArrayList


    成品
    image.png
    如有需要，以下两个工具类可以直接使用 EasyPoiUtils

    1. package com.shinedata.util;
    3. import cn.afterturn.easypoi.excel.ExcelExportUtil;
    4. import cn.afterturn.easypoi.excel.ExcelImportUtil;
    5. import cn.afterturn.easypoi.excel.entity.ExportParams;
    6. import cn.afterturn.easypoi.excel.entity.ImportParams;
    7. import cn.afterturn.easypoi.excel.entity.enmus.ExcelType;
    8. import org.apache.commons.lang3.StringUtils;
    9. import org.apache.poi.ss.usermodel.Workbook;
    10. import org.springframework.web.multipart.MultipartFile;
    12. import javax.servlet.http.HttpServletResponse;
    13. import java.io.File;
    14. import java.io.IOException;
    15. import java.io.InputStream;
    16. import java.net.URLEncoder;
    17. import java.util.List;
    18. import java.util.Map;
    19. import java.util.NoSuchElementException;
    21. /**  
    22.  * @Description:导出导入工具类
    23.  * @date 2019年8月21日 下午6:13:54
    24.  */
    25. public class EasyPoiUtils {
    27.     public static void sellerExportExcel(    List<?> list, String title, String sheetName,
    28.                                             Class<?> pojoClass, String fileName,
    29.                                             HttpServletResponse response) {
    30.         defaultExport(list, pojoClass, fileName, response, new ExportParams(title, sheetName));
    31.     }
    33.     /**
    34.      * 功能描述：复杂导出Excel，包括文件名以及表名。创建表头
    35.      *
    36.      * @param list 导出的实体类
    37.      * @param title 表头名称
    38.      * @param sheetName sheet表名
    39.      * @param pojoClass 映射的实体类
    40.      * @param isCreateHeader 是否创建表头
    41.      * @param fileName
    42.      * @param response
    43.      * @return
    44.      */
    45.     public static void exportExcel(    List<?> list, String title, String sheetName, Class<?> pojoClass,
    46.                                     String fileName, boolean isCreateHeader,
    47.                                     HttpServletResponse response) {
    48.         ExportParams exportParams = new ExportParams(title, sheetName);
    49.         exportParams.setCreateHeadRows(isCreateHeader);
    50.         exportParams.setStyle(ExcelStyleUtils.class);
    51.         defaultExport(list, pojoClass, fileName, response, exportParams);
    52.     }
    54.     /**
    55.      * 功能描述：复杂导出Excel，包括文件名以及表名,不创建表头
    56.      *
    57.      * @param list 导出的实体类
    58.      * @param title 表头名称
    59.      * @param sheetName sheet表名
    60.      * @param pojoClass 映射的实体类
    61.      * @param fileName
    62.      * @param response
    63.      * @return
    64.      */
    65.     public static void exportExcel(    List<?> list, String title, String sheetName, Class<?> pojoClass,
    66.                                     String fileName, HttpServletResponse response,
    67.                                     Integer userMasterId) {
    68.         defaultExport(list, pojoClass, fileName, response, new ExportParams(title, sheetName));
    69.     }
    71.     /**
    72.      * 功能描述：Map 集合导出
    73.      *
    74.      * @param list 实体集合
    75.      * @param fileName 导出的文件名称
    76.      * @param response
    77.      * @return
    78.      */
    79.     public static void exportExcel(    List<Map<String, Object>> list, String fileName,
    80.                                     HttpServletResponse response) {
    81.         defaultExport(list, fileName, response);
    82.     }
    84.     /**
    85.      * 功能描述：默认导出方法
    86.      *
    87.      * @param list 导出的实体集合
    88.      * @param fileName 导出的文件名
    89.      * @param pojoClass pojo实体
    90.      * @param exportParams ExportParams封装实体
    91.      * @param response
    92.      * @return
    93.      */
    94.     private static void defaultExport(    List<?> list, Class<?> pojoClass, String fileName,
    95.                                         HttpServletResponse response, ExportParams exportParams) {
    96.         Workbook workbook = ExcelExportUtil.exportExcel(exportParams, pojoClass, list);
    97.         if (workbook != null) {
    98.             downLoadExcel(fileName, response, workbook);
    99.         }
    100.     }
    102.     /**
    103.      * 功能描述：Excel导出
    104.      *
    105.      * @param fileName 文件名称
    106.      * @param response
    107.      * @param workbook Excel对象
    108.      * @return
    109.      */
    110.     private static void downLoadExcel(    String fileName, HttpServletResponse response,
    111.                                         Workbook workbook) {
    112.         try {
    113.             response.setCharacterEncoding("UTF-8");
    114.             response.setHeader("content-Type", "multipart/form-data");
    115.             response.setHeader("Content-Disposition",
    116.                 "attachment;filename=" + URLEncoder.encode(fileName, "UTF-8"));
    117.             workbook.write(response.getOutputStream());
    119.         } catch (IOException e) {
    120.             throw new RuntimeException(e);
    121.         }
    122.     }
    124.     /**
    125.      * 功能描述：默认导出方法
    126.      *
    127.      * @param list 导出的实体集合
    128.      * @param fileName 导出的文件名
    129.      * @param response
    130.      * @return
    131.      */
    132.     private static void defaultExport(    List<Map<String, Object>> list, String fileName,
    133.                                         HttpServletResponse response) {
    134.         Workbook workbook = ExcelExportUtil.exportExcel(list, ExcelType.HSSF);
    135.         if (workbook != null)
    136.             ;
    137.         downLoadExcel(fileName, response, workbook);
    138.     }
    140.     /**
    141.      * 功能描述：根据文件路径来导入Excel
    142.      *
    143.      * @param filePath 文件路径
    144.      * @param titleRows 表标题的行数
    145.      * @param headerRows 表头行数
    146.      * @param pojoClass Excel实体类
    147.      * @return
    148.      */
    149.     public static <T> List<T> importExcel(    String filePath, Integer titleRows, Integer headerRows,
    150.                                             Class<T> pojoClass) {
    151.         //判断文件是否存在
    152.         if (StringUtils.isBlank(filePath)) {
    153.             return null;
    154.         }
    155.         ImportParams params = new ImportParams();
    156.         params.setTitleRows(titleRows);
    157.         params.setHeadRows(headerRows);
    158.         List<T> list = null;
    159.         File file = new File(filePath);
    160.         try {
    161.             list = ExcelImportUtil.importExcel(file, pojoClass, params);
    162.         } catch (NoSuchElementException e) {
    163.             throw new RuntimeException("模板不能为空");
    164.         } catch (Exception e) {
    165.             e.printStackTrace();
    167.         }
    168.         return list;
    169.     }
    171.     /**
    172.      * 功能描述：根据文件流来导入Excel
    173.      *
    174.      * @param filePath 文件路径
    175.      * @param titleRows 表标题的行数
    176.      * @param headerRows 表头行数
    177.      * @param pojoClass Excel实体类
    178.      * @return
    179.      */
    180.     public static <T> List<T> importExcel(    InputStream is, Integer titleRows, Integer headerRows,
    181.                                             Class<T> pojoClass) {
    182.         //判断文件是否存在
    183.         if (is == null) {
    184.             return null;
    185.         }
    186.         ImportParams params = new ImportParams();
    187.         params.setTitleRows(titleRows);
    188.         params.setHeadRows(headerRows);
    189.         List<T> list = null;
    190.         try {
    191.             list = ExcelImportUtil.importExcel(is, pojoClass, params);
    192.         } catch (NoSuchElementException e) {
    193.             throw new RuntimeException("模板不能为空");
    194.         } catch (Exception e) {
    195.             e.printStackTrace();
    197.         }
    198.         return list;
    199.     }
    201.     /**
    202.      * 功能描述：根据接收的Excel文件来导入Excel,并封装成实体类
    203.      *
    204.      * @param file 上传的文件
    205.      * @param titleRows 表标题的行数
    206.      * @param headerRows 表头行数
    207.      * @param pojoClass Excel实体类
    208.      * @return
    209.      */
    210.     public static <T> List<T> importExcel(    MultipartFile file, Integer titleRows, Integer headerRows,
    211.                                             Class<T> pojoClass) {
    212.         if (file == null) {
    213.             return null;
    214.         }
    215.         ImportParams params = new ImportParams();
    216.         params.setTitleRows(titleRows);
    217.         params.setHeadRows(headerRows);
    218.         List<T> list = null;
    219.         try {
    220.             list = ExcelImportUtil.importExcel(file.getInputStream(), pojoClass, params);
    221.         } catch (NoSuchElementException e) {
    222.             throw new RuntimeException("excel文件不能为空");
    223.         } catch (Exception e) {
    224.             throw new RuntimeException(e.getMessage());
    226.         }
    227.         return list;
    228.     }
    229. }

    ExcelStyleUtils

    1. package com.shinedata.util;
    3. import cn.afterturn.easypoi.excel.entity.params.ExcelExportEntity;
    4. import cn.afterturn.easypoi.excel.entity.params.ExcelForEachParams;
    5. import cn.afterturn.easypoi.excel.export.styler.IExcelExportStyler;
    6. import org.apache.poi.ss.usermodel.*;
    8. /**
    9.  * @ClassName ExcelStyleUtils
    10.  * @Date 2020/7/14 15:23
    11.  */
    12. public class ExcelStyleUtils implements IExcelExportStyler {
    14.     private static final short STRING_FORMAT = (short) BuiltinFormats.getBuiltinFormat("TEXT");
    15.     private static final short FONT_SIZE_TEN = 10;
    16.     private static final short FONT_SIZE_ELEVEN = 11;
    17.     private static final short FONT_SIZE_TWELVE = 12;
    18.     /**
    19.      * 大标题样式
    20.      */
    21.     private CellStyle headerStyle;
    22.     /**
    23.      * 每列标题样式
    24.      */
    25.     private CellStyle titleStyle;
    26.     /**
    27.      * 数据行样式
    28.      */
    29.     private CellStyle styles;
    31.     public ExcelStyleUtils(Workbook workbook) {
    32.         this.init(workbook);
    33.     }
    35.     /**
    36.      * 初始化样式
    37.      *
    38.      * @param workbook
    39.      */
    40.     private void init(Workbook workbook) {
    41.         this.headerStyle = initHeaderStyle(workbook);
    42.         this.titleStyle = initTitleStyle(workbook);
    43.         this.styles = initStyles(workbook);
    44.     }
    47.     /**
    48.      * 大标题样式
    49.      *
    50.      * @param color
    51.      * @return
    52.      */
    53.     @Override
    54.     public CellStyle getHeaderStyle(short color) {
    55.         return headerStyle;
    56.     }
    58.     /**
    59.      * 每列标题样式
    60.      *
    61.      * @param color
    62.      * @return
    63.      */
    64.     @Override
    65.     public CellStyle getTitleStyle(short color) {
    66.         return titleStyle;
    67.     }
    69.     /**
    70.      * 数据行样式
    71.      *
    72.      * @param parity 可以用来表示奇偶行
    73.      * @param entity 数据内容
    74.      * @return 样式
    75.      */
    76.     @Override
    77.     public CellStyle getStyles(boolean parity, ExcelExportEntity entity) {
    78.         return styles;
    79.     }
    81.     /**
    82.      * 获取样式方法
    83.      *
    84.      * @param dataRow 数据行
    85.      * @param obj     对象
    86.      * @param data    数据
    87.      */
    88.     public CellStyle getStyles(Cell cell, int dataRow, ExcelExportEntity entity, Object obj, Object data) {
    89.         return getStyles(true, entity);
    90.     }
    92.     /**
    93.      * 模板使用的样式设置
    94.      */
    95.     @Override
    96.     public CellStyle getTemplateStyles(boolean isSingle, ExcelForEachParams excelForEachParams) {
    97.         return null;
    98.     }
    100.     /**
    101.      * 初始化--大标题样式
    102.      *
    103.      * @param workbook
    104.      * @return
    105.      */
    106.     private CellStyle initHeaderStyle(Workbook workbook) {
    107.         CellStyle style = getBaseCellStyle(workbook);
    108.         style.setFont(getFont(workbook, FONT_SIZE_TWELVE, true));
    109.         return style;
    110.     }
    112.     /**
    113.      * 初始化--每列标题样式
    114.      *
    115.      * @param workbook
    116.      * @return
    117.      */
    118.     private CellStyle initTitleStyle(Workbook workbook) {
    119.         CellStyle style = getBaseCellStyle(workbook);
    120.         style.setFont(getFont(workbook, FONT_SIZE_ELEVEN, false));
    121.         //背景色
    122.         style.setFillForegroundColor(IndexedColors.GREY_25_PERCENT.getIndex());
    123.         style.setFillPattern(FillPatternType.SOLID_FOREGROUND);
    124.         return style;
    125.     }
    127.     /**
    128.      * 初始化--数据行样式
    129.      *
    130.      * @param workbook
    131.      * @return
    132.      */
    133.     private CellStyle initStyles(Workbook workbook) {
    134.         CellStyle style = getBaseCellStyle(workbook);
    135.         style.setFont(getFont(workbook, FONT_SIZE_TEN, false));
    136.         style.setDataFormat(STRING_FORMAT);
    137.         return style;
    138.     }
    140.     /**
    141.      * 基础样式
    142.      *
    143.      * @return
    144.      */
    145.     private CellStyle getBaseCellStyle(Workbook workbook) {
    146.         CellStyle style = workbook.createCellStyle();
    147.         //下边框
    148.         style.setBorderBottom(BorderStyle.THIN);
    149.         //左边框
    150.         style.setBorderLeft(BorderStyle.THIN);
    151.         //上边框
    152.         style.setBorderTop(BorderStyle.THIN);
    153.         //右边框
    154.         style.setBorderRight(BorderStyle.THIN);
    155.         //水平居中
    156.         style.setAlignment(HorizontalAlignment.CENTER);
    157.         //上下居中
    158.         style.setVerticalAlignment(VerticalAlignment.CENTER);
    159.         //设置自动换行
    160.         style.setWrapText(true);
    161.         return style;
    162.     }
    164.     /**
    165.      * 字体样式
    166.      *
    167.      * @param size   字体大小
    168.      * @param isBold 是否加粗
    169.      * @return
    170.      */
    171.     private Font getFont(Workbook workbook, short size, boolean isBold) {
    172.         Font font = workbook.createFont();
    173.         //字体样式
    174.         font.setFontName("宋体");
    175.         //是否加粗
    176.         font.setBold(isBold);
    177.         //字体大小
    178.         font.setFontHeightInPoints(size);
    179.         return font;
    180.     }
    181. }

    调用

    1. EasyPoiUtils.exportExcel(exportVos, title, fileName, CustomerCluesExportVo.class, fileName, true, response);

    合并单元格(groupName)
    image.png
    image.png
    image.png