关于富文本html通过java生成并导出word

项目场景：

项目背景：由于前端用其他平台的缘故不支持直接引用三方库本地开发，仅可利用平台在线的方式。
现要求将合同生成 word 并在线下载。

问题描述

思路有很多，后端赋值并通过 poi 生成一篇 word 文档，通过前端处理富文本模板并将数据代入传至后台生成 word 文档

第一种思路：

1. 制作 word 合同模板。
2. 将值传递替换进模板占位符。
3. 将替换完成模板导出。

这里试过这一种思路：弊端是代码量很多，在替换时会遍历每一行并将占位符进行替换，在此过程中有可能会将格式搞错，例如把下划线去掉了, 改了字体颜色，多加部分空格下划线。

提供工具类

package app.modules.common.util;


import cn.hutool.core.lang.Assert;
import lombok.Data;
import lombok.Setter;
import org.apache.poi.openxml4j.exceptions.InvalidFormatException;
import org.apache.poi.openxml4j.opc.OPCPackage;
import org.apache.poi.xwpf.usermodel.*;
import org.apache.xmlbeans.XmlCursor;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.*;
import java.util.*;


public class DynWordUtils {

    private final Logger logger = LoggerFactory.getLogger(DynWordUtils.class);

    
    private XWPFParagraph oldParagraph;

    
    private MapString, Object> paramMap;

    
    int n = 0;

    
    boolean isTable = false;

    
    XWPFDocument templateDoc;

    
    final int DEFAULT_FONT_SIZE = 10;

    
    private int currentRowIndex;

    
    public static void process(MapString, Object> paramMap, String templatePaht, String outPath, HttpServletRequest request, HttpServletResponse response) {
        DynWordUtils dynWordUtils = new DynWordUtils();
        dynWordUtils.setParamMap(paramMap);
        dynWordUtils.createWord(templatePaht, outPath,request,response);
    }

