JAVA word模版转换数据--工具类

这里先补充一个奇葩的问题，word里面的${}一定要用复制粘贴的。否则会出现分段错误，无法匹配正确的${}

package com.itsm.web.implement;

import org.apache.poi.util.Units;
import org.apache.poi.xwpf.usermodel.*;
import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTcPr;
import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTVMerge;
import org.openxmlformats.schemas.wordprocessingml.x2006.main.STMerge;

import javax.servlet.http.HttpServletResponse;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.*;

/**
 * 替换word模板数据
 *
 * @author:LeeShaoQing
 * @data: 2021-04-09
 */
public class GenerateWordTools {

    public static void main(String[] args) throws Exception {
        String path = "/Users/6011021-test.docx";
        Map<String, Object> data = new HashMap<>();
        data.put("${a}", "1");
        data.put("${b}", "2");
        data.put("${c}", "3");
        data.put("${d}", "4");
        data.put("${e}", "5");
        data.put("${f}", "6");
        data.put("${g}", "7");
        data.put("${h}", "8");
        data.put("${isk}", "9");
        data.put("${j}", "10");

        List<Object> mapList = new ArrayList<>();

        List<String[]> list01 = new ArrayList<>();
        list01.add(new String[]{"a1","11111111111","22","22","1","1","1","1","1"});
        list01.add(new String[]{"b2","22222222222","33","22","1","1","1","1","1"});
        list01.add(new String[]{"c3","33333333333","44","22","1","1","1","1","1"});
        list01.add(new String[]{"d4","44444444444","55","22","1","1","1","1","1"});
        mapList.add(list01);

        //需要动态改变表格的位置；第一个表格的位置为0
        int[] placeList = {1};
        generateWord(null, data, mapList, placeList, null, null);
    }

    /**
     * 生成Word文件
     * @param data
     * @param is
     * @param picMap
     * @throws Exception
     */
    public static void generateWord(InputStream is, Map<String, Object> data, List<Object> mapList ,int[] placeList, Map<String, Object> picMap, HttpServletResponse response)
            throws Exception {
        try (XWPFDocument document = new XWPFDocument(is)) {
            // 替换掉word文件表格之外的文本(仅限文本)
            changeText(document, data);

            // 替换word表格内的文本对象
            changeTableText(document, data);

            // 解析替换表格对象（新增行数）
            // changeTable(document, data, mapList, placeList);


            // 替换图片
            if (picMap != null && picMap.containsKey("brandLogo")) {
                changePic(document, picMap);
            }

            // 替换word表格内的图片对象
            //changeTablePic(document, picMap);

            long time = System.currentTimeMillis();// 获取系统时间
            // 使用try和catch关键字捕获异常
            OutputStream os = null;
            try {
                String fileName = "report.docx";
                response.setHeader("Content-Disposition", "attachment; filename=" + fileName);
                response.setContentType("application/octet-stream;charset=utf-8");
                os = response.getOutputStream();
                document.write(os);
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (os != null && is != null) {
                    os.close();
                    is.close();
                }
            }
        }
    }

    /**
     * 替换段落文本
     *
     * @param document docx解析对象
     * @param textMap  需要替换的信息集合
     */
    public static void changeText(XWPFDocument document, Map<String, Object> textMap) {
        // 获取段落集合
        // 返回包含页眉或页脚文本的段落
        List<XWPFParagraph> paragraphs = document.getParagraphs();
        for (XWPFParagraph paragraph : paragraphs) {
            // 判断此段落是否需要替换
            String text = paragraph.getText();// 检索文档中的所有文本
            if (checkText(text)) {
                // 注意：分段的标识${}必须为复制到word中，否则会出现分段错误。
                List<XWPFRun> runs = paragraph.getRuns();
                for (XWPFRun run : runs) {
                    // 替换模板原来位置
                    Object ob = changeValue(run.toString(), textMap);
                    if (ob instanceof String) {
                        if (textMap.containsKey(run.toString())) {
                            run.setText((String) ob, 0);
                        }
                    }
                }
            }
        }
    }

    /* 检查文本中是否包含指定的字符(此处为“$”)，并返回值 */
    public static boolean checkText(String text) {
        boolean check = false;
        if (text.contains("$")) {
            check = true;
        }
        return check;
    }

    public static Object changeValue(String value, Map<String, Object> textMap) {
        Set<Map.Entry<String, Object>> textSets = textMap.entrySet();
        Object object = "";
        for (Map.Entry<String, Object> textSet : textSets) {
            // 匹配模板与替换值 格式${key}
            String key = textSet.getKey();
            if (value.contains(key)) {
                object = textSet.getValue();
            }
        }
        return object;
    }

