JXLS 2.x 模板导出

前言

我之前一直使用jxls 1.x版本对简单的列表进行导出，模板定义很简单，导出数据开发工作很轻松。最近使用jxls 2.x版本来导出数据，2.x版本变化最大的就是批注的方式定义模板，支持的功能更我之前一直使用jxls 1.x版本对简单的列表进行导出，模板定义很简单，导出数据开发工作很轻松。最近使用jxls 2.x版本来导出数据，2.x版本变化最大的就是批注的方式定义模板，支持的功能更加丰富，这是目前我用过最好的excel导出工具，基本可以完全满足所有的项目需要。

看一个简单的模板和效果：

模板

效果

一、添加maven依赖

<dependency>
    <groupId>org.jxls</groupId>
    <artifactId>jxls</artifactId>
    <version>2.4.6</version>
</dependency>
<dependency>
    <groupId>org.jxls</groupId>
    <artifactId>jxls-poi</artifactId>
    <version>1.0.15</version>
</dependency>
<dependency>
    <groupId>org.jxls</groupId>
    <artifactId>jxls-jexcel</artifactId>
    <version>1.0.6</version>
</dependency>

二、编写Excel的工具类

为了简化重复的工作，现在编写一个简单的工具类

public class ExcelUtil {

    static {
        //注册 jx 命令，这里增加合并单元格的自定义命令
        XlsCommentAreaBuilder.addCommandMapping("merge", MergeCommand.class);
    }

    /**
     * 一般模板导出
     *
     * @param request        http请求
     * @param response       http应答
     * @param templatePath   模板的路径
     * @param exportFileName 导出文件名字
     * @param model          数据
     * @throws IOException
     */
    public static void exportExcel(HttpServletRequest request, HttpServletResponse response, String templatePath, String exportFileName, Map<String, Object> model) throws IOException {
        // 这里对导出excel的响应头进行处理
        exportHeader(request, response, exportFileName);

        ClassPathResource resource = new ClassPathResource(templatePath);
        InputStream is = resource.getInputStream();
        OutputStream os = response.getOutputStream();
        // 定义jxls的上下文参数
        Context context = PoiTransformer.createInitialContext();
        if (model != null) {
            for (String key : model.keySet()) {
                context.putVar(key, model.get(key));
            }
        }

        JxlsHelper jxlsHelper = JxlsHelper.getInstance();
        Transformer transformer = jxlsHelper.createTransformer(is, os);
        //获得配置
        JexlExpressionEvaluator evaluator = (JexlExpressionEvaluator) transformer.getTransformationConfig().getExpressionEvaluator();
        //函数强制，自定义功能
        Map<String, Object> funcs = new HashMap<String, Object>();
        funcs.put("utils", new ExcelUtil());    //添加自定义功能
        evaluator.getJexlEngine().setFunctions(funcs);
        //必须要这个，否者表格函数统计会错乱
        jxlsHelper.setUseFastFormulaProcessor(false).processTemplate(context, transformer);
    }

    /**
     * 表格方式导出
     *
     * @param request        http请求
     * @param response       http应答
     * @param templatePath   模板的路径
     * @param exportFileName 导出文件名字
     * @param model          数据
     * @param objectProps    对象属性
     * @throws IOException
     */
    public static void exportGridExcel(HttpServletRequest request, HttpServletResponse response,  String templatePath, String exportFileName, Map<String, Object> model, String objectProps) throws IOException {

        exportHeader(request, response, exportFileName);
        ClassPathResource resource = new ClassPathResource(templatePath);
        InputStream is = resource.getInputStream();
        OutputStream os = response.getOutputStream();
        Context context = PoiTransformer.createInitialContext();
        if (model != null) {
            for (String key : model.keySet()) {
                context.putVar(key, model.get(key));
            }
        }
        JxlsHelper.getInstance().processGridTemplateAtCell(is, os, context, objectProps, "Sheet1!A1");
    }

    /**
     * 导出文件头设置
     *
     * @param request        http请求
     * @param response       http应答
     * @param exportFileName 导出文件名称
     * @throws UnsupportedEncodingException
     */
    private static void exportHeader(HttpServletRequest request, HttpServletResponse response, String exportFileName) throws UnsupportedEncodingException {
        response.reset();
        response.setHeader("Accept-Ranges", "bytes");

        String userAgent = request.getHeader("User-Agent");
        //针对IE或者以IE为内核的浏览器：
        if (userAgent.contains("MSIE") || userAgent.contains("Trident")) {
            exportFileName = java.net.URLEncoder.encode(exportFileName, "UTF-8");
        } else {
            //非IE浏览器的处理：
            exportFileName = new String(exportFileName.getBytes("UTF-8"), "ISO-8859-1");
        }
        //设置导出弹出框，以及下载文件名称
        response.setHeader("Content-disposition", "attachment;filename=" + exportFileName);
    }
}

