基于Jav POI实现Excel多级表头导出的完整方案

┌──────────┬──────────┬──────────┬────────────────┬───────────────────────┐
│ 所在地区 │ 道路名称 │ 管线类别 │ 手续             │ 财政资金(万元)    │
│          │          │          ├──────────┬─────┼──────────┬──────────┤
│          │          │          │ 批复     │ 许可 │ 预算内   │          │
│          │          │          │ 编码     │ 编码 │ 投资     │ 国债     │
└──────────┴──────────┴──────────┴──────────┴─────┴──────────┴──────────┘

<!-- Apache POI - Excel核心依赖 -->
<dependency>
    <groupId>org.apache.poi</groupId>
    <artifactId>poi</artifactId>
    <version>4.1.2</version>
</dependency>

<!-- Apache POI - XSSF (Excel 2007+) 支持 -->
<dependency>
    <groupId>org.apache.poi</groupId>
    <artifactId>poi-ooxml</artifactId>
    <version>4.1.2</version>
</dependency>

<!-- POI OOXML 依赖的XML解析库 -->
<dependency>
    <groupId>org.apache.poi</groupId>
    <artifactId>poi-ooxml-schemas</artifactId>
    <version>4.1.2</version>
</dependency>

<!-- 流式处理大数据量Excel（关键：避免OOM） -->
<dependency>
    <groupId>org.apache.poi</groupId>
    <artifactId>poi-scratchpad</artifactId>
    <version>4.1.2</version>
</dependency>

<!-- 日期工具依赖（可选，根据项目实际情况调整） -->
<dependency>
    <groupId>cn.hutool</groupId>
    <artifactId>hutool-all</artifactId>
    <version>5.8.20</version>
</dependency>

<!-- Lombok（可选，简化DTO开发） -->
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.30</version>
    <scope>provided</scope>
</dependency>

<!-- Spring Context（可选，项目已引入Spring可忽略） -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.3.29</version>
</dependency>

// Apache POI 核心
implementation 'org.apache.poi:poi:4.1.2'
// Excel 2007+ 支持
implementation 'org.apache.poi:poi-ooxml:4.1.2'
// OOXML 模式支持
implementation 'org.apache.poi:poi-ooxml-schemas:4.1.2'
// 流式处理大数据量
implementation 'org.apache.poi:poi-scratchpad:4.1.2'
// 工具类（可选）
implementation 'cn.hutool:hutool-all:5.8.20'
// Lombok（可选）
compileOnly 'org.projectlombok:lombok:1.18.30'
annotationProcessor 'org.projectlombok:lombok:1.18.30'

package com.tydt.framework.aspectj.lang.annotation;

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

/**
 * 自定义导出Excel数据注解
 *
 * @author tydt
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface Excel
{
    /**
     * 导出时在excel中排序
     */
    int sort() default Integer.MAX_VALUE;

    /**
     * 导出到Excel中的名字
     */
    String name() default "";

    /**
     * 日期格式, 如: yyyy-MM-dd
     */
    String dateFormat() default "";

    /**
     * 读取内容转表达式 (如: 0=男,1=女,2=未知)
     */
    String readConverterExp() default "";

    /**
     * 导出类型（0数字 1字符串）
     */
    ColumnType cellType() default ColumnType.STRING;

    /**
     * 导出时在excel中每个列的高度 单位为字符
     */
    double height() default 14;

    /**
     * 导出时在excel中每个列的宽 单位为字符
     */
    double width() default 16;

    /**
     * 【核心】表头合并配置
     * 格式: "起始行,结束行,起始列,结束列"
     * 例如: "0,0,0,2" 表示第0行第0列到第0行第2列合并
     *      "0,1,0,0" 表示第0行第0列到第1行第0列合并（纵向合并）
     */
    String headerMerge() default "";

    /**
     * 【核心】表头层级（从0开始，用于多级表头）
     */
    int headerLevel() default 0;

    /**
     * 【核心】是否分组表头（用于标识该字段是否为分组表头，不包含实际数据）
     */
    boolean isGroupHeader() default false;

    /**
     * 【核心】合并行
     * 参数1为合并基准列，其他列用逗号拼接，依据基准列进行当前单元行合并
     * 例如: "0" 表示以第0列为基准进行行合并
     */
    String mergeLine() default "";

    /**
     * 是否导出数据,应对需求:有时我们需要导出一份模板,这是标题需要但内容需要用户手工填写
     */
    boolean isExport() default true;

    /**
     * 字段类型（0：导出导入；1：仅导出；2：仅导入）
     */
    Type type() default Type.ALL;

    // 其他辅助配置
    String pattern() default "";
    String suffix() default "";
    String defaultValue() default "";
    String prompt() default "";
    String[] combo() default {};
    String targetAttr() default "";
    int groupHeaderRows() default 1;
    String separator() default "";
    String dictType() default "";
    int scale() default 0;
    int roundingMode() default 0;
    boolean isStatistics() default false;
    String comboDynamic() default "";

    public enum Type
    {
        ALL(0), EXPORT(1), IMPORT(2);
        private final int value;
        Type(int value) { this.value = value; }
        public int value() { return this.value; }
    }

    public enum ColumnType
    {
        NUMERIC(0), STRING(1);
        private final int value;
        ColumnType(int value) { this.value = value; }
        public int value() { return this.value; }
    }
}

package com.itl.project.ssjs.gx.xy.snjhk.domain;

import com.itl.framework.aspectj.lang.annotation.Excel;
import lombok.Data;
import java.util.Date;

/**
 * 导出管线实体类 - 现有道路储备项目库和年度计划库导出Excel模板
 */
@Data
public class ExportDTOSzd {

    // ========== 基础信息字段（纵向合并两行）==========
    // A列 (0) - 所在地区：0-1行纵向合并，作为二级表头
    @Excel(name = "所在地区", headerLevel = 1, headerMerge = "0,1,0,0", mergeLine = "0")
    private String szdName;

    // B列 (1) - 道路名称：0-1行纵向合并
    @Excel(name = "道路名称", headerLevel = 1, headerMerge = "0,1,1,1")
    private String dlmc;

    // C列 (2) - 管线类别：0-1行纵向合并
    @Excel(name = "管线类别", headerLevel = 1, headerMerge = "0,1,2,2")
    private String gxlbName;

    // ... 省略其他基础信息字段 ...

    // ========== 手续分组（横向合并）==========
    // Q-R-S列分组 (16-18) - 一级表头，横向合并3列
    @Excel(name = "手续", headerLevel = 0, headerMerge = "0,0,16,18", isGroupHeader = true)
    private String qqscGroup;

    // Q列 (16) - 批复编码：二级表头
    @Excel(name = "批复编码", headerLevel = 1, headerMerge = "1,1,16,16")
    private String lxpgbm;

    // R列 (17) - 许可编码：二级表头
    @Excel(name = "许可编码", headerLevel = 1, headerMerge = "1,1,17,17")
    private String ghxkbm;

    // S列 (18) - 挖掘编号：二级表头
    @Excel(name = "挖掘编号", headerLevel = 1, headerMerge = "1,1,18,18")
    private String dlwjbm;

    // ========== 财政资金分组 ==========
    // T-U列分组 (19-20) - 一级表头，横向合并2列
    @Excel(name = "财政资金(万元)", headerLevel = 0, headerMerge = "0,0,19,20", isGroupHeader = true)
    private String zyczzjGroup;

    // T列 (19) - 预算内投资：二级表头
    @Excel(name = "预算内投资", headerLevel = 1, headerMerge = "1,1,19,19")
    private String ystz;

    // U列 (20) - 特别国债：二级表头
    @Excel(name = "特别国债", headerLevel = 1, headerMerge = "1,1,20,20")
    private String cztqtbgz;

    // ... 省略其他资金相关字段 ...

    // ========== 辅助字段（不导出）==========
    private String szd;
    private Integer gxlb;
}

package com.itl.common.utils.poi;

import com.itl.common.exception.BusinessException;
import com.itl.common.utils.DateUtils;
import com.itl.common.utils.StringUtils;
import com.itl.common.utils.reflect.ReflectUtils;
import com.itl.common.utils.text.Convert;
import com.itl.framework.aspectj.lang.annotation.Excel;
import com.itl.framework.aspectj.lang.annotation.Excel.ColumnType;
import com.itl.framework.aspectj.lang.annotation.Excel.Type;
import com.itl.framework.aspectj.lang.annotation.Excels;
import com.itl.framework.config.SysConfig;
import com.itl.framework.web.domain.AjaxResult;
import org.apache.poi.hssf.usermodel.HSSFDateUtil;
import org.apache.poi.ss.usermodel.*;
import org.apache.poi.ss.util.CellRangeAddress;
import org.apache.poi.ss.util.CellRangeAddressList;
import org.apache.poi.xssf.streaming.SXSSFWorkbook;
import org.apache.poi.xssf.usermodel.XSSFDataValidation;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.util.ObjectUtils;