    private void setParamMap(MapString, Object> paramMap) {
        this.paramMap = paramMap;
    }

    
    public void createWord(String templatePath, String outPath,HttpServletRequest request, HttpServletResponse response) {
        File inFile = new File(templatePath);
        try (OutputStream out = response.getOutputStream()) {


            templateDoc = new XWPFDocument(OPCPackage.open(inFile));
            parseTemplateWord();
            

            
            







            
            response.setHeader("Content-Disposition", "attachment;filename=exported_document.docx");
            response.setContentType("application/vnd.openxmlformats-officedocument.wordprocessingml.document");
            templateDoc.write(out);
            out.flush();
            
            out.close();

        } catch (Exception e) {
            StackTraceElement[] stackTrace = e.getStackTrace();

            String className = stackTrace[0].getClassName();
            String methodName = stackTrace[0].getMethodName();
            int lineNumber = stackTrace[0].getLineNumber();

            logger.error("错误：第:{}行, 类名:{}, 方法名:{}", lineNumber, className, methodName);
            throw new RuntimeException(e.getCause().getMessage());
        }
    }

    
    public void parseTemplateWord() throws Exception {

        ListIBodyElement> elements = templateDoc.getBodyElements();

        for (; n  elements.size(); n++) {
            IBodyElement element = elements.get(n);
            
            if (element instanceof XWPFParagraph) {

                XWPFParagraph paragraph = (XWPFParagraph) element;
                oldParagraph = paragraph;
                if (paragraph.getParagraphText().isEmpty()) {
                    continue;
                }

                delParagraph(paragraph);

            }
            else if (element instanceof XWPFTable) {
                
                isTable = true;
                XWPFTable table = (XWPFTable) element;

                delTable(table, paramMap);
                isTable = false;
            }
        }

    }

    
    private void delParagraph(XWPFParagraph paragraph) throws Exception {
        ListXWPFRun> runs = oldParagraph.getRuns();
        StringBuilder sb = new StringBuilder();
        for (XWPFRun run : runs) {
            String text = run.getText(0);
            if (text == null) {
                continue;
            }
            sb.append(text);
            run.setText("", 0);
        }
        Placeholder(paragraph, runs, sb);
    }


    
    public void changeValue(XWPFRun currRun, String placeholder, MapString, Object> paramMap) throws Exception {

        String placeholderValue = placeholder;
        if (paramMap == null || paramMap.isEmpty()) {
            return;
        }




        MapString,Boolean> stringBooleanSet= new HashMap>();
        SetMap.EntryString, Object>> textSets = paramMap.entrySet();
        for (Map.EntryString, Object> textSet : textSets) {
            
            String mapKey = textSet.getKey();
            String docKey = PoiWordUtils.getDocKey(mapKey);
            if (placeholderValue.indexOf(docKey) != -1) {
                Object obj = textSet.getValue();
                
                if (obj instanceof List) {
                    placeholderValue = delDynList(placeholder, (List) obj);
                } else {
                    placeholderValue = placeholderValue.replaceAll(PoiWordUtils.getPlaceholderReg(mapKey), String.valueOf(obj));
                }

            }
        }
        currRun.setText(placeholderValue, 0);
    }

    
    private String delDynList(String placeholder, List obj) {
        String placeholderValue = placeholder;
        List dataList = obj;
        Collections.reverse(dataList);
        for (int i = 0, size = dataList.size(); i  size; i++) {
            Object text = dataList.get(i);
            
            if (i == 0) {
                placeholderValue = String.valueOf(text);
            } else {
                XWPFParagraph paragraph = createParagraph(String.valueOf(text));
                if (paragraph != null) {
                    oldParagraph = paragraph;
                }
                
                if (!isTable) {
                    n--;
                }
            }
        }
        return placeholderValue;
    }

    
    public XWPFParagraph createParagraph(String... texts) {

        
        XmlCursor cursor = oldParagraph.getCTP().newCursor();
        XWPFParagraph newPar = templateDoc.insertNewParagraph(cursor);
        
        newPar.getCTP().setPPr(oldParagraph.getCTP().getPPr());
        copyParagraph(oldParagraph, newPar, texts);
        return newPar;
    }

    
    public void delTable(XWPFTable table, MapString, Object> paramMap) throws Exception {
        ListXWPFTableRow> rows = table.getRows();
        for (int i = 0, size = rows.size(); i  size; i++) {
            XWPFTableRow row = rows.get(i);
            currentRowIndex = i;
            
            if (delAndJudgeRow(table, paramMap, row)) {
                return;
            }
        }
    }

    
    private boolean delAndJudgeRow(XWPFTable table, MapString, Object> paramMap, XWPFTableRow row) throws Exception {
        
        if (PoiWordUtils.isAddRow(row)) {
            ListXWPFTableRow> xwpfTableRows = addAndGetRows(table, row, paramMap);
            
            for (XWPFTableRow tbRow : xwpfTableRows) {
                delAndJudgeRow(table, paramMap, tbRow);
            }
            return true;
        }

        
        if (PoiWordUtils.isAddRowRepeat(row)) {
            ListXWPFTableRow> xwpfTableRows = addAndGetRepeatRows(table, row, paramMap);
            
            for (XWPFTableRow tbRow : xwpfTableRows) {
                delAndJudgeRow(table, paramMap, tbRow);
            }
            return true;
        }
        
        ListXWPFTableCell> cells = row.getTableCells();
        for (XWPFTableCell cell : cells) {
            
            if (PoiWordUtils.checkText(cell.getText())) {
                ListXWPFParagraph> paragraphs = cell.getParagraphs();
                for (XWPFParagraph paragraph : paragraphs) {
                    ListXWPFRun> runs = paragraph.getRuns();
                    StringBuilder sb = new StringBuilder();
                    for (XWPFRun run : runs) {
                        sb.append(run.toString());
                        run.setText("", 0);
                    }
                    Placeholder(paragraph, runs, sb);
                }
            }
        }
        return false;
    }

    
    private void Placeholder(XWPFParagraph currentPar, ListXWPFRun> runs, StringBuilder sb) throws Exception {
        if (runs.size() > 0) {
            String text = sb.toString();
            ListXWPFRun> newRuns = currentPar.getRuns();
            XWPFRun currRun = runs.get(0);
            if (PoiWordUtils.isPicture(text)) {
                
            } else {
                changeValue(currRun, text, paramMap);
            }
        }
    }



    
    private ListXWPFTableRow> addAndGetRows(XWPFTable table, XWPFTableRow flagRow, MapString, Object> paramMap) throws Exception {
        ListXWPFTableCell> flagRowCells = flagRow.getTableCells();
        XWPFTableCell flagCell = flagRowCells.get(0);

        String text = flagCell.getText();
        ListListString>> dataList = (ListListString>>) PoiWordUtils.getValueByPlaceholder(paramMap, text);

        
        ListXWPFTableRow> newRows = new ArrayList>(dataList.size());
        if (dataList == null || dataList.size()  0) {
            return newRows;
        }

        XWPFTableRow currentRow = flagRow;
        int cellSize = flagRow.getTableCells().size();
        for (int i = 0, size = dataList.size(); i  size; i++) {
            if (i != 0) {
                currentRow = table.createRow();
                
                if (flagRow.getCtRow() != null) {
                    currentRow.getCtRow().setTrPr(flagRow.getCtRow().getTrPr());
                }
            }
            addRow(flagCell, currentRow, cellSize, dataList.get(i));
            newRows.add(currentRow);
        }
        return newRows;
    }

    
    private ListXWPFTableRow> addAndGetRepeatRows(XWPFTable table, XWPFTableRow flagRow, MapString, Object> paramMap) throws Exception {
        ListXWPFTableCell> flagRowCells = flagRow.getTableCells();
        XWPFTableCell flagCell = flagRowCells.get(0);
        String text = flagCell.getText();
        ListListString>> dataList = (ListListString>>) PoiWordUtils.getValueByPlaceholder(paramMap, text);
        String tbRepeatMatrix = PoiWordUtils.getTbRepeatMatrix(text);


        
        ListXWPFTableRow> newRows = new ArrayList>();
        if (dataList == null || dataList.size()  0) {
            return newRows;
        } else {
             newRows = new ArrayList>(dataList.size());
        }

        String[] split = tbRepeatMatrix.split(",");
        int startRow = Integer.parseInt(split[0]);
        int endRow = Integer.parseInt(split[1]);
        int startCell = Integer.parseInt(split[2]);
        int endCell = Integer.parseInt(split[3]);

        XWPFTableRow currentRow;
        for (int i = 0, size = dataList.size(); i  size; i++) {
            int flagRowIndex = i % (endRow - startRow + 1);
            XWPFTableRow repeatFlagRow = table.getRow(flagRowIndex);
            
            if (i == 0) {
                table.removeRow(currentRowIndex);
            }
            currentRow = table.createRow();
            
            if (repeatFlagRow.getCtRow() != null) {
                currentRow.getCtRow().setTrPr(repeatFlagRow.getCtRow().getTrPr());
            }
            addRowRepeat(startCell, endCell, currentRow, repeatFlagRow, dataList.get(i));
            newRows.add(currentRow);
        }
        return newRows;
    }

    
    private void addRow(XWPFTableCell flagCell, XWPFTableRow row, int cellSize, ListString> rowDataList) {
        for (int i = 0; i  cellSize; i++) {
            XWPFTableCell cell = row.getCell(i);
            cell = cell == null ? row.createCell() : row.getCell(i);
            if (i  rowDataList.size()) {
                PoiWordUtils.copyCellAndSetValue(flagCell, cell, rowDataList.get(i));
            } else {
                
                PoiWordUtils.copyCellAndSetValue(flagCell, cell, "");
            }
        }
    }

    
    private void addRowRepeat(int startCell, int endCell, XWPFTableRow currentRow, XWPFTableRow repeatFlagRow, ListString> rowDataList) {
        int cellSize = repeatFlagRow.getTableCells().size();
        for (int i = 0; i  cellSize; i++) {
            XWPFTableCell cell = currentRow.getCell(i);
            cell = cell == null ? currentRow.createCell() : currentRow.getCell(i);
            int flagCellIndex = i % (endCell - startCell + 1);
            XWPFTableCell repeatFlagCell = repeatFlagRow.getCell(flagCellIndex);
            if (i  rowDataList.size()) {
                PoiWordUtils.copyCellAndSetValue(repeatFlagCell, cell, rowDataList.get(i));
            } else {
                
                PoiWordUtils.copyCellAndSetValue(repeatFlagCell, cell, "");
            }
        }
    }

    
    private void copyParagraph(XWPFParagraph sourcePar, XWPFParagraph targetPar, String... texts) {

        targetPar.setAlignment(sourcePar.getAlignment());
        targetPar.setVerticalAlignment(sourcePar.getVerticalAlignment());

        
        targetPar.setAlignment(sourcePar.getAlignment());
        targetPar.setVerticalAlignment(sourcePar.getVerticalAlignment());

        if (texts != null && texts.length > 0) {
            String[] arr = texts;
            XWPFRun xwpfRun = sourcePar.getRuns().size() > 0 ? sourcePar.getRuns().get(0) : null;

            for (int i = 0, len = texts.length; i  len; i++) {
                String text = arr[i];
                XWPFRun run = targetPar.createRun();

                run.setText(text);

                run.setFontFamily(xwpfRun.getFontFamily());
                int fontSize = xwpfRun.getFontSize();
                run.setFontSize((fontSize == -1) ? DEFAULT_FONT_SIZE : fontSize);
                run.setBold(xwpfRun.isBold());
                run.setItalic(xwpfRun.isItalic());
            }
        }
    }

}