三、jxls一般用法

1.简单导出

代码：

public void exportSimpleExcel(HttpServletRequest request, HttpServletResponse response) {
    try {
        Map<String, Object> model = new HashMap<>();
        model.put("index", 1);
        model.put("name", "小明");
        model.put("sex", "男");
        ExcelUtil.exportExcel(request, response, "static/static/template/simple.xlsx", "简单Excel.xlsx", model);
    } catch (Exception e) {
        e.printStackTrace();
    }
}

数据格式：

{
    "sex":"男",
    "name":"小明",
    "index":1
}

模板

效果

标签说明：

jx:area(lastCell="D3")

在报表中最左上角（A1）加入一个注释jx:area(lastCell="D3")，含义为模板的区域由A1（加注释的单元格）到D3

${index} ${name} ${sex}

从数据中直接替换对应属性名字的占位符

2.列表导出

代码：

public void exportListExcel(HttpServletRequest request, HttpServletResponse response) {
    try {
        User user1 = new User(1, "小明1", "男");
        User user2 = new User(2, "小明2", "男");
        User user3 = new User(3, "小明3", "男");
        User user4 = new User(4, "小明4", "男");
        List<User> users = new ArrayList<>();
        users.add(user1);
        users.add(user2);
        users.add(user3);
        users.add(user4);
        Map<String, Object> model = new HashMap<>();
        // 数据
        model.put("items", users);
        // 标题
        model.put("title", "学生列表");

        ExcelUtil.exportExcel(request, response, "static/static/template/list.xlsx", "列表Excel.xlsx", model);
    } catch (Exception e) {
        e.printStackTrace();
    }
}

数据格式：

{
    "title":"学生列表",
    "items":[
        {
            "index":1,
            "name":"小明1",
            "score":0,
            "sex":"男"
        },
        {
            "index":2,
            "name":"小明2",
            "score":0,
            "sex":"男"
        },
        {
            "index":3,
            "name":"小明3",
            "score":0,
            "sex":"男"
        },
        {
            "index":4,
            "name":"小明4",
            "score":0,
            "sex":"男"
        }
    ]
}

模板

效果

标签说明：

jx:each(items="items" var="user" lastCell="D3")

遍历标签，items是数据的key，var是对数据的别名，lastCell是each标签有效的单元格范围，即一次循环从A3到D3都有效

如果E3中定义了一个${user.sex}，因为不在jx:each的有效范围内，所以不会将占位符替换

${user.index}

从jx:each var别名中输出对应属性的值

3.页面合计

代码：

public void exportSumExcel(HttpServletRequest request, HttpServletResponse response) {
    try {
        User user1 = new User(1, "小明1", "男", 60.3);
        User user2 = new User(2, "小明2", "男", 70.5);
        User user3 = new User(3, "小明3", "男", 80.4);
        User user4 = new User(4, "小明4", "男", 48.5);
        List<User> users = new ArrayList<>();
        users.add(user1);
        users.add(user2);
        users.add(user3);
        users.add(user4);
        Map<String, Object> model = new HashMap<>();
        // 数据
        model.put("users", users);

        ExcelUtil.exportExcel(request, response, "static/static/template/sumList.xlsx", "合计Excel.xlsx", model);
    } catch (Exception e) {
        e.printStackTrace();
    }
}

数据格式：

{
    "users":[
        {
            "index":1,
            "name":"小明1",
            "score":60.3,
            "sex":"男"
        },
        {
            "index":2,
            "name":"小明2",
            "score":70.5,
            "sex":"男"
        },
        {
            "index":3,
            "name":"小明3",
            "score":80.4,
            "sex":"男"
        },
        {
            "index":4,
            "name":"小明4",
            "score":48.5,
            "sex":"男"
        }
    ]
}

模板

效果

标签说明：

$[SUM(D2)]

JXSL会自动将D2列表对应的单元格都统计出来

也可以在对应合计的单元格上输入 =SUM(D2)

4.嵌套列表

代码：