import java.io.*;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.math.BigDecimal;
import java.text.DecimalFormat;
import java.util.*;

/**
 * Excel相关处理 - 修复多级表头问题
 *
 * @author itl
 */
public class ExcelUtilMerge<T>
{
    private static final Logger log = LoggerFactory.getLogger(ExcelUtilMerge.class);

    /**
     * Excel sheet最大行数，默认65536
     */
    public static final int sheetSize = 65536;

    /**
     * 工作表名称
     */
    private String sheetName;

    /**
     * 导出类型（EXPORT:导出数据；IMPORT：导入模板）
     */
    private Type type;

    /**
     * 工作薄对象
     */
    private Workbook wb;

    /**
     * 工作表对象
     */
    private Sheet sheet;

    /**
     * 样式列表
     */
    private Map<String, CellStyle> styles;

    /**
     * 导入导出数据列表
     */
    private List<T> list;

    /**
     * 注解列表
     */
    private List<Object[]> fields;

    /**
     * 实体对象
     */
    public Class<T> clazz;

    /**
     * 统计列表
     */
    private Map<Integer, Double> statistics = new HashMap<Integer, Double>();

    //是否进行合并行
    private boolean switchMearge = false;
    //合并行数  起始行，结束行
    private int mergeLine_start = 0;
    private int mergeLine_end = 0;

    // 多级表头相关
    private int maxHeaderLevel = 0;
    private Map<Integer, Row> headerRows = new HashMap<>();

    // 多级表头模式开关
    private boolean multiLevelHeaderMode = false;

    public ExcelUtilMerge(Class<T> clazz)
    {
        this.clazz = clazz;
    }

    /**
     * 设置多级表头模式
     */
    public void setMultiLevelHeaderMode(boolean multiLevelHeaderMode) {
        this.multiLevelHeaderMode = multiLevelHeaderMode;
        if (multiLevelHeaderMode) {
            log.debug("启用多级表头模式");
        }
    }

    public void init(List<T> list, String sheetName, Type type)
    {
        if (list == null)
        {
            list = new ArrayList<T>();
        }
        this.list = list;
        this.sheetName = sheetName;
        this.type = type;
        createExcelField();
        createWorkbook();
    }

    /**
     * 对excel表单默认第一个索引名转换成list
     *
     * @param is 输入流
     * @return 转换后集合
     */
    public List<T> importExcel(InputStream is) throws Exception
    {
        return importExcel(StringUtils.EMPTY, is);
    }

    /**
     * 对excel表单指定表格索引名转换成list
     *
     * @param sheetName 表格索引名
     * @param is 输入流
     * @return 转换后集合
     */
    public List<T> importExcel(String sheetName, InputStream is) throws Exception
    {
        this.type = Type.IMPORT;
        this.wb = WorkbookFactory.create(is);
        List<T> list = new ArrayList<T>();
        Sheet sheet = null;
        if (StringUtils.isNotEmpty(sheetName))
        {
            // 如果指定sheet名,则取指定sheet中的内容.
            sheet = wb.getSheet(sheetName);
        }
        else
        {
            // 如果传入的sheet名不存在则默认指向第1个sheet.
            sheet = wb.getSheetAt(0);
        }

        if (sheet == null)
        {
            throw new IOException("文件sheet不存在");
        }

        int rows = sheet.getPhysicalNumberOfRows();

        if (rows > 0)
        {
            // 定义一个map用于存放excel列的序号和field.
            Map<String, Integer> cellMap = new HashMap<String, Integer>();
            // 获取表头
            Row heard = sheet.getRow(0);
            for (int i = 0; i < heard.getPhysicalNumberOfCells(); i++)
            {
                Cell cell = heard.getCell(i);
                if (StringUtils.isNotNull(cell))
                {
                    String value = this.getCellValue(heard, i).toString();
                    cellMap.put(value, i);
                }
                else
                {
                    cellMap.put(null, i);
                }
            }
            // 有数据时才处理 得到类的所有field.
            Field[] allFields = clazz.getDeclaredFields();
            // 定义一个map用于存放列的序号和field.
            Map<Integer, Field> fieldsMap = new HashMap<Integer, Field>();
            for (int col = 0; col < allFields.length; col++)
            {
                Field field = allFields[col];
                Excel attr = field.getAnnotation(Excel.class);
                if (attr != null && (attr.type() == Type.ALL || attr.type() == type))
                {
                    // 设置类的私有字段属性可访问.
                    field.setAccessible(true);
                    Integer column = cellMap.get(attr.name());
                    fieldsMap.put(column, field);
                }
            }
            for (int i = 1; i < rows; i++)
            {
                // 从第2行开始取数据,默认第一行是表头.
                Row row = sheet.getRow(i);
                T entity = null;
                for (Map.Entry<Integer, Field> entry : fieldsMap.entrySet())
                {
                    Object val = this.getCellValue(row, entry.getKey());

                    // 如果不存在实例则新建.
                    entity = (entity == null ? clazz.newInstance() : entity);
                    // 从map中得到对应列的field.
                    Field field = fieldsMap.get(entry.getKey());
                    // 取得类型,并根据对象类型设置值.
                    Class<?> fieldType = field.getType();
                    if (String.class == fieldType)
                    {
                        String s = Convert.toStr(val);
                        if (StringUtils.endsWith(s, ".0"))
                        {
                            val = StringUtils.substringBefore(s, ".0");
                        }
                        else
                        {
                            String dateFormat = field.getAnnotation(Excel.class).dateFormat();
                            if (StringUtils.isNotEmpty(dateFormat))
                            {
                                val = DateUtils.parseDateToStr(dateFormat, (Date) val);
                            }
                            else
                            {
                                val = Convert.toStr(val);
                            }
                        }
                    }
                    else if ((Integer.TYPE == fieldType) || (Integer.class == fieldType))
                    {
                        val = Convert.toInt(val);
                    }
                    else if ((Long.TYPE == fieldType) || (Long.class == fieldType))
                    {
                        val = Convert.toLong(val);
                    }
                    else if ((Double.TYPE == fieldType) || (Double.class == fieldType))
                    {
                        val = Convert.toDouble(val);
                    }
                    else if ((Float.TYPE == fieldType) || (Float.class == fieldType))
                    {
                        val = Convert.toFloat(val);
                    }
                    else if (BigDecimal.class == fieldType)
                    {
                        val = Convert.toBigDecimal(val);
                    }
                    else if (Date.class == fieldType)
                    {
                        if (val instanceof String)
                        {
                            val = DateUtils.parseDate(val);
                        }
                        else if (val instanceof Double)
                        {
                            val = DateUtil.getJavaDate((Double) val);
                        }
                    }
                    if (StringUtils.isNotNull(fieldType))
                    {
                        Excel attr = field.getAnnotation(Excel.class);
                        String propertyName = field.getName();
                        if (StringUtils.isNotEmpty(attr.targetAttr()))
                        {
                            propertyName = field.getName() + "." + attr.targetAttr();
                        }
                        else if (StringUtils.isNotEmpty(attr.readConverterExp()))
                        {
                            val = reverseByExp(String.valueOf(val), attr.readConverterExp());
                        }else if(StringUtils.isNotEmpty(attr.pattern())){
                            val = reverseByPattern(String.valueOf(val), attr.pattern());
                        }
                        ReflectUtils.invokeSetter(entity, propertyName, val);
                    }
                }
                list.add(entity);
            }
        }
        return list;
    }

    /**
     * 对list数据源将其里面的数据导入到excel表单
     *
     * @param list 导出数据集合
     * @param sheetName 工作表的名称
     * @return 结果
     */
    public AjaxResult exportExcel(List<T> list, String sheetName)
    {
        this.init(list, sheetName, Type.EXPORT);
        return exportExcel();
    }

    /**
     * 对list数据源将其里面的数据导入到excel表单
     *
     * @param sheetName 工作表的名称
     * @return 结果
     */
    public AjaxResult importTemplateExcel(String sheetName)
    {
        this.init(null, sheetName, Type.IMPORT);
        return exportExcel();
    }