    /**
     * 替换图片
     *
     * @param document
     * @param textMap
     * @throws Exception
     */
    public static void changePic(XWPFDocument document, Map<String, Object> textMap) throws Exception {
        // 获取段落集合
        List<XWPFParagraph> paragraphs = document.getParagraphs();

        for (XWPFParagraph paragraph : paragraphs) {
            // 判断此段落是否需要替换
            String text = paragraph.getText();
            if (checkText(text)) {
                List<XWPFRun> runs = paragraph.getRuns();
                for (XWPFRun run : runs) {
                    // 替换模板原来位置
                    Object ob = changeValue(run.toString(), textMap);
                    if (ob instanceof String) {
                        if (textMap.containsKey(run.toString())) {
                            run.setText("", 0);
                            try (FileInputStream is = new FileInputStream((String) ob)) {
                                run.addPicture(is, XWPFDocument.PICTURE_TYPE_PNG, (String) ob, Units.toEMU(100),
                                        Units.toEMU(100));
                            }
                        }
                    }
                }
            }
        }
    }

    /**
     * 替换文件中的表格数据
     * @param document
     * @param data
     */
    public static void changeTableText(XWPFDocument document, Map<String, Object> data) {
        // 获取文件的表格
        List<XWPFTable> tableList = document.getTables();

        // 循环所有需要进行替换的文本，进行替换
        for (int i = 0; i < tableList.size(); i++) {
            XWPFTable table = tableList.get(i);
            if (checkText(table.getText())) {
                List<XWPFTableRow> rows = table.getRows();
                // 遍历表格，并替换模板
                eachTable(document, rows, data);
            }
        }

    }

    /**
     * 替换表格对象方法
     *
     * @param document docx解析对象
     * @param textMap  需要替换的信息集合
     * @param mapList  需要动态生成的内容
     */
    public static void changeTable(XWPFDocument document, Map<String, Object> textMap, List<Object> mapList, int[] placeList) {
        //获取表格对象集合
        List<XWPFTable> tables = document.getTables();

        int index = 0;
        //操作word中的表格
        for (int i = 0; i < tables.size(); i++) {
            //只处理行数大于等于2的表格，且不循环表头
            XWPFTable table = tables.get(i);
            if (placeList[index] == i) {
                List<String[]> list = (List<String[]>) mapList.get(index);
                //第二个表格使用daList，插入数据
                if (null != list && 0 < list.size()) {
                    insertTable(table, null, list, 2);
                    List<Integer[]> indexList = startEnd(list);
                    for (int c = 0; c < indexList.size(); c++) {
                        //合并行
                        mergeCellVertically(table, 0, indexList.get(c)[0] + 1, indexList.get(c)[1] + 1);
                    }
                }
                index++;
            }
        }
    }

    /**
     * 为表格插入数据，行数不够添加新行
     *
     * @param table     需要插入数据的表格
     * @param tableList 第四个表格的插入数据
     * @param daList    第二个表格的插入数据
     * @param type      表格类型：1-第一个表格 2-第二个表格 3-第三个表格 4-第四个表格
     */
    public static void insertTable(XWPFTable table, List<String> tableList, List<String[]> daList, Integer type) {
        if (2 == type) {
            //创建行和创建需要的列
            for (int i = 1; i < daList.size(); i++) {
                //添加一个新行（从第3行开始）
                XWPFTableRow row = table.insertNewTableRow(2);
                for (int k = 0; k < daList.get(0).length; k++) {
                    row.createCell();//根据String数组第一条数据的长度动态创建列
                }
            }

            //创建行,根据需要插入的数据添加新行，不处理表头
            for (int i = 0; i < daList.size(); i++) {
                List<XWPFTableCell> cells = table.getRow(i + 2).getTableCells();
                for (int j = 0; j < cells.size(); j++) {
                    XWPFTableCell cell02 = cells.get(j);
                    cell02.setText(daList.get(i)[j]);
                }
            }
        } else if (4 == type) {
            //插入表头下面第一行的数据
            for (int i = 0; i < tableList.size(); i++) {
                XWPFTableRow row = table.createRow();
                List<XWPFTableCell> cells = row.getTableCells();
                cells.get(0).setText(tableList.get(i));
            }
        }
    }