public void exportCycleListExcel(HttpServletRequest request, HttpServletResponse response) {
    try {
        User user1 = new User(1, "小明1", "男");
        User user2 = new User(2, "小明2", "男");
        User user3 = new User(3, "小明3", "男");
        User user4 = new User(4, "小明4", "男");
        List<User> users = new ArrayList<>();
        users.add(user1);
        users.add(user2);
        users.add(user3);
        users.add(user4);
        Map<String, Object> clazz1 = new HashMap<>();
        clazz1.put("num", "01");
        clazz1.put("users", users);

        User user_1 = new User(1, "小红1", "女");
        User user_2 = new User(2, "小红2", "女");
        User user_3 = new User(3, "小红3", "女");
        User user_4 = new User(4, "小红4", "女");
        List<User> users_2 = new ArrayList<>();
        users_2.add(user_1);
        users_2.add(user_2);
        users_2.add(user_3);
        users_2.add(user_4);
        Map<String, Object> clazz1_2 = new HashMap<>();
        clazz1_2.put("num", "02");
        clazz1_2.put("users", users_2);

        List<Map<String, Object>> clazzList = new ArrayList<>();
        clazzList.add(clazz1);
        clazzList.add(clazz1_2);

        Map<String, Object> model = new HashMap<>();
        // 数据
        model.put("data", clazzList);

        ExcelUtil.exportExcel(request, response, "static/static/template/cycleList.xlsx", "嵌套循环Excel.xlsx", model);
    } catch (Exception e) {
        e.printStackTrace();
    }
}

数据格式：

{
    "data":[
        {
            "num":"01",
            "users":[
                {
                    "index":1,
                    "name":"小明1",
                    "score":0,
                    "sex":"男"
                },
                {
                    "index":2,
                    "name":"小明2",
                    "score":0,
                    "sex":"男"
                },
                {
                    "index":3,
                    "name":"小明3",
                    "score":0,
                    "sex":"男"
                },
                {
                    "index":4,
                    "name":"小明4",
                    "score":0,
                    "sex":"男"
                }
            ]
        },
        {
            "num":"02",
            "users":[
                {
                    "index":1,
                    "name":"小红1",
                    "score":0,
                    "sex":"女"
                },
                {
                    "index":2,
                    "name":"小红2",
                    "score":0,
                    "sex":"女"
                },
                {
                    "index":3,
                    "name":"小红3",
                    "score":0,
                    "sex":"女"
                },
                {
                    "index":4,
                    "name":"小红4",
                    "score":0,
                    "sex":"女"
                }
            ]
        }
    ]
}

模板

效果

5.表格

代码：

public void exportGridExcel(HttpServletRequest request, HttpServletResponse response) {
    try {
        User user1 = new User(1, "小明1", "男", 60.3);
        User user2 = new User(2, "小明2", "男", 70.5);
        User user3 = new User(3, "小明3", "男", 80.4);
        User user4 = new User(4, "小明4", "男", 48.5);
        List<User> users = new ArrayList<>();
        users.add(user1);
        users.add(user2);
        users.add(user3);
        users.add(user4);
        Map<String, Object> model = new HashMap<>();
        // 数据
        model.put("headers", Arrays.asList("序号", "姓名", "性别", "分数"));
        model.put("data", users);
        String objectProps = "index,name,sex,score";

        ExcelUtil.exportGridExcel(request, response, "static/static/template/gridList.xlsx", "表格Excel.xlsx", model, objectProps);
    } catch (Exception e) {
        e.printStackTrace();
    }
}

数据格式：

{
    "headers":[
        "序号",
        "姓名",
        "性别",
        "分数"
    ],
    "data":[
        {
            "index":1,
            "name":"小明1",
            "score":60.3,
            "sex":"男"
        },
        {
            "index":2,
            "name":"小明2",
            "score":70.5,
            "sex":"男"
        },
        {
            "index":3,
            "name":"小明3",
            "score":80.4,
            "sex":"男"
        },
        {
            "index":4,
            "name":"小明4",
            "score":48.5,
            "sex":"男"
        }
    ]
}

模板

效果

标签说明：

jx:grid(lastCell="A2" headers="headers" data="data" areas=[A1:A1, A2:A2] formatCells="BigDecimal:D1")

jx:grid 为固定格式，headers 表示表头，data对应${cell}的数据，areas表示表头的范围和数据的范围，formatCells 可以对特定的单元格进行格式化

ExcelUtil.exportGridExcel(request, response, "static/static/template/gridList.xlsx", "表格Excel.xlsx", model, objectProps);