    /**
     * 对list数据源将其里面的数据导入到excel表单
     *
     * @return 结果
     */
    public AjaxResult exportExcel()
    {
        OutputStream out = null;
        try
        {
            // 取出一共有多少个sheet.
            double sheetNo = Math.ceil(list.size() / sheetSize);
            for (int index = 0; index <= sheetNo; index++)
            {
                createSheet(sheetNo, index);

                // 创建多级表头
                createMultiLevelHeader();

                if (Type.EXPORT.equals(type))
                {
                    // 数据起始行 = 表头行数
                    int dataStartRow = maxHeaderLevel + 1;
                    fillExcelData(index, dataStartRow);
                }
            }
            String filename = encodingFilename(sheetName);
            out = new FileOutputStream(getAbsoluteFile(filename));
            wb.write(out);
            return AjaxResult.success(filename);
        }
        catch (Exception e)
        {
            log.error("导出Excel异常{}", e.getMessage());
            throw new BusinessException("导出Excel失败，请联系网站管理员！");
        }
        finally
        {
            if (wb != null)
            {
                try
                {
                    wb.close();
                }
                catch (IOException e1)
                {
                    e1.printStackTrace();
                }
            }
            if (out != null)
            {
                try
                {
                    out.close();
                }
                catch (IOException e1)
                {
                    e1.printStackTrace();
                }
            }
        }
    }

    /**
     * 创建多级表头 - 简化版本
     */
    private void createMultiLevelHeader() {
        // 计算最大表头层级
        calculateMaxHeaderLevel();

        // 创建所有表头行
        for (int level = 0; level <= maxHeaderLevel; level++) {
            Row row = sheet.createRow(level);
            headerRows.put(level, row);

            // 设置行高（表头行高稍高）
            row.setHeight((short) (25 * 20));
        }

        // 填充表头内容
        fillHeaderContent();

        // 处理表头合并
        processHeaderMerge();

        // 设置列宽
        setColumnWidths();
    }

    /**
     * 计算最大表头层级
     */
    private void calculateMaxHeaderLevel() {
        maxHeaderLevel = 0;
        for (Object[] os : fields) {
            Excel excel = (Excel) os[1];
            // 检查是否有headerMerge配置
            if (StringUtils.isNotEmpty(excel.headerMerge())) {
                String[] mergeParams = excel.headerMerge().split(",");
                if (mergeParams.length == 4) {
                    try {
                        int lastRow = Integer.parseInt(mergeParams[1]);
                        if (lastRow > maxHeaderLevel) {
                            maxHeaderLevel = lastRow;
                        }
                    } catch (NumberFormatException e) {
                        log.warn("headerMerge参数格式错误: {}", excel.headerMerge());
                    }
                }
            }
            // 同时检查headerLevel
            if (excel.headerLevel() > maxHeaderLevel) {
                maxHeaderLevel = excel.headerLevel();
            }
        }

        // 确保至少有一级表头
        if (maxHeaderLevel < 0) {
            maxHeaderLevel = 0;
        }
    }

    /**
     * 填充表头内容 - 根据模式选择不同的实现
     */
    private void fillHeaderContent() {
        if (multiLevelHeaderMode) {
            fillHeaderContentMultiLevel();
        } else {
            fillHeaderContentOriginal();
        }
    }

    /**
     * 原有的表头填充逻辑
     */
    private void fillHeaderContentOriginal() {
        int column = 0;
        for (Object[] os : fields) {
            Excel excel = (Excel) os[1];
            String headerMerge = excel.headerMerge();

            // 解析合并参数
            int firstRow = 0;
            int lastRow = 0;
            int firstCol = column;
            int lastCol = column;

            if (StringUtils.isNotEmpty(headerMerge)) {
                String[] mergeParams = headerMerge.split(",");
                if (mergeParams.length == 4) {
                    try {
                        firstRow = Integer.parseInt(mergeParams[0]);
                        lastRow = Integer.parseInt(mergeParams[1]);
                        firstCol = Integer.parseInt(mergeParams[2]);
                        lastCol = Integer.parseInt(mergeParams[3]);
                    } catch (NumberFormatException e) {
                        log.warn("headerMerge参数格式错误: {}", headerMerge);
                    }
                }
            }

            // 为每个层级的表头行创建单元格
            for (int level = 0; level <= maxHeaderLevel; level++) {
                Row row = headerRows.get(level);
                Cell cell = row.createCell(column);

                // 所有表头使用相同的样式
                cell.setCellStyle(styles.get("header0"));

                // 判断当前单元格是否应该显示内容
                boolean shouldShowContent = false;

                if (StringUtils.isNotEmpty(headerMerge)) {
                    // 有合并配置的情况
                    if (level >= firstRow && level <= lastRow && column >= firstCol && column <= lastCol) {
                        if (level == firstRow && column == firstCol) {
                            // 只在合并区域的第一个单元格显示内容
                            cell.setCellValue(excel.name());
                            shouldShowContent = true;
                        }
                    }
                } else {
                    // 无合并配置的情况，使用headerLevel
                    if (excel.headerLevel() == level) {
                        cell.setCellValue(excel.name());
                        shouldShowContent = true;
                    }
                }

                if (!shouldShowContent) {
                    cell.setCellValue("");
                }
            }
            column++;
        }
    }

    /**
     * 多级表头专用逻辑
     */
   /* private void fillHeaderContentMultiLevel() {
        int logicalIndex = 0;
        int physicalColumn = 0;

        log.debug("=== 开始多级表头填充 ===");

        for (Object[] os : fields) {
            Excel excel = (Excel) os[1];
            String headerMerge = excel.headerMerge();

            int actualColumn = physicalColumn;
            int columnSpan = 1;

            // 解析合并参数，确定实际列位置和跨度
            if (StringUtils.isNotEmpty(headerMerge)) {
                String[] mergeParams = headerMerge.split(",");
                if (mergeParams.length == 4) {
                    try {
                        int configFirstCol = Integer.parseInt(mergeParams[2]);
                        int configLastCol = Integer.parseInt(mergeParams[3]);
                        actualColumn = configFirstCol;
                        columnSpan = configLastCol - configFirstCol + 1;

                        log.debug("分组字段[{}]: 逻辑索引={}, 实际列={}, 跨度={}",
                                excel.name(), logicalIndex, actualColumn, columnSpan);
                    } catch (NumberFormatException e) {
                        log.warn("headerMerge参数格式错误: {}", headerMerge);
                    }
                }
            } else {
                log.debug("普通字段[{}]: 逻辑索引={}, 实际列={}",
                        excel.name(), logicalIndex, actualColumn);
            }

            // 为每个层级的表头行创建单元格
            for (int level = 0; level <= maxHeaderLevel; level++) {
                Row row = headerRows.get(level);
                Cell cell = row.createCell(actualColumn);
                cell.setCellStyle(styles.get("header0"));

                boolean shouldShowContent = false;

                if (StringUtils.isNotEmpty(headerMerge)) {
                    // 分组字段的处理
                    String[] mergeParams = headerMerge.split(",");
                    int firstRow = Integer.parseInt(mergeParams[0]);
                    int lastRow = Integer.parseInt(mergeParams[1]);
                    int firstCol = Integer.parseInt(mergeParams[2]);
                    int lastCol = Integer.parseInt(mergeParams[3]);

                    if (level >= firstRow && level <= lastRow &&
                            actualColumn >= firstCol && actualColumn <= lastCol) {
                        if (level == firstRow && actualColumn == firstCol) {
                            // 只在合并区域的第一个单元格显示分组标题
                            cell.setCellValue(excel.name());
                            shouldShowContent = true;
                        }
                    } else if (level == excel.headerLevel()) {
                        // 分组字段不在自己的合并区域内，但在正确的层级，显示空值
                        cell.setCellValue("");
                    }
                } else {
                    // 普通字段的处理
                    if (excel.headerLevel() == level) {
                        cell.setCellValue(excel.name());
                        shouldShowContent = true;
                    }
                }

                if (!shouldShowContent) {
                    cell.setCellValue("");
                }
            }

            // 更新列索引
            if (StringUtils.isNotEmpty(headerMerge)) {
                // 分组字段：跳转到配置的结束列的下一个位置
                String[] mergeParams = headerMerge.split(",");
                int lastCol = Integer.parseInt(mergeParams[3]);
                physicalColumn = lastCol + 1;
            } else {
                // 普通字段：正常递增
                physicalColumn++;
            }

            logicalIndex++;
        }

        log.debug("=== 结束多级表头填充 ===");
    }*/