package app.modules.common.util;

import org.apache.poi.xwpf.usermodel.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.List;
import java.util.Map;
import java.util.Optional;


public class PoiWordUtils {

    
    public static final String PREFIX_FIRST = "$";

    
    public static final String PREFIX_SECOND = "{";

    
    public static final String PLACEHOLDER_PREFIX = PREFIX_FIRST + PREFIX_SECOND;

    
    public static final String PLACEHOLDER_END = "}";
    
    public static final String underlineRowText = "underline:";
    
    public static final String addRowText = "tbAddRow:";

    public static final String addRowRepeatText = "tbAddRowRepeat:";

    
    public static final String addRowFlag = PLACEHOLDER_PREFIX + addRowText;

    
    public static final String addRowRepeatFlag = PLACEHOLDER_PREFIX + addRowRepeatText;

    
    public static final String tbRepeatMatrixSeparator = ",";

    
    public static final String PLACEHOLDER_SUFFIX = "}";

    
    public static final String PICTURE_PREFIX = PLACEHOLDER_PREFIX + "image:";
    private static final Logger log = LoggerFactory.getLogger(PoiWordUtils.class);

    
    public static boolean isAddRow(XWPFTableRow row) {
        return isDynRow(row, addRowFlag);
    }

    
    public static boolean isAddRowRepeat(XWPFTableRow row) {
        return isDynRow(row, addRowRepeatFlag);
    }