调用的方法需要对对象属性进行说明，才能在cell中渲染出来

四、jxls复杂用法

1.多个sheet

代码：

public void exportMultiSheetExcel(HttpServletRequest request, HttpServletResponse response) {
    try {
        User user1 = new User(1, "小明1", "男", 60.3);
        User user2 = new User(2, "小明2", "男", 70.5);
        User user3 = new User(3, "小明3", "男", 80.4);
        User user4 = new User(4, "小明4", "男", 48.5);
        List<User> users = new ArrayList<>();
        users.add(user1);
        users.add(user2);
        users.add(user3);
        users.add(user4);
        Map<String, Object> clazz1 = new HashMap<>();
        clazz1.put("name", "三年级一班");
        clazz1.put("users", users);

        User user_1 = new User(1, "小红1", "女", 60.3);
        User user_2 = new User(2, "小红2", "女", 100);
        User user_3 = new User(3, "小红3", "女", 80.4);
        User user_4 = new User(4, "小红4", "女", 48.5);
        List<User> users_2 = new ArrayList<>();
        users_2.add(user_1);
        users_2.add(user_2);
        users_2.add(user_3);
        users_2.add(user_4);
        Map<String, Object> clazz1_2 = new HashMap<>();
        clazz1_2.put("name", "三年级二班");
        clazz1_2.put("users", users_2);

        List<Map<String, Object>> clazzList = new ArrayList<>();
        clazzList.add(clazz1);
        clazzList.add(clazz1_2);

        Map<String, Object> model = new HashMap<>();
        // 数据
        model.put("clazzs", clazzList);
        model.put("sheetNames", Arrays.asList("三年级一班", "三年级二班"));

        ExcelUtil.exportExcel(request, response, "static/static/template/multiSheet.xlsx", "多工作薄Excel.xlsx", model);
    } catch (Exception e) {
        e.printStackTrace();
    }
}

数据格式：

{
    "clazzs":[
        {
            "name":"三年级一班",
            "users":[
                {
                    "index":1,
                    "name":"小明1",
                    "score":60.3,
                    "sex":"男"
                },
                {
                    "index":2,
                    "name":"小明2",
                    "score":70.5,
                    "sex":"男"
                },
                {
                    "index":3,
                    "name":"小明3",
                    "score":80.4,
                    "sex":"男"
                },
                {
                    "index":4,
                    "name":"小明4",
                    "score":48.5,
                    "sex":"男"
                }
            ]
        },
        {
            "name":"三年级二班",
            "users":[
                {
                    "index":1,
                    "name":"小红1",
                    "score":60.3,
                    "sex":"女"
                },
                {
                    "index":2,
                    "name":"小红2",
                    "score":100,
                    "sex":"女"
                },
                {
                    "index":3,
                    "name":"小红3",
                    "score":80.4,
                    "sex":"女"
                },
                {
                    "index":4,
                    "name":"小红4",
                    "score":48.5,
                    "sex":"女"
                }
            ]
        }
    ],
    "sheetNames":[
        "三年级一班",
        "三年级二班"
    ]
}

模板

效果

标签说明：

jx:each(items="clazzs", var="clazz", lastCell="E5" multisheet="sheetNames")

multisheet="sheetNames" 对应的是

    "sheetNames":[
        "三年级一班",
        "三年级二班"
    ]

只要 sheetNames 的列表跟 clazzs 的列表数相同，就会在两个 sheet 中生成对应的数据

2.合并单元格

代码：