    /**
     * 处理表头合并 - 根据模式选择不同的实现
     */
    private void processHeaderMerge() {
        if (multiLevelHeaderMode) {
            processHeaderMergeMultiLevel();
        } else {
            processHeaderMergeOriginal();
        }
    }

    /**
     * 原有的合并区域处理逻辑
     */
    private void processHeaderMergeOriginal() {
        int column = 0;

        for (Object[] os : fields) {
            Excel excel = (Excel) os[1];
            String headerMerge = excel.headerMerge();

            if (StringUtils.isNotEmpty(headerMerge)) {
                String[] mergeParams = headerMerge.split(",");
                if (mergeParams.length == 4) {
                    try {
                        int firstRow = Integer.parseInt(mergeParams[0]);
                        int lastRow = Integer.parseInt(mergeParams[1]);
                        int firstCol = Integer.parseInt(mergeParams[2]);
                        int lastCol = Integer.parseInt(mergeParams[3]);

                        // 验证合并区域的有效性
                        if (firstRow >= 0 && lastRow <= maxHeaderLevel &&
                                firstCol >= 0 && lastCol < fields.size() &&
                                firstRow <= lastRow && firstCol <= lastCol) {

                            CellRangeAddress region = new CellRangeAddress(firstRow, lastRow, firstCol, lastCol);

                            try {
                                sheet.addMergedRegion(region);
                                log.debug("添加合并区域: {}-{}, {}-{}",
                                        region.getFirstRow(), region.getLastRow(),
                                        region.getFirstColumn(), region.getLastColumn());
                            } catch (Exception e) {
                                log.error("合并区域失败: {}", region.formatAsString(), e);
                            }
                        }
                    } catch (NumberFormatException e) {
                        log.error("表头合并参数格式错误: {}", headerMerge);
                    }
                }
            }
            column++;
        }
    }

    /**
     * 多级表头专用的合并区域处理
     */
    private void processHeaderMergeMultiLevel() {
        int logicalIndex = 0;
        int physicalColumn = 0;

        for (Object[] os : fields) {
            Excel excel = (Excel) os[1];
            String headerMerge = excel.headerMerge();

            if (StringUtils.isNotEmpty(headerMerge)) {
                String[] mergeParams = headerMerge.split(",");
                if (mergeParams.length == 4) {
                    try {
                        int firstRow = Integer.parseInt(mergeParams[0]);
                        int lastRow = Integer.parseInt(mergeParams[1]);
                        int firstCol = Integer.parseInt(mergeParams[2]);
                        int lastCol = Integer.parseInt(mergeParams[3]);

                        // 验证合并区域的有效性
                        if (firstRow >= 0 && lastRow <= maxHeaderLevel &&
                                firstCol >= 0 && lastCol < getTotalColumns() &&
                                firstRow <= lastRow && firstCol <= lastCol) {

                            CellRangeAddress region = new CellRangeAddress(firstRow, lastRow, firstCol, lastCol);

                            try {
                                sheet.addMergedRegion(region);
                                log.debug("添加合并区域: {}-{}, {}-{}",
                                        region.getFirstRow(), region.getLastRow(),
                                        region.getFirstColumn(), region.getLastColumn());
                            } catch (Exception e) {
                                log.error("合并区域失败: {}", region.formatAsString(), e);
                            }
                        }
                    } catch (NumberFormatException e) {
                        log.error("表头合并参数格式错误: {}", headerMerge);
                    }
                }
            }

            // 更新列索引（与fillHeaderContentMultiLevel保持一致）
            if (StringUtils.isNotEmpty(headerMerge)) {
                String[] mergeParams = headerMerge.split(",");
                int lastCol = Integer.parseInt(mergeParams[3]);
                physicalColumn = lastCol + 1;
            } else {
                physicalColumn++;
            }

            logicalIndex++;
        }
    }

    /**
     * 计算总列数 - 多级表头专用
     */
    private int getTotalColumns() {
        int total = 0;
        for (Object[] os : fields) {
            Excel excel = (Excel) os[1];
            String headerMerge = excel.headerMerge();

            if (StringUtils.isNotEmpty(headerMerge)) {
                String[] mergeParams = headerMerge.split(",");
                if (mergeParams.length == 4) {
                    try {
                        int firstCol = Integer.parseInt(mergeParams[2]);
                        int lastCol = Integer.parseInt(mergeParams[3]);
                        total = Math.max(total, lastCol + 1);
                    } catch (NumberFormatException e) {
                        total++;
                    }
                }
            } else {
                total++;
            }
        }
        return total;
    }

    /**
     * 设置列宽
     */
    private void setColumnWidths() {
        int column = 0;
        for (Object[] os : fields) {
            Excel excel = (Excel) os[1];
            // 设置列宽
            sheet.setColumnWidth(column, (int) ((excel.width() + 0.72) * 256));
            column++;
        }
    }

    /**
     * 填充excel数据
     *
     * @param index 序号
     * @param startRow 数据起始行
     */
    public void fillExcelData(int index, int startRow)
    {
        int startNo = index * sheetSize;
        int endNo = Math.min(startNo + sheetSize, list.size());

        //当前行
        int thisLine = 0;
        Row row = null;

        for (int i = startNo; i < endNo; i++) {
            row = sheet.createRow(startRow + i - startNo);

            thisLine = startRow + i - startNo;
            // 得到导出对象.
            T vo = (T) list.get(i);
            T vo_previous = null;
            //得到上一个导出对象
            if (i != startNo) {
                vo_previous = (T) list.get(i - 1);
            }
            /**
             *取下一个对象   与当前对象对比，如果相同，记住当前列，再与下一个对比，一直对比到不相同，执行合并代码
             * 注解加入 合并行列标识
             */
            int column = 0;
            for (Object[] os : fields) {

                Field field = (Field) os[0];
                Excel excel = (Excel) os[1];
                // 关键修复：跳过分组字段，不创建单元格
                if (excel.isGroupHeader()) {
                   // log.debug("跳过分组字段: {} (isGroupHeader=true)", excel.name());
                    continue; // 直接跳过，不增加column索引
                }
                // 设置实体类私有属性可访问
                field.setAccessible(true);
                this.addCell(excel, row, vo, field, column++, vo_previous, thisLine);
            }
        }
    }

    /**
     * 创建表格样式 - 简化表头样式
     */
    private Map<String, CellStyle> createStyles(Workbook wb) {
        Map<String, CellStyle> styles = new HashMap<>();

        // 数据样式
        CellStyle dataStyle = createDataStyle(wb);
        styles.put("data", dataStyle);

        // 创建表头样式（所有表头使用相同样式）
        createHeaderStyles(wb, styles);

        return styles;
    }

    /**
     * 创建表头样式 - 所有表头使用统一样式
     */
    private void createHeaderStyles(Workbook wb, Map<String, CellStyle> styles) {
        // 表头样式 - 灰色背景，黑色字体
        CellStyle headerStyle = wb.createCellStyle();
        headerStyle.cloneStyleFrom(styles.get("data"));

        // 设置对齐方式
        headerStyle.setAlignment(HorizontalAlignment.CENTER);
        headerStyle.setVerticalAlignment(VerticalAlignment.CENTER);

        // 设置背景色 - 浅灰色
        headerStyle.setFillForegroundColor(IndexedColors.GREY_25_PERCENT.getIndex());
        headerStyle.setFillPattern(FillPatternType.SOLID_FOREGROUND);

        // 设置字体 - 加粗
        Font headerFont = wb.createFont();
        headerFont.setFontName("宋体");
        headerFont.setFontHeightInPoints((short) 11);
        headerFont.setBold(true);
        headerFont.setColor(IndexedColors.BLACK.getIndex());

        headerStyle.setFont(headerFont);

        // 所有层级的表头都使用同一个样式
        for (int i = 0; i <= 4; i++) {
            styles.put("header" + i, headerStyle);
        }
    }

    /**
     * 创建数据样式
     */
    private CellStyle createDataStyle(Workbook wb) {
        CellStyle style = wb.createCellStyle();
        style.setAlignment(HorizontalAlignment.CENTER);
        style.setVerticalAlignment(VerticalAlignment.CENTER);
        style.setBorderRight(BorderStyle.THIN);
        style.setRightBorderColor(IndexedColors.GREY_50_PERCENT.getIndex());
        style.setBorderLeft(BorderStyle.THIN);
        style.setLeftBorderColor(IndexedColors.GREY_50_PERCENT.getIndex());
        style.setBorderTop(BorderStyle.THIN);
        style.setTopBorderColor(IndexedColors.GREY_50_PERCENT.getIndex());
        style.setBorderBottom(BorderStyle.THIN);
        style.setBottomBorderColor(IndexedColors.GREY_50_PERCENT.getIndex());

        Font dataFont = wb.createFont();
        dataFont.setFontName("宋体");
        dataFont.setFontHeightInPoints((short) 10);
        style.setFont(dataFont);

        return style;
    }