    private static boolean isDynRow(XWPFTableRow row, String dynFlag) {
        if (row == null) {
            return false;
        }
        ListXWPFTableCell> tableCells = row.getTableCells();
        if (tableCells != null) {
            XWPFTableCell cell = tableCells.get(0);
            if (cell != null) {
                String text = cell.getText();
                if (text != null && text.startsWith(dynFlag)) {
                    return true;
                }
            }
        }
        return false;
    }

    
    public static Object getValueByPlaceholder(MapString, Object> paramMap, String key) {
        if (paramMap != null) {
            if (key != null) {
                return paramMap.get(getKeyFromPlaceholder(key));
            }
        }
        return null;
    }

    
    public static String getTbRepeatMatrix(String key) {
        String $1 = key.replaceAll("" + PREFIX_FIRST + "" + PREFIX_SECOND + addRowRepeatText + "(.*)" + "" + PLACEHOLDER_SUFFIX, "$1");
        return $1;
    }

    
    public static String getKeyFromPlaceholder(String placeholder) {
        return Optional.ofNullable(placeholder).map(p -> p.replaceAll("[${}]", "")).get();
    }

    
    public static void copyCellAndSetValue(XWPFTableCell sourceCell, XWPFTableCell targetCell, String text) {
        
        ListXWPFParagraph> sourceCellParagraphs = sourceCell.getParagraphs();
        if (sourceCellParagraphs == null || sourceCellParagraphs.size()  0) {
            return;
        }
        XWPFParagraph sourcePar = sourceCellParagraphs.get(0);
        XWPFParagraph targetPar = targetCell.getParagraphs().get(0);

        
        targetPar.getCTP().setPPr(sourcePar.getCTP().getPPr());



        ListXWPFRun> sourceParRuns = sourcePar.getRuns();
        if (sourceParRuns != null && sourceParRuns.size() > 0) {
            
            ListXWPFRun> runs = targetPar.getRuns();
            Optional.ofNullable(runs).ifPresent(rs -> rs.stream().forEach(r -> r.setText("", 0)));
            if (runs != null && runs.size() > 0) {
                runs.get(0).setText(text, 0);
            } else {
                XWPFRun cellR = targetPar.createRun();
                cellR.setText(text, 0);
                
                targetCell.getCTTc().setTcPr(sourceCell.getCTTc().getTcPr());
            }
            setTypeface(sourcePar, targetPar);
        } else {
            targetCell.setText(text);
        }
    }
    