public void exportMergeExcel(HttpServletRequest request, HttpServletResponse response) {
        try {
            User user1 = new User(1, "小明1", "男", 60.3);
            User user2 = new User(2, "小明2", "男", 70.5);
            User user3 = new User(3, "小明3", "男", 80.4);
            User user4 = new User(4, "小明4", "男", 48.5);
            List<User> users = new ArrayList<>();
            users.add(user1);
            users.add(user2);
            users.add(user3);
            users.add(user4);
            Map<String, Object> clazz1 = new HashMap<>();
            clazz1.put("name", "三年级一班");
            clazz1.put("users", users);

            User user_1 = new User(1, "小红1", "女", 60.3);
            User user_2 = new User(2, "小红2", "女", 100);
            User user_3 = new User(3, "小红3", "女", 80.4);
            User user_4 = new User(4, "小红4", "女", 48.5);
            List<User> users_2 = new ArrayList<>();
            users_2.add(user_1);
            users_2.add(user_2);
            users_2.add(user_3);
            users_2.add(user_4);
            Map<String, Object> clazz1_2 = new HashMap<>();
            clazz1_2.put("name", "三年级二班");
            clazz1_2.put("users", users_2);

            List<Map<String, Object>> clazzList = new ArrayList<>();
            clazzList.add(clazz1);
            clazzList.add(clazz1_2);

            Map<String, Object> model = new HashMap<>();
            // 数据
            model.put("data", clazzList);

            ExcelUtil.exportExcel(request, response, "static/static/template/mergeCell.xlsx", "合并单元格Excel.xlsx", model);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

数据格式：

{
    "data":[
        {
            "name":"三年级一班",
            "users":[
                {
                    "index":1,
                    "name":"小明1",
                    "score":60.3,
                    "sex":"男"
                },
                {
                    "index":2,
                    "name":"小明2",
                    "score":70.5,
                    "sex":"男"
                },
                {
                    "index":3,
                    "name":"小明3",
                    "score":80.4,
                    "sex":"男"
                },
                {
                    "index":4,
                    "name":"小明4",
                    "score":48.5,
                    "sex":"男"
                }
            ]
        },
        {
            "name":"三年级二班",
            "users":[
                {
                    "index":1,
                    "name":"小红1",
                    "score":60.3,
                    "sex":"女"
                },
                {
                    "index":2,
                    "name":"小红2",
                    "score":100,
                    "sex":"女"
                },
                {
                    "index":3,
                    "name":"小红3",
                    "score":80.4,
                    "sex":"女"
                },
                {
                    "index":4,
                    "name":"小红4",
                    "score":48.5,
                    "sex":"女"
                }
            ]
        }
    ]
}

模板

效果

标签说明：

jx:merge(rows="clazz.users.size()" lastCell="A3")

jxls不支持 merge 单元格，需要自己实现合并单元格的方法，并把命令注册到 ExcelUtil 类中

static {
    //注册 jx 命令
    XlsCommentAreaBuilder.addCommandMapping("merge", MergeCommand.class);
}

3.插入图片

代码

// 这里构建对象
public void buildExcel() {
    List<CollectionPojo> collect = hits.stream().map(entity -> {
            JSONObject hit = (JSONObject) entity;
            log.info("{}", JSONObject.toJSONString(hit));
            JSONObject o = new JSONObject();
            o.put("name", hit.getString("name"));
            o.put("preview_image", hit.getString("preview_image"));
            ...
            CollectionPojo pojo = new CollectionPojo();
            pojo.setName(o.getString("name"));
            pojo.setPreviewImage(o.getString("preview_image"));
            ...
            try {
                pojo.setImg(getImage(pojo.getPreviewImage()));
            } catch (IOException e) {
                e.printStackTrace();
            }
            return pojo;
        }).collect(Collectors.toList());
        log.info("{}", JSONObject.toJSONString(collect));
    }
    Map<String, Object> model = new HashMap<>();
    model.put("items", collect);
    ExcelUtils.exportExcel("a/b/c.xlsx", "static/template/Thingiverse.xlsx", model, false);
}

private byte[] getImage(String imgPath) throws IOException {
    String path = imgPath.substring(imgPath.lastIndexOf("/"), imgPath.length());
    HttpUtil.downloadFile(imgPath, FileUtil.file(path), 60000);
    InputStream imageInputStream = new FileInputStream(path);
    // 使用工具方法把流转成byte数组
    byte[] imageBytes = IoUtil.readBytes(imageInputStream);
    return imageBytes;
}

数据

[
    {
        "commentCount":0,
        "createdAt":"2021-08-08",
        "creator":"AA3DPRINTING",
        "img":"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",
        "likeCount":42,
        "link":"https://www.xxx.com/thing:4927640",
        "makeCount":1,
        "name":"Elmo dtms - Wall Art"
    }
]

模板

效果

标签说明：

jx:image(lastCell="B4" src="data.img" imageType="PNG") 目前支持的格式比较少，PNG 就没错了

五、jxls与poi比较

1. jxls 对 poi 接口进行了封装，使用模板的方式进行导出，定义模板简单，能快速开发
2. poi 对 excel 进行直接操作，效率高，相比 jxls 来说需要对 excel 的 sheet、cell 进行编码实现

附录

merge类

public class MergeCommand extends AbstractCommand {
    private String cols;        //合并的列数
    private String rows;        //合并的行数
    private String minCols;     //最小合并的列数
    private String minRows;     //最小合并的行数
    private CellStyle cellStyle;//第一个单元格的样式

    private Area area;

    @Override
    public String getName() {
        return "merge";
    }

    @Override
    public Command addArea(Area area) {
        if (super.getAreaList().size() >= 1) {
            throw new IllegalArgumentException("You can add only a single area to 'merge' command");
        }
        this.area = area;
        return super.addArea(area);
    }

    @Override
    public Size applyAt(CellRef cellRef, Context context) {
        int rows = getVal(this.rows, context);
        int cols = getVal(this.cols, context);
        rows = Math.max(getVal(this.minRows, context), rows);
        cols = Math.max(getVal(this.minCols, context), cols);
        rows = rows > 0 ? rows : area.getSize().getHeight();
        cols = cols > 0 ? cols : area.getSize().getWidth();
        if (rows > 1 || cols > 1) {
            Transformer transformer = this.getTransformer();
            if (transformer instanceof PoiTransformer) {
                poiMerge(cellRef, context, (PoiTransformer) transformer, rows, cols);
            } else if (transformer instanceof JexcelTransformer) {
                jexcelMerge(cellRef, context, (JexcelTransformer) transformer, rows, cols);
            }
        }
        area.applyAt(cellRef, context);
        return new Size(cols, rows);
    }

    protected Size poiMerge(CellRef cellRef, Context context, PoiTransformer transformer, int rows, int cols) {
        Sheet sheet = transformer.getWorkbook().getSheet(cellRef.getSheetName());
        CellRangeAddress region = new CellRangeAddress(
                cellRef.getRow(),
                cellRef.getRow() + rows - 1,
                cellRef.getCol(),
                cellRef.getCol() + cols - 1);
        sheet.addMergedRegion(region);

        //合并之后单元格样式会丢失，以下操作将合并后的单元格恢复成合并前第一个单元格的样式
        area.applyAt(cellRef, context);
        if (cellStyle == null) {
            PoiCellData cellData = (PoiCellData) transformer.getCellData(area.getStartCellRef());
            if (cellData != null) {
                cellStyle = cellData.getCellStyle();
            }
        }
        setRegionStyle(cellStyle, region, sheet);
        return new Size(cols, rows);
    }

    protected Size jexcelMerge(CellRef cellRef, Context context, JexcelTransformer transformer, int rows, int cols) {
        try {
            transformer.getWritableWorkbook().getSheet(cellRef.getSheetName())
                    .mergeCells(
                            cellRef.getRow(),
                            cellRef.getCol(),
                            cellRef.getRow() + rows - 1,
                            cellRef.getCol() + cols - 1);
            area.applyAt(cellRef, context);
        } catch (WriteException e) {
            throw new IllegalArgumentException("合并单元格失败");
        }
        return new Size(cols, rows);
    }

    private static void setRegionStyle(CellStyle cs, CellRangeAddress region, Sheet sheet) {
        for (int i = region.getFirstRow(); i <= region.getLastRow(); i++) {
            Row row = sheet.getRow(i);
            if (row == null) {
                row = sheet.createRow(i);
            }
            for (int j = region.getFirstColumn(); j <= region.getLastColumn(); j++) {
                Cell cell = row.getCell(j);
                if (cell == null) {
                    cell = row.createCell(j);
                }
                if (cs == null) {
                    cell.getCellStyle().setAlignment(HorizontalAlignment.CENTER);
                    cell.getCellStyle().setVerticalAlignment(VerticalAlignment.CENTER);
                } else {
                    cell.setCellStyle(cs);
                }
            }
        }
    }

    private int getVal(String expression, Context context) {
        if (ExcelUtil.hasText(expression)) {
            Object obj = getTransformationConfig().getExpressionEvaluator().evaluate(expression, context.toMap());
            try {
                return Integer.parseInt(obj.toString());
            } catch (NumberFormatException e) {
                throw new IllegalArgumentException("表达式：" + expression + " 解析失败");
            }
        }
        return 0;
    }

    public String getCols() {
        return cols;
    }

    public void setCols(String cols) {
        this.cols = cols;
    }

    public String getRows() {
        return rows;
    }

    public void setRows(String rows) {
        this.rows = rows;
    }

    public String getMinCols() {
        return minCols;
    }

    public void setMinCols(String minCols) {
        this.minCols = minCols;
    }

    public String getMinRows() {
        return minRows;
    }

    public void setMinRows(String minRows) {
        this.minRows = minRows;
    }
}