    /**
     * @param attr     excel
     * @param row
     * @param vo
     * @param field
     * @param column
     * @param thisLine 当前行
     * @return org.apache.poi.ss.usermodel.Cell
     * @author xkng
     * @creed: 合并单元行拓展
     * @date 2021/12/14 14:51
     */
    public Cell addCell(Excel attr, Row row, T vo, Field field, int column, T vo_previous, int thisLine) {
        Cell cell = null;
        try {
            // 设置行高
            row.setHeight((short) (attr.height() * 20));
            // 根据Excel中设置情况决定是否导出,有些情况需要保持为空,希望用户填写这一列.
            if (attr.isExport()) {
                // 创建cell
                cell = row.createCell(column);
                cell.setCellStyle(styles.get("data"));

                // 如果是分组表头字段，不显示实际数据
                if (attr.isGroupHeader()) {
                    cell.setCellValue("");
                } else {
                    // 用于读取对象中的属性
                    Object value = getTargetValue(vo, field, attr);
                    Object value_previous = null;
                    if (vo_previous != null) {
                        value_previous = getTargetValue(vo_previous, field, attr);
                    }
                    String dateFormat = attr.dateFormat();
                    String readConverterExp = attr.readConverterExp();
                    String pattern = attr.pattern();

                    String mergeLineStr = attr.mergeLine();
                    String[] mergeLine = mergeLineStr.split(",");

                    if (StringUtils.isNotEmpty(dateFormat) && StringUtils.isNotNull(value))
                    {
                        cell.setCellValue(DateUtils.parseDateToStr(dateFormat, (Date) value));
                    }
                    else if (StringUtils.isNotEmpty(readConverterExp) && StringUtils.isNotNull(value))
                    {
                        cell.setCellValue(convertByExp(String.valueOf(value), readConverterExp));
                    }
                    else if(StringUtils.isNotEmpty(pattern) && StringUtils.isNotNull(value))
                    {
                        cell.setCellValue(reverseByPattern(String.valueOf(value), pattern));
                    }
                    else
                    {
                        // 设置列类型
                        setCellVo(value, attr, cell);
                    }

                    addStatisticsData(column, Convert.toStr(value), attr);

                    //合并行  单列为基准进行合并
                    if (mergeLine.length > 0 && mergeLine[0] != null && !"".equals(mergeLine[0])) {
                        if (!ObjectUtils.isEmpty(value) && value.equals(value_previous)) {
                            if (this.mergeLine_start == 0) {
                                this.mergeLine_start = thisLine - 1;
                            }
                            this.mergeLine_end = thisLine;
                        } else {
                            if (this.mergeLine_start != 0 && this.mergeLine_end != 0) {
                                if (this.mergeLine_start != this.mergeLine_end) {
                                    for (String ml : mergeLine) {
                                        CellRangeAddress region = new CellRangeAddress(this.mergeLine_start, this.mergeLine_end, Integer.parseInt(ml), Integer.parseInt(ml));
                                        sheet.addMergedRegion(region);
                                    }
                                }
                                this.mergeLine_start = 0;
                                this.mergeLine_end = 0;
                            }
                        }
                    }
                }
            }
        } catch (Exception e) {
            log.error("导出Excel失败{}", e);
        }
        return cell;
    }

    /**
     * 创建单元格
     */
    public Cell createCell(Excel attr, Row row, int column)
    {
        // 创建列
        Cell cell = row.createCell(column);

        // 设置表头样式
        cell.setCellValue(attr.name());
        setDataValidation(attr, row, column);
        cell.setCellStyle(styles.get("header0"));
        return cell;
    }

    /**
     * 设置单元格信息
     *
     * @param value 单元格值
     * @param attr 注解相关
     * @param cell 单元格信息
     */
    public void setCellVo(Object value, Excel attr, Cell cell)
    {
        if (ColumnType.STRING == attr.cellType())
        {
            cell.setCellType(CellType.NUMERIC);
            cell.setCellValue(StringUtils.isNull(value) ? attr.defaultValue() : value + attr.suffix());
        }
        else if (ColumnType.NUMERIC == attr.cellType())
        {
            cell.setCellType(CellType.NUMERIC);
            cell.setCellValue(Integer.parseInt(value + ""));
        }
    }

    /**
     * 创建表格样式
     */
    public void setDataValidation(Excel attr, Row row, int column)
    {
        if (attr.name().indexOf("注：") >= 0)
        {
            sheet.setColumnWidth(column, 6000);
        }
        else
        {
            // 设置列宽
            sheet.setColumnWidth(column, (int) ((attr.width() + 0.72) * 256));
            row.setHeight((short) (attr.height() * 20));
        }
        // 如果设置了提示信息则鼠标放上去提示.
        if (StringUtils.isNotEmpty(attr.prompt()))
        {
            // 这里默认设了2-101列提示.
            setXSSFPrompt(sheet, "", attr.prompt(), 1, 100, column, column);
        }
        // 如果设置了combo属性则本列只能选择不能输入
        if (attr.combo().length > 0)
        {
            // 这里默认设了2-101列只能选择不能输入.
            setXSSFValidation(sheet, attr.combo(), 1, 100, column, column);
        }
    }

    /**
     * 合计统计信息
     */
    private void addStatisticsData(Integer index, String text, Excel entity) {
        if (entity != null && entity.isStatistics()) {
            Double temp = 0D;
            if (!statistics.containsKey(index)) {
                statistics.put(index, temp);
            }
            try {
                temp = Double.valueOf(text);
            } catch (NumberFormatException e) {
            }
            statistics.put(index, statistics.get(index) + temp);
        }
    }

    /**
     * 设置 POI XSSFSheet 单元格提示
     *
     * @param sheet 表单
     * @param promptTitle 提示标题
     * @param promptContent 提示内容
     * @param firstRow 开始行
     * @param endRow 结束行
     * @param firstCol 开始列
     * @param endCol 结束列
     */
    public void setXSSFPrompt(Sheet sheet, String promptTitle, String promptContent, int firstRow, int endRow,
                              int firstCol, int endCol)
    {
        DataValidationHelper helper = sheet.getDataValidationHelper();
        DataValidationConstraint constraint = helper.createCustomConstraint("DD1");
        CellRangeAddressList regions = new CellRangeAddressList(firstRow, endRow, firstCol, endCol);
        DataValidation dataValidation = helper.createValidation(constraint, regions);
        dataValidation.createPromptBox(promptTitle, promptContent);
        dataValidation.setShowPromptBox(true);
        sheet.addValidationData(dataValidation);
    }

    /**
     * 设置某些列的值只能输入预制的数据,显示下拉框.
     *
     * @param sheet 要设置的sheet.
     * @param textlist 下拉框显示的内容
     * @param firstRow 开始行
     * @param endRow 结束行
     * @param firstCol 开始列
     * @param endCol 结束列
     * @return 设置好的sheet.
     */
    public void setXSSFValidation(Sheet sheet, String[] textlist, int firstRow, int endRow, int firstCol, int endCol)
    {
        DataValidationHelper helper = sheet.getDataValidationHelper();
        // 加载下拉列表内容
        DataValidationConstraint constraint = helper.createExplicitListConstraint(textlist);
        // 设置数据有效性加载在哪个单元格上,四个参数分别是：起始行、终止行、起始列、终止列
        CellRangeAddressList regions = new CellRangeAddressList(firstRow, endRow, firstCol, endCol);
        // 数据有效性对象
        DataValidation dataValidation = helper.createValidation(constraint, regions);
        // 处理Excel兼容性问题
        if (dataValidation instanceof XSSFDataValidation)
        {
            dataValidation.setSuppressDropDownArrow(true);
            dataValidation.setShowErrorBox(true);
        }
        else
        {
            dataValidation.setSuppressDropDownArrow(false);
        }

        sheet.addValidationData(dataValidation);
    }