    private static void setTypeface(XWPFParagraph sourcePar, XWPFParagraph targetPar) {
        XWPFRun sourceRun = sourcePar.getRuns().get(0);
        String fontFamily = sourceRun.getFontFamily();
        
        String color = sourceRun.getColor();

        boolean bold = sourceRun.isBold();
        boolean italic = sourceRun.isItalic();
        int kerning = sourceRun.getKerning();

        UnderlinePatterns underline = sourceRun.getUnderline();

        XWPFRun targetRun = targetPar.getRuns().get(0);
        targetRun.setFontFamily(fontFamily);

        targetRun.setBold(bold);
        targetRun.setColor(color);
        log.info("存在颜色变动 =====》");
        targetRun.setItalic(italic);
        targetRun.setKerning(kerning);
        targetRun.setUnderline(underline);
        
    }
    
    public static boolean checkText(String text){
        boolean check  =  false;
        if(text.indexOf(PLACEHOLDER_PREFIX)!= -1){
            check = true;
        }
        return check;
    }

    
    public static String getPlaceholderReg(String text) {
        return "" + PREFIX_FIRST + "" + PREFIX_SECOND + text + "" + PLACEHOLDER_SUFFIX;
    }

    public static String getDocKey(String mapKey) {
        return PLACEHOLDER_PREFIX + mapKey + PLACEHOLDER_SUFFIX;
    }

    
    public static boolean isPicture(String text) {
        return text.startsWith(PICTURE_PREFIX);
    }

    
    public static void removeCells(XWPFTableRow row) {
        int size = row.getTableCells().size();
        try {
            for (int i = 0; i  size; i++) {
                row.removeCell(i);
            }
        } catch (Exception e) {

        }
    }
}

3. 调用部分

 // 处理导出合同
    @PostMapping("/getContractWord")
    public void getContractWord(@RequestBody Map jsonObject, HttpServletRequest request, HttpServletResponse response) {Map map =new HashMap();
        map.put("customerName","高密海绵厂");
        map.put("salesName","烟台顺达聚氨酯有限责任公司");
        map.put("contractNo","123456");
        log.info("============>{}",map.toString());
        DynWordUtils.process(map,"D:bbb.docx","D:aaa.doc",request,response);

    }