    /**
     * 合并行
     * @param table
     * @param col 需要合并的列
     * @param fromRow 开始行
     * @param toRow 结束行
     */
    public static void mergeCellVertically(XWPFTable table, int col, int fromRow, int toRow) {
        for (int rowIndex = fromRow; rowIndex <= toRow; rowIndex++) {
            CTVMerge vmerge = CTVMerge.Factory.newInstance();
            if (rowIndex == fromRow) {
                vmerge.setVal(STMerge.RESTART);
            } else {
                vmerge.setVal(STMerge.CONTINUE);
            }
            XWPFTableCell cell = table.getRow(rowIndex).getCell(col);
            CTTcPr tcPr = cell.getCTTc().getTcPr();
            if (tcPr != null) {
                tcPr.setVMerge(vmerge);
            } else {
                tcPr = CTTcPr.Factory.newInstance();
                tcPr.setVMerge(vmerge);
                cell.getCTTc().setTcPr(tcPr);
            }
        }
    }

    /**
     * 获取需要合并单元格的下标
     *
     * @return
     */
    public static List<Integer[]> startEnd(List<String[]> daList) {
        List<Integer[]> indexList = new ArrayList<Integer[]>();

        List<String> list = new ArrayList<String>();
        for (int i = 0; i < daList.size(); i++) {
            list.add(daList.get(i)[0]);
        }
        Map<Object, Integer> tm = new HashMap<Object, Integer>();
        for (int i = 0; i < daList.size(); i++) {
            if (!tm.containsKey(daList.get(i)[0])) {
                tm.put(daList.get(i)[0], 1);
            } else {
                int count = tm.get(daList.get(i)[0]) + 1;
                tm.put(daList.get(i)[0], count);
            }
        }
        for (Map.Entry<Object, Integer> entry : tm.entrySet()) {
            String key = entry.getKey().toString();
            String value = entry.getValue().toString();
            if (list.indexOf(key) != (-1)) {
                Integer[] index = new Integer[2];
                index[0] = list.indexOf(key);
                index[1] = list.lastIndexOf(key);
                indexList.add(index);
            }
        }
        return indexList;
    }

    /**
     * 替換文件中表格内的图片
     * @param document
     * @param pic
     * @throws Exception
     */
    public static void changeTablePic(XWPFDocument document, Map<String, Object> pic) throws Exception {
        List<XWPFTable> tableList = document.getTables();
        // 循环所有需要替换的文本，进行替换
        for (int i = 0; i < tableList.size(); i++) {
            XWPFTable table = tableList.get(i);
            if (checkText(table.getText())) {
                List<XWPFTableRow> rows = table.getRows();
                System.out.println("简单表格替换：" + rows);
                // 遍历表格，并替换模板
                eachTablePic(document, rows, pic);
            }
        }
    }

    public static void eachTablePic(XWPFDocument document, List<XWPFTableRow> rows, Map<String, Object> pic)
            throws Exception {
        for (XWPFTableRow row : rows) {
            List<XWPFTableCell> cells = row.getTableCells();
            for (XWPFTableCell cell : cells) {
                // 判断单元格是否需要替换
                if (checkText(cell.getText())) {
                    List<XWPFParagraph> paragraphs = cell.getParagraphs();
                    for (XWPFParagraph paragraph : paragraphs) {
                        List<XWPFRun> runs = paragraph.getRuns();
                        for (XWPFRun run : runs) {
                            Object ob = changeValue(run.toString(), pic);
                            if (ob instanceof String) {
                                System.out.println("run" + "'" + run.toString() + "'");
                                if (pic.containsKey(run.toString())) {
                                    System.out.println("run" + run.toString() + "替换为" + ob);
                                    run.setText("", 0);
                                    try (FileInputStream is = new FileInputStream((String) ob)) {
                                        run.addPicture(is, XWPFDocument.PICTURE_TYPE_PNG, (String) ob, Units.toEMU(100),
                                                Units.toEMU(100));
                                    }
                                } else {
                                    System.out.println("'" + run.toString() + "' 不匹配");
                                }
                            }
                        }
                    }
                }
            }
        }
    }

    public static void eachTable(XWPFDocument document, List<XWPFTableRow> rows, Map<String, Object> textMap) {
        for (XWPFTableRow row : rows) {
            List<XWPFTableCell> cells = row.getTableCells();
            for (XWPFTableCell cell : cells) {
                // 判断单元格是否需要替换
                if (checkText(cell.getText())) {
                    List<XWPFParagraph> paragraphs = cell.getParagraphs();
                    for (XWPFParagraph paragraph : paragraphs) {
                        List<XWPFRun> runs = paragraph.getRuns();
                        for (XWPFRun run : runs) {

                            Object ob = changeValue(run.toString(), textMap);
                            if (ob instanceof String) {

                                if (textMap.containsKey(run.toString())) {
                                    System.out.println("run:" + run.toString() + "替换为" + ob);
                                    run.setText((String) ob, 0);
                                } else {
                                    System.out.println("'" + run.toString() + "'不匹配");
                                }
                            }
                        }
                    }
                }
            }
        }
    }

}