    /**
     * 解析导出值 0=男,1=女,2=未知
     *
     * @param propertyValue 参数值
     * @param converterExp 翻译注解
     * @return 解析后值
     * @throws Exception
     */
    public static String convertByExp(String propertyValue, String converterExp) throws Exception
    {
        try
        {
            String[] convertSource = converterExp.split(",");
            for (String item : convertSource)
            {
                String[] itemArray = item.split("=");
                if (itemArray[0].equals(propertyValue))
                {
                    return itemArray[1];
                }
            }
        }
        catch (Exception e)
        {
            throw e;
        }
        return propertyValue;
    }

    /**
     * 反向解析值 男=0,女=1,未知=2
     *
     * @param propertyValue 参数值
     * @param converterExp 翻译注解
     * @return 解析后值
     * @throws Exception
     */
    public static String reverseByExp(String propertyValue, String converterExp) throws Exception
    {
        try
        {
            String[] convertSource = converterExp.split(",");
            for (String item : convertSource)
            {
                String[] itemArray = item.split("=");
                if (itemArray[1].equals(propertyValue))
                {
                    return itemArray[0];
                }
            }
        }
        catch (Exception e)
        {
            throw e;
        }
        return propertyValue;
    }

    /**
     * 获取正则表达式内容
     * @param propertyValue 参数值
     * @param converterExp 注解
     * @return
     */
    public static String reverseByPattern(String propertyValue, String converterExp){
        String result = propertyValue.replaceAll(converterExp,"").replaceAll("\\&[a-zA-Z]{1,10};", "");
        return result;
    }

    /**
     * 编码文件名
     */
    public String encodingFilename(String filename)
    {
        filename = UUID.randomUUID().toString() + "_" + filename + ".xlsx";
        return filename;
    }

    /**
     * 获取下载路径
     *
     * @param filename 文件名称
     */
    public String getAbsoluteFile(String filename)
    {
        String downloadPath = SysConfig.getDownloadPath() + filename;
        File desc = new File(downloadPath);
        if (!desc.getParentFile().exists())
        {
            desc.getParentFile().mkdirs();
        }
        return downloadPath;
    }

    /**
     * 获取bean中的属性值
     *
     * @param vo 实体对象
     * @param field 字段
     * @param excel 注解
     * @return 最终的属性值
     * @throws Exception
     */
    private Object getTargetValue(T vo, Field field, Excel excel) throws Exception
    {
        Object o = field.get(vo);
        if (StringUtils.isNotEmpty(excel.targetAttr()))
        {
            String target = excel.targetAttr();
            if (target.indexOf(".") > -1)
            {
                String[] targets = target.split("[.]");
                for (String name : targets)
                {
                    o = getValue(o, name);
                }
            }
            else
            {
                o = getValue(o, target);
            }
        }
        return o;
    }

    /**
     * 以类的属性的get方法方法形式获取值
     *
     * @param o
     * @param name
     * @return value
     * @throws Exception
     */
    private Object getValue(Object o, String name) throws Exception
    {
        if (StringUtils.isNotEmpty(name))
        {
            Class<?> clazz = o.getClass();
            String methodName = "get" + name.substring(0, 1).toUpperCase() + name.substring(1);
            Method method = clazz.getMethod(methodName);
            o = method.invoke(o);
        }
        return o;
    }

    /**
     * 得到所有定义字段 - 修复排序问题
     */
    private void createExcelField()
    {
        this.fields = new ArrayList<Object[]>();
        List<Field> tempFields = new ArrayList<>();
        tempFields.addAll(Arrays.asList(clazz.getSuperclass().getDeclaredFields()));
        tempFields.addAll(Arrays.asList(clazz.getDeclaredFields()));

        for (Field field : tempFields)
        {
            // 单注解
            if (field.isAnnotationPresent(Excel.class))
            {
                putToField(field, field.getAnnotation(Excel.class));
            }

            // 多注解
            if (field.isAnnotationPresent(Excels.class))
            {
                Excels attrs = field.getAnnotation(Excels.class);
                Excel[] excels = attrs.value();
                for (Excel excel : excels)
                {
                    putToField(field, excel);
                }
            }
        }

        // 关键修复：按sort值对字段进行排序
        sortFieldsByOrder();
    }

    /**
     * 按sort值对字段进行排序 - 新增方法
     */
    private void sortFieldsByOrder() {
        if (this.fields != null && this.fields.size() > 0) {
            // 使用稳定的排序算法
            Collections.sort(this.fields, new Comparator<Object[]>() {
                @Override
                public int compare(Object[] o1, Object[] o2) {
                    Excel excel1 = (Excel) o1[1];
                    Excel excel2 = (Excel) o2[1];
                    return Integer.compare(excel1.sort(), excel2.sort());
                }
            });

            // 调试信息：打印排序后的字段顺序
            if (log.isDebugEnabled()) {
                StringBuilder sb = new StringBuilder("Excel字段排序结果: ");
                for (Object[] field : fields) {
                    Excel excel = (Excel) field[1];
                    sb.append(excel.name()).append("(sort=").append(excel.sort()).append(") ");
                }
                log.debug(sb.toString());
            }
        }
    }

    /**
     * 放到字段集合中
     */
    private void putToField(Field field, Excel attr)
    {
        if (attr != null && (attr.type() == Type.ALL || attr.type() == type))
        {
            this.fields.add(new Object[] { field, attr });
        }
    }

    /**
     * 创建一个工作簿
     */
    public void createWorkbook()
    {
        this.wb = new SXSSFWorkbook(500);
    }

    /**
     * 创建工作表
     *
     * @param sheetNo sheet数量
     * @param index 序号
     */
    public void createSheet(double sheetNo, int index)
    {
        this.sheet = wb.createSheet();
        this.styles = createStyles(wb);
        // 设置工作表的名称.
        if (sheetNo == 0)
        {
            wb.setSheetName(index, sheetName);
        }
        else
        {
            wb.setSheetName(index, sheetName + index);
        }
    }

    /**
     * 获取单元格值
     *
     * @param row 获取的行
     * @param column 获取单元格列号
     * @return 单元格值
     */
    public Object getCellValue(Row row, int column)
    {
        if (row == null)
        {
            return row;
        }
        Object val = "";
        try
        {
            Cell cell = row.getCell(column);
            if (StringUtils.isNotNull(cell))
            {
                if (cell.getCellTypeEnum() == CellType.NUMERIC || cell.getCellTypeEnum() == CellType.FORMULA)
                {
                    val = cell.getNumericCellValue();
                    if (HSSFDateUtil.isCellDateFormatted(cell))
                    {
                        val = DateUtil.getJavaDate((Double) val); // POI Excel 日期格式转换
                    }
                    else
                    {
                        if ((Double) val % 1 > 0)
                        {
                            val = new DecimalFormat("0.00").format(val);
                        }
                        else
                        {
                            val = new DecimalFormat("0").format(val);
                        }
                    }
                }
                else if (cell.getCellTypeEnum() == CellType.STRING)
                {
                    val = cell.getStringCellValue();
                }
                else if (cell.getCellTypeEnum() == CellType.BOOLEAN)
                {
                    val = cell.getBooleanCellValue();
                }
                else if (cell.getCellTypeEnum() == CellType.ERROR)
                {
                    val = cell.getErrorCellValue();
                }

            }
        }
        catch (Exception e)
        {
            return val;
        }
        return val;
    }



