合同doc/docx文件渲染参数，实现动态展示文档，并可配置

实现效果

模板文件

效果

前端页面展示采用，microsoft联机文档查看的方式

地址：https://products.office.com/zh-CN/office-online/view-office-documents-online

数据库设计相信天才般的你已经知道怎么处理了，废话不多说，上代码

pom.xml

    <dependency>
            <groupId>org.apache.poi</groupId>
            <artifactId>poi</artifactId>
            <version>3.17</version>
        </dependency>
        <dependency>
            <groupId>org.apache.poi</groupId>
            <artifactId>poi-ooxml</artifactId>
            <version>3.17</version>
        </dependency>
        <dependency>
            <groupId>org.apache.poi</groupId>
            <artifactId>poi-ooxml-schemas</artifactId>
            <version>3.17</version>
        </dependency>
        <dependency>
            <groupId>org.apache.poi</groupId>
            <artifactId>poi-contrib</artifactId>
            <version>3.6</version>
        </dependency>
        <dependency>
            <groupId>org.apache.poi</groupId>
            <artifactId>poi-scratchpad</artifactId>
            <version>3.17</version>
        </dependency>

与上一篇文章类似，这里我们不需要将云上的文件下载到本地在进行处理
替换文档参数核心方法

/**
 * inputStream 文档输入流
 * outputStream 文档输入流
 * map 带替换参数及value
 * isDownload 是否为下载文件，如果不是下载，在前端展示合同时将渲染参数标红。
 *
 */