第二种思路

1. 前端准备富文本 html 利用原生 css 处理格式。
2. 前端利用 es6 模板语法将 html 中的关键字段值替换掉
3. 传递后端生成 word 并写入流中

1.html 很多 这里只取片段 包含普通格式以及表格处理

es6 只需要代码块中存在声明占位符部分，模板会自动填充

  let data =  this.value
  const date = new Date(data.createdTime); 
  const year = date.getFullYear(); 
  const month = date.getMonth() + 1; 
  const day = date.getDate(); 
  const formattedDate = `${year}年 ${month} 月${day}日`;
  let html1 =
      `

    

      

        

          工业品买卖合同
        
        

          

            

            

              

                
供方：${data.orgName}
              
              

                
合同编号：${data.formNo}
              
            
            

              

              

                
签订方式：传真、扫描件
              
            
            

              

                
需方：${data.CustomerName}
              
              

                
签订时间：${formattedDate}
              
            
            

              

                
第一条 产品规格、数量、价款
              
            
            

              

                `let data1 =this.value.ws_contractentry
  data1.forEach((item,index)=>{
    html1+=`    `;})fetch(`${config.apiHost}/common/createWord`,{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({html: html1+html2 })}).then(response=> response.blob()).then(blob=>{const url = window.URL.createObjectURL(blob);const a = document.createElement('a');
        a.href = url;
        a.download ='document.docx';  
        document.body.appendChild(a);
        a.click();
        a.remove();}).catch(error=> console.error('Error:', error));
java 部分 html 转成 word 导出
 @PostMapping("/createWord")
    public void generateWord(@RequestBody MapString,String> html, HttpServletRequest request, HttpServletResponse response) throws IOException {
        
        String htmlContent = html.get("html");
        
         htmlContent = ""+htmlContent+"";
        ByteArrayInputStream byteArrayInputStream = null;
        POIFSFileSystem poifsFileSystem = null;
        ServletOutputStream servletOutputStream = null;
        try {
            byte b[] = htmlContent.getBytes("GBK"); 
            byteArrayInputStream = new ByteArrayInputStream(b);
            poifsFileSystem = new POIFSFileSystem();
            DirectoryEntry directory = poifsFileSystem.getRoot();
            directory.createDocument("WordDocument", byteArrayInputStream);
            
            request.setCharacterEncoding("utf-8");
            response.setContentType("application/msword");
            response.addHeader("Content-Disposition", "attachment;filename=aaaa.doc");
            servletOutputStream = response.getOutputStream();
            poifsFileSystem.writeFilesystem(servletOutputStream);
            byteArrayInputStream.close();
            servletOutputStream.close();
            poifsFileSystem.close();
        } catch (Exception e) {
            throw e;
        }
    }

第二种思路的弊端是 poifsFileSystem 不支持二次修改，例如修改页边距 修改字体颜色 调整文件内容，我尝试了一下 poifsFileSystem 转 HWPFDdocument 对象没找到合适的解决方法 所以暂定不能二次修改。
最后效果

                  

                  

                    

                      

                        序号
                      
                    
                    

                      

                        产品名称
                      
                    
                    

                      

                        牌号
                      
                    
                    

                      

                        规格
                      
                    
                    

                      

                        数量（吨）
                    
                    

                      

                        单价（元 / 吨）
                    
                    

                      

                        总金额（元）
                    
                    

                      

                        备注
                      
                    
                  
   

                    

                      
${index+1}
                    
                    

                      

                        ${item.groupName}
                      
                    
                    

                      

                        ${item.mNameIdText}
                      
                    
                    

                      

                        ${item.model}
                      
                    
                    

                      
${item.num}
                    
                    

                      

                        ${item.rPrice}
                      
                    
                    

                      

                        ${item.sum}
                      
                    
                    

                      

                        ${item.remark}