    /**
     * 多级表头专用逻辑 - 修复版本
     */
    private void fillHeaderContentMultiLevel() {
        int logicalIndex = 0;
        int physicalColumn = 0;

        log.debug("=== 开始多级表头填充 ===");

        for (Object[] os : fields) {
            Excel excel = (Excel) os[1];
            String headerMerge = excel.headerMerge();

            int actualColumn = physicalColumn;
            int columnSpan = 1;

            // 解析合并参数，确定实际列位置和跨度
            if (StringUtils.isNotEmpty(headerMerge)) {
                String[] mergeParams = headerMerge.split(",");
                if (mergeParams.length == 4) {
                    try {
                        int configFirstCol = Integer.parseInt(mergeParams[2]);
                        int configLastCol = Integer.parseInt(mergeParams[3]);
                        actualColumn = configFirstCol;
                        columnSpan = configLastCol - configFirstCol + 1;

                        log.debug("分组字段[{}]: 逻辑索引={}, 实际列={}, 跨度={}",
                                excel.name(), logicalIndex, actualColumn, columnSpan);
                    } catch (NumberFormatException e) {
                        log.warn("headerMerge参数格式错误: {}", headerMerge);
                    }
                }
            } else {
                log.debug("普通字段[{}]: 逻辑索引={}, 实际列={}",
                        excel.name(), logicalIndex, actualColumn);
            }

            // 为每个层级的表头行创建单元格
            for (int level = 0; level <= maxHeaderLevel; level++) {
                Row row = headerRows.get(level);

                // 确保单元格存在
                Cell cell = row.getCell(actualColumn);
                if (cell == null) {
                    cell = row.createCell(actualColumn);
                }

                cell.setCellStyle(styles.get("header0"));

                boolean shouldShowContent = false;

                if (StringUtils.isNotEmpty(headerMerge)) {
                    // 分组字段的处理 - 修复逻辑
                    String[] mergeParams = headerMerge.split(",");
                    int firstRow = Integer.parseInt(mergeParams[0]);
                    int lastRow = Integer.parseInt(mergeParams[1]);
                    int firstCol = Integer.parseInt(mergeParams[2]);
                    int lastCol = Integer.parseInt(mergeParams[3]);

                    // 只在合并区域的起始位置显示内容
                    if (level == firstRow && actualColumn == firstCol) {
                        cell.setCellValue(excel.name());
                        shouldShowContent = true;
                        log.debug("设置分组标题[{}]在位置: 行={}, 列={}",
                                excel.name(), level, actualColumn);
                    }
                } else {
                    // 普通字段的处理
                    if (excel.headerLevel() == level) {
                        cell.setCellValue(excel.name());
                        shouldShowContent = true;
                    }
                }

                if (!shouldShowContent && cell.getCellType() == CellType.BLANK.getCode()) {
                    cell.setCellValue("");
                }
            }

            // 更新列索引
            if (StringUtils.isNotEmpty(headerMerge)) {
                // 分组字段：跳转到配置的结束列的下一个位置
                String[] mergeParams = headerMerge.split(",");
                int lastCol = Integer.parseInt(mergeParams[3]);
                physicalColumn = lastCol + 1;
            } else {
                // 普通字段：正常递增
                physicalColumn++;
            }

            logicalIndex++;
        }

        log.debug("=== 结束多级表头填充 ===");
    }
}

package com.itl.framework.aspectj.lang.annotation;

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

/**
 * 自定义导出Excel数据注解
 *
 * @author itl
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface Excel
{
    /**
     * 导出时在excel中排序
     */
    public int sort() default Integer.MAX_VALUE;

    /**
     * 导出到Excel中的名字.
     */
    public String name() default "";

    /**
     * 日期格式, 如: yyyy-MM-dd
     */
    public String dateFormat() default "";

    /**
     * 读取内容转表达式 (如: 0=男,1=女,2=未知)
     */
    public String readConverterExp() default "";

    /**
     * 读取符合正则表达式内容
     */
    public String pattern() default "";

    /**
     * 导出类型（0数字 1字符串）
     */
    public ColumnType cellType() default ColumnType.STRING;

    /**
     * 导出时在excel中每个列的高度 单位为字符
     */
    public double height() default 14;

    /**
     * 导出时在excel中每个列的宽 单位为字符
     */
    public double width() default 16;

    /**
     * 文字后缀,如% 90 变成90%
     */
    public String suffix() default "";

    /**
     * 当值为空时,字段的默认值
     */
    public String defaultValue() default "";

    /**
     * 提示信息
     */
    public String prompt() default "";

    /**
     * 设置只能选择不能输入的列内容.
     */
    public String[] combo() default {};

    /**
     * 是否导出数据,应对需求:有时我们需要导出一份模板,这是标题需要但内容需要用户手工填写.
     */
    public boolean isExport() default true;

    /**
     * 另一个类中的属性名称,支持多级获取,以小数点隔开
     */
    public String targetAttr() default "";

    /**
     * 字段类型（0：导出导入；1：仅导出；2：仅导入）
     */
    Type type() default Type.ALL;

    /**
     * 合并行
     * 参数1合并第一个参数为合并基准列，其他列用逗号拼接，依据基准列进行当前单元行合并 参数:如1,7, 8
     */
    public String mergeLine() default "";

    /**
     * 表头合并配置
     * 格式: "起始行,结束行,起始列,结束列"
     * 例如: "0,0,0,2" 表示第0行第0列到第0行第2列合并
     */
    public String headerMerge() default "";

    /**
     * 表头层级（从0开始，用于多级表头）
     */
    public int headerLevel() default 0;

    /**
     * 是否分组表头（用于标识该字段是否为分组表头，不包含实际数据）
     */
    public boolean isGroupHeader() default false;

    /**
     * 分组表头行数（默认1行）
     */
    public int groupHeaderRows() default 1;

//    ColumnType align();

    String separator() default "";

    String dictType() default "";

    int scale() default 0;

    int roundingMode() default 0;

    boolean isStatistics() default false;

    /**
     * 设置只能选择不能输入的列内容.
     * 动态字典方式
     */
    public String comboDynamic() default "";

    public enum Type
    {
        ALL(0), EXPORT(1), IMPORT(2);
        private final int value;

        Type(int value)
        {
            this.value = value;
        }

        public int value()
        {
            return this.value;
        }
    }

    public enum ColumnType
    {
        NUMERIC(0), STRING(1);
        private final int value;

        ColumnType(int value)
        {
            this.value = value;
        }

        public int value()
        {
            return this.value;
        }
    }
}

/**
 * 计算最大表头层级（确定需要创建多少行表头）
 */
private void calculateMaxHeaderLevel() {
    maxHeaderLevel = 0;
    for (Object[] os : fields) {
        Excel excel = (Excel) os[1];
        // 处理headerMerge配置中的结束行
        if (StringUtils.isNotEmpty(excel.headerMerge())) {
            String[] mergeParams = excel.headerMerge().split(",");
            if (mergeParams.length == 4) {
                try {
                    int lastRow = Integer.parseInt(mergeParams[1]);
                    if (lastRow > maxHeaderLevel) {
                        maxHeaderLevel = lastRow;
                    }
                } catch (NumberFormatException e) {
                    log.warn("headerMerge参数格式错误: {}", excel.headerMerge());
                }
            }
        }
        // 处理headerLevel配置
        if (excel.headerLevel() > maxHeaderLevel) {
            maxHeaderLevel = excel.headerLevel();
        }
    }
    // 兜底：至少保留1级表头
    if (maxHeaderLevel < 0) {
        maxHeaderLevel = 0;
    }
}

/**
 * 创建多级表头 - 完整实现
 */
private void createMultiLevelHeader() {
    // 1. 计算最大表头层级
    calculateMaxHeaderLevel();
    
    // 2. 创建所有表头行并设置行高
    for (int level = 0; level <= maxHeaderLevel; level++) {
        Row row = sheet.createRow(level);
        headerRows.put(level, row);
        row.setHeight((short) (25 * 20)); // 统一设置表头行高（25磅）
    }

    // 3. 填充表头内容（根据模式选择不同实现）
    fillHeaderContent();

    // 4. 处理表头合并（核心）
    processHeaderMerge();

    // 5. 设置列宽
    setColumnWidths();
}

/**
 * 多级表头专用 - 填充表头内容
 */
private void fillHeaderContentMultiLevel() {
    int logicalIndex = 0;
    int physicalColumn = 0;

    log.debug("=== 开始多级表头填充 ===");

    for (Object[] os : fields) {
        Excel excel = (Excel) os[1];
        String headerMerge = excel.headerMerge();

        int actualColumn = physicalColumn;
        int columnSpan = 1;

        // 解析合并参数，确定列位置和跨度
        if (StringUtils.isNotEmpty(headerMerge)) {
            String[] mergeParams = headerMerge.split(",");
            if (mergeParams.length == 4) {
                try {
                    int configFirstCol = Integer.parseInt(mergeParams[2]);
                    int configLastCol = Integer.parseInt(mergeParams[3]);
                    actualColumn = configFirstCol;
                    columnSpan = configLastCol - configFirstCol + 1;
                    
                    log.debug("分组字段[{}]: 逻辑索引={}, 实际列={}, 跨度={}",
                            excel.name(), logicalIndex, actualColumn, columnSpan);
                } catch (NumberFormatException e) {
                    log.warn("headerMerge参数格式错误: {}", headerMerge);
                }
            }
        }

        // 为每个层级创建单元格
        for (int level = 0; level <= maxHeaderLevel; level++) {
            Row row = headerRows.get(level);
            // 确保单元格存在（避免空指针）
            Cell cell = row.getCell(actualColumn);
            if (cell == null) {
                cell = row.createCell(actualColumn);
            }
            // 应用表头样式
            cell.setCellStyle(styles.get("header0"));

            boolean shouldShowContent = false;

            // 分组表头处理：只在合并区域起始位置显示内容
            if (StringUtils.isNotEmpty(headerMerge)) {
                String[] mergeParams = headerMerge.split(",");
                int firstRow = Integer.parseInt(mergeParams[0]);
                int firstCol = Integer.parseInt(mergeParams[2]);
                
                // 仅在合并区域的左上角单元格显示标题
                if (level == firstRow && actualColumn == firstCol) {
                    cell.setCellValue(excel.name());
                    shouldShowContent = true;
                    log.debug("设置标题[{}]在位置: 行={}, 列={}",
                            excel.name(), level, actualColumn);
                }
            } else {
                // 普通表头：按层级显示
                if (excel.headerLevel() == level) {
                    cell.setCellValue(excel.name());
                    shouldShowContent = true;
                }
            }

            // 非显示单元格置空
            if (!shouldShowContent && cell.getCellType() == CellType.BLANK.getCode()) {
                cell.setCellValue("");
            }
        }

        // 更新列索引
        if (StringUtils.isNotEmpty(headerMerge)) {
            String[] mergeParams = headerMerge.split(",");
            int lastCol = Integer.parseInt(mergeParams[3]);
            physicalColumn = lastCol + 1;
        } else {
            physicalColumn++;
        }
        logicalIndex++;
    }
    log.debug("=== 结束多级表头填充 ===");
}