public static void replaceText(InputStream inputStream, OutputStream outputStream, Map<String, String> map, String fileName, Integer isDownload) {
        try {
            if (fileName.endsWith(Constants.DOC)) {
                //1. 替换段落中的指定文字
                HWPFDocument document = new HWPFDocument(inputStream);
                Range range = document.getRange();
                //读取word文本内容
                //替换文本内容
                for (Map.Entry entry : map.entrySet()) {
                    range.replaceText(entry.getKey().toString(), entry.getValue() == null ? "" : entry.getValue().toString());
                }
                TableIterator it = new TableIterator(range);
                //迭代文档中的表格
                while (it.hasNext()) {
                    Table tb = it.next();
                    //迭代行，默认从0开始
                    for (int i = 0; i < tb.numRows(); i++) {
                        TableRow tr = tb.getRow(i);
                        //迭代列，默认从0开始
                        for (int j = 0; j < tr.numCells(); j++) {
                            TableCell td = tr.getCell(j);
                            //取得单元格的内容
                            for (int k = 0; k < td.numParagraphs(); k++) {
                                Paragraph para = td.getParagraph(k);
                                for (Map.Entry<String, String> e : map.entrySet()) {
                                    if (para.text().equals(e.getKey())) {
                                        String tempKey = e.getKey().replaceAll("\\{", "\\\\{");
                                        tempKey = tempKey.replaceAll("\\}", "\\\\}");
                                        String value = para.text().replaceAll(tempKey, e.getValue());
                                        para.replaceText(e.getKey(), value);
                                    }
                                }
                            }

                        }
                    }
                }
                document.write(outputStream);
            } else if (fileName.endsWith(Constants.DOCX)) {
                XWPFDocument document = new XWPFDocument(inputStream);
                //1. 替换段落中的指定文字
                Iterator<XWPFParagraph> itPara = document.getParagraphsIterator();
                String text;
                Set<String> set;
                XWPFParagraph paragraph;
                List<XWPFRun> run;
                String key;
                while (itPara.hasNext()) {
                    paragraph = itPara.next();
                    set = map.keySet();
                    for (String aSet : set) {
                        key = aSet;
                        run = paragraph.getRuns();
                        for (int i = 0; i < run.size(); i++) {
                            XWPFRun aRun = run.get(i);

                            text = aRun.getText(aRun.getTextPosition());
                            if (text != null) {
                                String text2 = text.replaceAll("\\{", "\\\\{");
                                text2 = text2.replaceAll("\\}", "\\\\}");
                                if (text.equals(key) || text2.equals(key)) {
                                    aRun.setText(map.get(key), 0);
                                    if (isDownload == 1) {
                                        aRun.setColor("FF0000");
                                        aRun.setBold(false);
                                        aRun.setUnderline(UnderlinePatterns.WORDS);
                                    }
                                }
                            }
                            if (i > 1) {
                                String tempText = run.get(i - 2).getText(run.get(i - 2).getTextPosition()) + run.get(i - 1).getText(run.get(i - 1).getTextPosition()) + aRun.getText(aRun.getTextPosition());
                                if (tempText != null && tempText.indexOf(key) > -1) {
                                    String key2 = aSet.replaceAll("\\{", "\\\\{");
                                    key2 = key2.replaceAll("\\}", "\\\\}");
                                    String[] tempStrArr = tempText.split(key2);
                                    if (tempStrArr.length == 2) {
                                        run.get(i - 2).setText(tempStrArr[0], 0);
                                        run.get(i - 1).setText(map.get(key) == null ? "" : map.get(key), 0);
                                        if (isDownload == 1) {
                                            run.get(i - 1).setColor("FF0000");
                                            run.get(i - 1).setBold(false);
                                            run.get(i - 1).setUnderline(UnderlinePatterns.WORDS);
                                        }
                                        aRun.setText(tempStrArr[1], 0);
                                    } else {
                                        run.get(i - 2).setText("", 0);
                                        if (tempStrArr.length > 0) {
                                            run.get(i - 1).setText(tempStrArr[0], 0);
                                        } else {
                                            run.get(i - 1).setText("", 0);
                                        }
                                        aRun.setText(map.get(key) == null ? "" : map.get(key), 0);
                                        if (isDownload == 1) {
                                            aRun.setColor("FF0000");
                                            aRun.setBold(false);
                                            aRun.setUnderline(UnderlinePatterns.WORDS);
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
                //2. 替换表格中的指定文字
                Iterator<XWPFTable> itTable = document.getTablesIterator();
                XWPFTable table;
                int rowsCount;
                while (itTable.hasNext()) {
                    table = itTable.next();
                    rowsCount = table.getNumberOfRows();
                    for (int i = 0; i < rowsCount; i++) {
                        XWPFTableRow row = table.getRow(i);
                        List<XWPFTableCell> cells = row.getTableCells();
                        for (XWPFTableCell cell : cells) {
                            String text1 = cell.getText();
                            String flag = text1;
                            for (Map.Entry<String, String> e : map.entrySet()) {
                                if (text1.contains(e.getKey())) {
                                    String key2 = e.getKey().replaceAll("\\{", "\\\\{");
                                    key2 = key2.replaceAll("\\}", "\\\\}");
                                    text1 = text1.replaceAll(key2, e.getValue() == null ? "" : e.getValue());

                                }
                            }
                            if (cell.getParagraphs().size() > 0) {
                                cell.removeParagraph(0);
                            }
                            cell.setText(text1);
                            if (isDownload == 1 && !flag.equals(text1)) {
                                cell.setColor("FF0000");
                            }

                        }
                    }
                }
                document.write(outputStream);
            } else {
                System.out.println("此文件不是word文件！");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

在上边方法中需要说明几个地方

• 有些童鞋可能会问为啥那么多/,在替换字符串的时候，注意在java语法中第一个"/“是被当做转义字符存在的，所以会有那么多，另外为什么需要将”\{“替换为”\\{"，因为在replace方法中其实第一个参数是被当做正则表达式来做处理的，而“{}” 在正则中是有特殊含义的所以需要替换为"\\{"这种我们才能正确渲染合同模板

好处

在此方法中，如果doc文件中存在表格，只要满足公式，一样会被替换

坑

在编写doc文档时，

注意，同一参数要保证样式一致！

注意，同一参数要保证样式一致 ！

注意，同一参数要保证样式一致 ！

（md当初浪费老子半天时间的bug）