/**
 * 处理表头合并（多级表头专用）
 */
private void processHeaderMergeMultiLevel() {
    int logicalIndex = 0;
    int physicalColumn = 0;

    for (Object[] os : fields) {
        Excel excel = (Excel) os[1];
        String headerMerge = excel.headerMerge();

        // 跳过无合并配置的字段
        if (StringUtils.isEmpty(headerMerge)) {
            physicalColumn++;
            logicalIndex++;
            continue;
        }

        String[] mergeParams = headerMerge.split(",");
        if (mergeParams.length == 4) {
            try {
                // 解析合并参数
                int firstRow = Integer.parseInt(mergeParams[0]);
                int lastRow = Integer.parseInt(mergeParams[1]);
                int firstCol = Integer.parseInt(mergeParams[2]);
                int lastCol = Integer.parseInt(mergeParams[3]);

                // 验证合并区域有效性（关键：避免越界）
                if (firstRow >= 0 && lastRow <= maxHeaderLevel &&
                        firstCol >= 0 && lastCol < getTotalColumns() &&
                        firstRow <= lastRow && firstCol <= lastCol) {

                    // 创建合并区域
                    CellRangeAddress region = new CellRangeAddress(
                        firstRow, lastRow, firstCol, lastCol);
                    
                    // 添加合并区域到工作表
                    sheet.addMergedRegion(region);
                    log.debug("添加合并区域: {}-{}, {}-{} → 字段[{}]",
                        firstRow, lastRow, firstCol, lastCol, excel.name());
                } else {
                    log.warn("合并区域无效: {}-{}, {}-{} → 字段[{}]",
                        firstRow, lastRow, firstCol, lastCol, excel.name());
                }
            } catch (NumberFormatException e) {
                log.error("表头合并参数格式错误: {} → 字段[{}]", headerMerge, excel.name(), e);
            } catch (Exception e) {
                log.error("添加合并区域失败: {} → 字段[{}]", headerMerge, excel.name(), e);
            }
        }

        // 更新列索引
        if (StringUtils.isNotEmpty(headerMerge)) {
            String[] mergeParams = headerMerge.split(",");
            int lastCol = Integer.parseInt(mergeParams[3]);
            physicalColumn = lastCol + 1;
        } else {
            physicalColumn++;
        }
        logicalIndex++;
    }
}

/**
 * 计算总列数 - 多级表头专用
 */
private int getTotalColumns() {
    int total = 0;
    for (Object[] os : fields) {
        Excel excel = (Excel) os[1];
        String headerMerge = excel.headerMerge();

        if (StringUtils.isNotEmpty(headerMerge)) {
            String[] mergeParams = headerMerge.split(",");
            if (mergeParams.length == 4) {
                try {
                    int firstCol = Integer.parseInt(mergeParams[2]);
                    int lastCol = Integer.parseInt(mergeParams[3]);
                    total = Math.max(total, lastCol + 1);
                } catch (NumberFormatException e) {
                    total++;
                }
            }
        } else {
            total++;
        }
    }
    return total;
}

/**
 * 创建表格样式 - 统一管理表头和数据样式
 */
private Map<String, CellStyle> createStyles(Workbook wb) {
    Map<String, CellStyle> styles = new HashMap<>();

    // 1. 数据单元格样式
    CellStyle dataStyle = wb.createCellStyle();
    // 居中对齐
    dataStyle.setAlignment(HorizontalAlignment.CENTER);
    dataStyle.setVerticalAlignment(VerticalAlignment.CENTER);
    // 边框样式
    dataStyle.setBorderRight(BorderStyle.THIN);
    dataStyle.setRightBorderColor(IndexedColors.GREY_50_PERCENT.getIndex());
    dataStyle.setBorderLeft(BorderStyle.THIN);
    dataStyle.setLeftBorderColor(IndexedColors.GREY_50_PERCENT.getIndex());
    dataStyle.setBorderTop(BorderStyle.THIN);
    dataStyle.setTopBorderColor(IndexedColors.GREY_50_PERCENT.getIndex());
    dataStyle.setBorderBottom(BorderStyle.THIN);
    dataStyle.setBottomBorderColor(IndexedColors.GREY_50_PERCENT.getIndex());
    // 字体
    Font dataFont = wb.createFont();
    dataFont.setFontName("宋体");
    dataFont.setFontHeightInPoints((short) 10);
    dataStyle.setFont(dataFont);
    styles.put("data", dataStyle);

    // 2. 表头样式（所有层级共用）
    CellStyle headerStyle = wb.createCellStyle();
    headerStyle.cloneStyleFrom(dataStyle);
    // 表头居中对齐
    headerStyle.setAlignment(HorizontalAlignment.CENTER);
    headerStyle.setVerticalAlignment(VerticalAlignment.CENTER);
    // 浅灰色背景
    headerStyle.setFillForegroundColor(IndexedColors.GREY_25_PERCENT.getIndex());
    headerStyle.setFillPattern(FillPatternType.SOLID_FOREGROUND);
    // 加粗字体
    Font headerFont = wb.createFont();
    headerFont.setFontName("宋体");
    headerFont.setFontHeightInPoints((short) 11);
    headerFont.setBold(true);
    headerFont.setColor(IndexedColors.BLACK.getIndex());
    headerStyle.setFont(headerFont);
    // 所有层级表头共用一个样式
    for (int i = 0; i <= 4; i++) {
        styles.put("header" + i, headerStyle);
    }

    return styles;
}

import com.tydt.framework.web.domain.AjaxResult;
import org.apache.shiro.authz.annotation.RequiresPermissions;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.ResponseBody;

/**
 * 导出地下管线-现有道路-年度计划库
 */
@RequiresPermissions("ssjs:xyndjhk:export")
@Log(title = "地下管线-现有道路-年度计划库", businessType = BusinessType.EXPORT)
@PostMapping("/export")
@ResponseBody
public AjaxResult export(@RequestBody SsjsGxSnjhk snjhk) {
    try {
        if ("1".equals(snjhk.getExportType())) {
            // 按所在地导出（启用多级表头）
            List<ExportSnjhkGxNdjhkDTOBySzd> list = xyGxSnjhkService.selectExportSnjhkGxNdjhkDTOBySzdList(snjhk);
            ExcelUtilMerge<ExportSnjhkGxNdjhkDTOBySzd> util = new ExcelUtilMerge<>(ExportSnjhkGxNdjhkDTOBySzd.class);
            util.setMultiLevelHeaderMode(true); // 关键：启用多级表头模式
            return util.exportExcel(list, "现有道路-储备项目库-按所在地导出");
        }  else {
            // 默认导出（普通表头）
            List<ExportGxDTO> list = ssjsXyGxndjhkService.selectExportGxDTOList(snjhk);
            ExcelUtilMerge<ExportGxDTO> util = new ExcelUtilMerge<>(ExportGxDTO.class);
            return util.exportExcel(list, "现有道路-年度计划库-默认导出");
        }
    } catch (Exception e) {
        log.error("Excel导出失败", e);
        return AjaxResult.error("导出失败：" + e.getMessage());
    }
}