本文通过POI实现了针对具有格式的页眉页脚、正文文本、表格、图片的替换，以及插入新的文本、表格、图片，以及删除它们。
一、基本概念
POI：即Apache POI， 它是一个开源的 Java 库，主要用于读取 Microsoft Office 文档（Word、Excel、PowerPoint 等），修改 或 生成 Office 文档内容，保存 为对应的二进制或 XML 格式（如 .doc、.docx、.xls、.xlsx）。
书签：作用类似于图书阅读中的实体书签（bookmark），字面上就是用来标记（记住）某一页或某一段的位置。在 Word 里，你可以给文档的某个位置（文字、段落或任意元素前后）打上一个“标记”，并为它命名，在自动化处理文档时，就相当于给程序提供了一个清晰、稳定的操作目标。(利用 Apache POI 等库，可以通过书签来定位，针对该区域执行“替换”、“删除”或“插入”操作，而不必遍历整个文档或依赖复杂的坐标。)
基础概念
Docx4j：即Docx 4j，Docx指用于Microsoft Word 2007 及以后版本使用的文件格式（基于 Office Open XML，扩展名为 .docx），4j表示 "for Java"，即专为 Java 设计的库。它是用于Java 的 DOCX 文档处理库，明确其核心功能是操作现代 Word 文档格式（.docx）。
(Docx4j与POI均为Java开发者提供操作Word文档的能力，但POI适合需要同时处理 .doc 和 .docx 的旧项目，具有更活跃的 Apache 社区支持，采用Apache 2.0协议。而Docx4j 适合专注于 .docx 且需要更高级功能的场景（如 PDF 转换），采用AGPLv3协议。两者在实现原理上也不同，Docx4j 将 Word 文档的 XML 结构映射为 Java 对象（通过 JAXB），代码更直观，大文件处理可能更高效（依赖 JAXB 优化）。而POI 直接操作 XML 节点，灵活性高但代码更繁琐，大文件易内存溢出（DOM 模型）)
Aspose.Words：即 Aspose 公司提供的 Word 文档处理解决方案，适合企业级复杂需求，功能强大，支持 Word 文档的完整操作（格式、图表、加密、渲染为 PDF 等），需要商业许可，并且提供更好的技术支持和稳定性。
(Aspose.Words 是商业化、功能全面的 Word 操作库，它提供类似 Word 对象模型（如 Document、Paragraph），API 更直观，适合企业级应用。而POI 是开源基础工具，适合轻量级需求或预算有限的场景。另外Aspose.Words支持 .NET/Java/Cloud API，并且官方商业技术支持)
HWPF：即"Horrible Word Processor Format"，直译为“糟糕的文字处理器格式”。这个名字是 Apache POI 开发者对旧版 Microsoft Word 二进制文件格式（.doc）的一种调侃式命名，原因是.doc 格式是微软私有的二进制格式，结构复杂且未完全公开，解析和操作极其困难，在逆向工程 .doc 格式时遇到了许多挑战，因此用“Horrible”形容其开发过程。
(HWPF 是 Apache POI 项目中专门用于处理 旧版 Word 文件（.doc） 的组件，属于 POI 的早期核心模块之一（与 Excel 的 HSSF 属于同一代）。尽管 HWPF 已过时，但 POI 仍保留它，主要为了向后兼容，支持遗留系统需要读取或修改旧版 .doc 文件)
XWPF ：即"XML Word Processor Format"，表示它处理的是基于 Office Open XML (OOXML) 格式的文档（即 .docx 文件，本质是 ZIP 压缩的 XML 文件集合，可将 .docx 重命名为 .zip 解压，观察文件内容），关键类有XWPFDocument(表示整个 .docx 文档)、XWPFParagraph(操作段落)、XWPFRun(段落中的文本片段（控制字体、样式等）)、XWPFTable(操作表格)、XWPFStyles(管理样式（如标题、正文样式）)等
(XWPF 基于 POI 的 POI-OOXML 子模块实现，后者提供了对 Office Open XML 格式（2007+）的底层解析支持，它与旧版 HWPF（处理 .doc 二进制格式）并列，共同覆盖 Word 文档的全版本。)
OOXML:即Office Open XML，是 Microsoft 从 Office 2007 开始引入的基于 XML 的文档格式标准，用于替代旧的二进制格式（如 .doc、.xls）。Office Open表示表示格式的开放性（由 ECMA 和 ISO 标准化，文档结构可被第三方工具解析）；XML表示文档内容以 XML 文件的形式存储，本质是一个 ZIP 压缩包（可重命名为 .zip 解压查看内部结构）。
典型 OOXML 文档结构（以 .docx 为例）解压后的文件目录如下：
word/
├── document.xml # 正文内容
├── styles.xml # 样式定义
├── header1.xml # 页眉
├── footer1.xml # 页脚
├── theme/ # 主题
└── ...
_rels/ # 文件关系定义
[Content_Types].xml # 内容类型声明
具体内容结构如下：
<pkg:package> 表示整个文档包
...<pkg:part> 表示文档包包含的多个 part（部件件），例如正文、样式、关系等
<pkg:part pkg:name="/word/document.xml"> 表示 Word 文档的主体内容所在的 XML 文件
<pkg:xmlData> 表示XML 的实际数据内容，也就是文档的主体结构数据
<w:document> Word 文档的根节点
<w:body> 文档主体
...多种不同的标签
<w:p> 表示一个段落（paragraph）
...多种不同的标签
<w:pPr> 段落属性（paragraph properties）
...多种不同的标签
<w:lang> 语言设置
<w:rFonts> 字体设置
<w:ind> 段落缩进设置
<w:r> 表示一个文本运行（run）
...多种不同的标签
<w:rPr> 文本运行的属性
...多种不同的标签
<w:rFonts> 字体设置
<w:lang> 语言设置
<w:noProof>
<w:t> 表示具体的文本内容
<w:drawing> 表示绘图对象（如图片、形状）
<wp:inline> 表示内联对象
...多种不同的标签
<a:graphic> 表示图形元素
<a:graphicData> 表示图形数据
...多种不同的标签
<pic:pic> 表示图片元素
<pic:nvPicPr> 表示图片非视觉属性
<pic:blipFill> 表示图片填充
<pic:spPr> 表示图形形状属性
<wp:docPr> 表示文档属性
<wp:extent> 表示对象尺寸
<wp:effectExtent> 表示效果范围
<wp:cNvGraphicFramePr> 表示图形框架属性
<w:proofErr> 标记拼写或语法错误
<w:bookmarkStart> 表示书签的起始（可任意位置但一定成对出现。大多数位于段落内，但是也跨段落出现，还可存在于表格、页眉页脚、文档主体中）
<w:bookmarkEnd> 表示书签的结束（可任意位置，同w:bookmarkStart）
<w:tbl> 表示一个表格
<w:tblPr> 表示表格属性
<w:tblGrid> 表示表格列宽定义
...多个<w:tr>
<w:tr> 表示表格行（table row）
...多个<w:tc>
<w:tc> 表示表格单元格（table cell）
<w:tcPr> 表示单元格属性
<w:tcW> 表示单元格宽度
<w:p>
(POI 基于 OOXML 标准实现，比如XWPF（用于操作 .docx）和 XSSF（用于操作 .xlsx）模块本质上是 OOXML 的高级 Java 封装。POI的操作层级根据是否进行了高级封装而不直接操作XML， 可以分为高级 API（推荐，比如使用 XWPFDocument、XWPFParagraph 等类，无需直接接触 XML）以及低级 API（直接操作 OOXML 的 XML 绑定类（如 CTP、CTR），适用于 POI 未封装的功能）。POI 屏蔽了 OOXML 的复杂性，开发者无需手动编写 XML，但是若需实现 POI 未支持的功能（如复杂图表），需直接操作 OOXML 或结合 OpenXML SDK实现)
POI 高级 API：指 Apache POI 库中提供的高层次应用编程接口，它对底层细节（XMLBeans、DOM、二进制格式解析等）做了封装，提供了面向文档对象模型的 Java 类，让开发者以更直观、面向对象的方式操作 Office 文档。典型的类比如：XWPFDocument、XWPFParagraph、XWPFRun、XWPFTable等
(POI 高级 API 并不是一个独立库，而是 Apache POI 中的一个模块（如 poi‑ooxml、poi‑scratchpad）所暴露给用户的顶层接口。在底层，POI 依赖 XMLBeans（以及 DOM API）来解析和生成 OOXML（二进制格式则由 HWPF/HSSF 模块处理）；而高级 API 则在此之上，封装了对 XMLBeans 生成的 CTR、CTTbl 等对象的操作，使调用更符合 Java 面向对象习惯。)
XMLBeans：就是“针对 XML 的 JavaBeans”，即将 XML 文档或 XML Schema 自动绑定（binding）为一组类型安全的 JavaBean 类，开发者可以像操作普通 Java 对象一样读写 XML。它也是poi-ooxml依赖链中的一个子依赖。典型的类比如：XmlObject、XmlCursor，针对OOXML，生成如 CTR、CTTbl 之类的类，并支持 XmlCursor 精细操作。
（Apache POI 的 OOXML 模块（如 XSSF、XWPF、SLF4J 等）并不自己手写 XML 解析逻辑，而是借助 XMLBeans 根据 Office Open XML 的 XSD（XML Schema）文件，自动生成了一系列与标签一一对应的 Java 类。XMLBeans 是 POI 操作 OOXML 的“引擎”，为 POI 提供了从 XML ↔ Java 对象的双向映射能力，而 POI 的高级 API 则基于这些映射，帮开发者屏蔽了大多数底层细节。）
DOM API：即Document Object Model（文档对象模型），它一组用于以“对象树”形式访问和操作 XML/HTML 文档的java标准接口。典型的类比如：org.w3c.dom.Node、NodeList
(XMLBeans 会直接将OOXML解析成自己的 XmlObject（类型化 Java 类），POI 也基于这些对象工作；只有在你显式请求 DOM 视图时，才会在后台创建 org.w3c.dom.Node，比如当调用 getDomNode() 或使用 XmlObject.newDomNode()、XmlCursor 等方法时，XMLBeans 才会“懒惰地”把内部数据结构转换或映射成一个标准的 org.w3c.dom.Node。)
二、操作步骤
1、引入依赖
<!-- 支持 新版 Office OOXML 格式（如 .docx、.xlsx），是操作 Word 书签的 核心依赖,并且poi-ooxml 的依赖链包含 poi、xmlbeans 等必要库，无需手动重复添加-->
<dependency>
<groupId>org.apache.poi</groupId>
<artifactId>poi-ooxml</artifactId>
<version>5.2.3</version>
</dependency>
<!-- 可选：旧版 Word 的附加支持（如图片、复杂格式） -->
<!-- <dependency>
<groupId>org.apache.poi</groupId>
<artifactId>poi-scratchpad</artifactId>
<version>5.2.3</version>
</dependency>-->
poi-ooxml 及其传递依赖的作用：
poi-ooxml (高级API)
├── poi (基础功能)
├── poi-ooxml-lite（OOXML结构类定义，包含大量通过 XMLBeans 自动生成的 schema 对应 Java 类，比如 CTDocument1、CTBody、CTR、CTTbl 等。）
├── xmlbeans（XML对象建模，POI 使用 XMLBeans 来把 word/document.xml 等 XML 文件映射为 Java 对象，并支持对这些对象的访问与修改。它也支持 XmlCursor、getDomNode() 等低层 XML 操作。）
├── commons-compress（解压zip，OOXML 格式其实就是一个 ZIP 包，里面有多个 XML 文件（如 document.xml, styles.xml），这个库就是用来处理这些压缩内容的。）
├── commons-io（IO工具，在POI 中用于读写流、文件等操作）
├── curveapi（图表曲线，OI 中处理图表（Chart）功能时会用到。）
├── log4j-api（日志框架，用于 POI 中记录日志，比如异常信息、解析错误等）
└── commons-collections4（集合工具库，在POI 中用于复杂文档结构处理时的数据支持。）
(poi-ooxml是操作 Word 书签的 核心依赖，后续所有基于 .docx 的书签操作（替换、删除、插入）都依赖此模块)
2、插入word书签
这里所打的书签格式均与代码中的判断相对应，建议可直接采用本文中的书签格式方便实践.另外建议开启 文件-》更多-》选项-》高级-》显示文档内容-》显示书签 方便快速查看书签位置及是否添加正确
2.1、替换书签的插入
书签固定的格式为replace_text_xxx、replace_table_xxx、replace_image_xxx，它主要用于替换具有一定格式的内容，需要选中一段文本或者图片或者表格后，通过在word的菜单 插入-》书签 弹窗中，输入书签名，点击添加插入replace书签（特别注意，书签一定要打准确，否则可能会导致意料之外的问题。打文本书签的时候，对于文本只可选中文本段的文字，不可包含多余的前后空格或换行；打图片书签的时候，左键选中图片然后添加书签；打表格书签的时候，点击表格点击表格左上角的十字标识选中表格，然后添加书签；打页眉页脚书签的时候，双击页眉或页脚，选择文本内容添加书签。特别需要注意的是，后续页眉或页脚通过 链接到上一节 来实现统一的替换，后续页眉或页脚如果节没有递增，可能是因为在上一页末尾缺少 布局-》分割符-》分节符-》下一页 ，插入后页眉或页脚 节 即会递增。另外用于被链接的页眉页脚所属页在最终的输出内容中必须存在，否则后续页眉页脚链接不到，会替换失败）
2.2、删除书签的插入
书签固定格式为delete_数字，它主要用于删除word内容，需要选择要删除的文本内容，然后在word的菜单 插入-》书签 弹窗中，输入书签名，点击添加插入delete书签
2.3、插入书签的插入
书签固定格式为insert_text_xxx、insert_image_xxx、insert_table_xxx,它主要用于插入word内容，通常对于文本会通过replace进行替换以满足文本的格式，而对于图片和表格则在代码中自定义样式插入。插入书签首先需要光标点击要插入的位置，然后直接在word的菜单 插入-》书签 弹窗中，输入书签名，点击添加插入insert书签
文本和表格书签做类似插入
3、书签的处理
在代码中由注释可见，针对三种书签的处理涉及三个主要的部分：“一、replace书签的处理”部分、“二、insert书签的处理”、“三、delete书签的处理”。此外还有“四、原文本格式的特殊适配”、“五、保存文件”。以上提纲具体代码如下（由于功能比较全面，所以还覆盖了很多容易出现的问题，比如跨段书签处理、连续表格处理等，代码中都做了解决，建议仔细阅读并理解）：
/**
* 处理书签
*
* @param replaceBookmarkAndValue 正文替换书签及值
* @param replaceHeaderAndFooterBookmarkAndValue 页眉页脚替换书签及值
* @param insertBookmarkAndValue 插入书签及值
* @param deleteBookmarks 删除书签
* @param tempFilePath 模板文件路径
*/
public void dealWithBookMark(Map<String, String> replaceBookmarkAndValue, Map<String, String> replaceHeaderAndFooterBookmarkAndValue, Map<String, String> insertBookmarkAndValue, List<String> deleteBookmarks, String tempFilePath) {
File file = new File(tempFilePath);
try (InputStream is = Files.newInputStream(file.toPath())) {
XWPFDocument docx = new XWPFDocument(is);
// 一、replace书签的处理(针对文本、图片、表格)
// 1、正文内容的处理（document.xml）
boolean isBookmarkEnd;
Node bodyNode = docx.getDocument().getBody().getDomNode();
NodeList bodyChildNodes = bodyNode.getChildNodes();
List<String> replaceBookmarks = new ArrayList<>(replaceBookmarkAndValue.keySet());
List<String> realReplaceBookmarks = replaceBookmarks.stream().map(item -> item.substring(0, item.lastIndexOf("_")))
.collect(Collectors.toList());
// 对于word中打了替换书签的图片，如果没有对应替换书签数据，则删除该图片(replace图片是w:drawing中指向的embed内容替换，因此无关的需要先删除)
List<XWPFParagraph> paragraphs = docx.getParagraphs();
// 由于POI的高级API并未提供删除段落的方法，因此统计需要删除的段落节点，最终统一通过节点删除（在逻辑末尾删除，避免XmlValueDisconnectedException）
List<Node> toRemovePNodes = new ArrayList<>();
for (XWPFParagraph paragraph : paragraphs) {
List<XWPFRun> runs = paragraph.getRuns();
for (int i = runs.size() - 1; i >= 0; i--) {
XWPFRun run = runs.get(i);
CTR ctr = run.getCTR();
List<CTDrawing> drawingList = ctr.getDrawingList();
if (CollectionUtils.isEmpty(drawingList)) {
continue;
}
Node domNode = ctr.getDomNode();
Node previousSibling = domNode.getPreviousSibling();
if (!Objects.isNull(previousSibling) && previousSibling.getNodeName()
.equals("w:bookmarkStart") && previousSibling.getAttributes().getNamedItem("w:name").getNodeValue()
.startsWith("replace_image_") && !realReplaceBookmarks.contains(previousSibling.getAttributes()
.getNamedItem("w:name").getNodeValue())) {
paragraph.removeRun(i);
}
}
}
// 对于word中打了替换书签的文本，如果没有对应替换书签数据，则将该书签修改为删除书签，后续处理中删除该文本（经过多种书签场景的测试，开始书签一定位于p内与r平齐，而结束书签可以在p内【可以跨p】也可以在p
// 外【当选择的内容末尾包含分节符时】，因此需要特别处理）
int deleteNum = 1000;
for (XWPFParagraph paragraph : paragraphs) {
CTP ctp = paragraph.getCTP();
List<CTBookmark> bookmarkStartList = ctp.getBookmarkStartList();
if (CollectionUtils.isEmpty(bookmarkStartList)) {
continue;
}
for (CTBookmark bookmarkStart : bookmarkStartList) {
if (!bookmarkStart.getName()
.startsWith("replace_text_") || realReplaceBookmarks.contains(bookmarkStart.getName())) {
continue;
}
// 将该书签修改为删除书签，后续处理中删除
bookmarkStart.setName("delete_" + deleteNum++);
}
}
// 处理其他replace书签数据
for (int index = 0; index < replaceBookmarks.size(); index++) {
String bookmark = replaceBookmarks.get(index);
int lastUnderscoreIndex = bookmark.lastIndexOf("_");
String realBookmark = bookmark.substring(0, lastUnderscoreIndex);
String bookmarkValue = replaceBookmarkAndValue.get(bookmark);
// 只有替换文本和图片考虑书签范围的查找，替换表格无需遍历段落及段落子查找（因为表格节点在body中与段落平级）
if (realBookmark.startsWith("replace_text_") || realBookmark.startsWith("replace_image_")) {
// 书签范围内完整的P标签
List<Node> inBookmarkRangePNodes = new ArrayList<>();
// 书签范围内除了完整的P标签之外，到结束标签为止，额外多余的P标签子节点（如果书签跨p,则从第0个子节点计算，不包含结束书签；如果书签不跨p,则包含起始书签，不包含结束书签）
List<Node> inBookmarkRangeExtraPChildNodes = new ArrayList<>();
// 匹配替换书签除末尾数字以外的前缀部分（末尾数字用于多个内容同一位置的重复插入）
isBookmarkEnd = getBookmarkStartAndEndRangeNodes(bodyChildNodes, realBookmark, inBookmarkRangeExtraPChildNodes, inBookmarkRangePNodes);
if (isBookmarkEnd) {
// replace文本时，对第一个<w:r 节点进行内容替换，对其他p及p子节点进行删除
if (realBookmark.startsWith("replace_text_")) {
if (!CollectionUtils.isEmpty(inBookmarkRangePNodes)) {
Node pNode = inBookmarkRangePNodes.get(0);
NodeList pNodeChildNodes = pNode.getChildNodes();
List<Node> nodes = new ArrayList<>();
for (int i = 0; i < pNodeChildNodes.getLength(); i++) {
Node node = pNodeChildNodes.item(i);
nodes.add(node);
}
deleteExtraPChildNodes(bodyChildNodes, nodes, bookmarkValue, docx);
// 存在多个p时，除了第一个p，其他p全部删除
if (inBookmarkRangePNodes.size() > 1) {
for (int i = 1; i < inBookmarkRangePNodes.size(); i++) {
Node node = inBookmarkRangePNodes.get(i);
toRemovePNodes.add(node);
}
}
// 存在p时，额外的p子内容一定是全删除的
for (int i = 0; i < bodyChildNodes.getLength(); i++) {
Node bodyChildNode = bodyChildNodes.item(i);
for (Node pChildNode : inBookmarkRangeExtraPChildNodes) {
// p删除子节点(无需移除段落样式，其他书签【可能是其他标题链接】)
if (pChildNode.getParentNode() == bodyChildNode && !pChildNode.getNodeName()
.equals("w:pPr") && !pChildNode.getNodeName().equals("w:bookmarkStart")) {
bodyChildNode.removeChild(pChildNode);
}
}
}
} else {
deleteExtraPChildNodes(bodyChildNodes, inBookmarkRangeExtraPChildNodes, bookmarkValue, docx);
}
} else if (realBookmark.startsWith("replace_image_")) {
// replace图片时，将节点中第一个<w:drawing>中的<a:blip标签节点的r:embed属性指向的图片，更换为待替换图片(具体需查看OOXML结构)
// 另外replace_image_书签只针对单个图片打，以进行满足格式样式的图片内容替换，不存在跨段，也就没有inBookmarkRangePNodes
// ，只有inBookmarkRangeExtraPChildNodes
String imageEmbedId = null;
exitLoop:
for (int i = 0; i < bodyChildNodes.getLength(); i++) {
Node bodyChildNode = bodyChildNodes.item(i);
NodeList childNodes = bodyChildNode.getChildNodes();
for (int j = 0; j < childNodes.getLength(); j++) {
Node childNode = childNodes.item(j);
if (!childNode.getNodeName().equals("w:r")) {
continue;
}
NodeList childNodes1 = childNode.getChildNodes();
for (int k = 0; k < childNodes1.getLength(); k++) {
Node childNode1 = childNodes1.item(k);
if (!childNode1.getNodeName().equals("w:drawing")) {
continue;
}
Node wpInline = childNode1.getFirstChild();
NodeList childNodes3 = wpInline.getChildNodes();
for (int l = 0; l < childNodes3.getLength(); l++) {
Node childNode2 = childNodes3.item(l);
if (!childNode2.getNodeName().equals("a:graphic")) {
continue;
}
Node graphicDataNode = childNode2.getFirstChild();
Node picNode = graphicDataNode.getFirstChild();
NodeList picChildNodes = picNode.getChildNodes();
for (int m = 0; m < picChildNodes.getLength(); m++) {
Node childNode3 = picChildNodes.item(m);
if (!childNode3.getNodeName().equals("pic:blipFill")) {
continue;
}
NodeList childNodes5 = childNode3.getChildNodes();
for (int n = 0; n < childNodes5.getLength(); n++) {
Node childNode4 = childNodes5.item(n);
if (childNode4.getNodeName().equals("a:blip")) {
imageEmbedId = childNode4.getAttributes().getNamedItem("r:embed")
.getNodeValue();
break exitLoop;
}
}
}
}
}
}
}
// 根据embedId替换图片的关联引用
POIXMLDocumentPart picPart = docx.getRelationById(imageEmbedId);
XWPFPictureData pictureData = (XWPFPictureData) picPart;
PackagePart pkgPart = pictureData.getPackagePart();
// 将新图片字节写进去
try (OutputStream os = pkgPart.getOutputStream()) {
byte[] newBytes = Files.readAllBytes(Paths.get(bookmarkValue));
os.write(newBytes);
} catch (Exception e) {
log.error("图片替换异常", e);
}
}
}
} else if (realBookmark.startsWith("replace_table_")) {
// replace表格时，需要获取原书签对应表格的<w:tblPr>样式进行设置、由于表格行列属性只有高宽设置，而实际表格需要视具体数据设置宽高，因此行列属性不做设置（如有特殊需要补充特殊处理）
// 另外由于选中表格打书签时，起始书签位于表格第一行的p内，结束书签位于表格最后一行p内，并且每一行都位于<w:tbl>（直接位于body内，与其他body内p平级）,因此可直接遍历表格查找书签
List<XWPFTable> tables = docx.getTables();
for (XWPFTable table : tables) {
CTTbl ctTbl = table.getCTTbl();
CTRow firstRow = table.getRow(0).getCtRow();
CTTc firstCol = firstRow.getTcArray(0);
CTP firstP = firstCol.getPArray(0);
CTR firstR = firstP.getRArray(0);
List<CTBookmark> bookmarkStartList = firstP.getBookmarkStartList();
if (CollectionUtils.isEmpty(bookmarkStartList)) {
continue;
}
boolean anyMatch = bookmarkStartList.stream().map(CTBookmark::getName)
.anyMatch(item -> item.equals(realBookmark));
if (anyMatch) {
// 以该表格的tblPr样式创建新的表格
// 用Jsoup解析HTML表格数据
// 特殊处理，给所有th 后增加一个空格
bookmarkValue = bookmarkValue.replace("thstyle", "th style");
Document htmlDoc = Jsoup.parse(bookmarkValue);
Element htmlTable = htmlDoc.selectFirst("table");
if (Objects.isNull(htmlTable)) {
continue;
}
XmlCursor xmlCursor = ctTbl.newCursor();
xmlCursor.toNextSibling();
// 相同表格替换位置(以去除数字的剩余书签是否相同做判断)的替换，如果之前的替换表格书签已经存在过替换，计算替换过多少次，XmlCursor就要向后移动多少个兄弟节点
// (特别注意，连续表格会被合并，因此每替换一个表格就需要多NextSibling一次以多一个p去划分表格)
List<String> preReplaceBookmarks = replaceBookmarks.subList(0, index);
List<String> replaceTimes = preReplaceBookmarks.stream()
.filter(item -> item.substring(0, item.lastIndexOf("_")).equals(realBookmark))
.collect(Collectors.toList());
int moveTimes = replaceTimes.size();
if (moveTimes > 0) {
for (int j = 0; j < moveTimes * 2; j++) {
xmlCursor.toNextSibling();
}
}
insertHTMLTable(htmlTable, docx, xmlCursor, ctTbl.getTblPr(), firstP.getPPr(), firstR.getRPr());
xmlCursor.close();
break;
}
}
}
}
// 对于word中打了替换书签的表格，如果没有对应替换书签数据，则删除该表格(特别注意，选中表格后打的书签，在表格第一行第一列的段落中;因此需要等表格替换插入后再操作，否则会导致表格替换无法找到对应书签)
// 另外新插入的表格是没有书签的，因此这里可以删除所有原本有书签的表格，包括本来要被替换以及本来不被替换的表格
// 倒序遍历，删除表格（防止删除后影响下标）
List<IBodyElement> bodyElements = docx.getBodyElements();
for (int i = bodyElements.size() - 1; i >= 0; i--) {
IBodyElement bodyElement = bodyElements.get(i);
if (bodyElement.getElementType() == BodyElementType.TABLE) {
XWPFTable table = (XWPFTable) bodyElement;
CTRow firstRow = table.getRow(0).getCtRow();
CTTc firstCol = firstRow.getTcArray(0);
List<CTBookmark> bookmarkStartList = firstCol.getPArray(0).getBookmarkStartList();
if (!CollectionUtils.isEmpty(bookmarkStartList)) {
docx.removeBodyElement(i);
}
}
}
// 2、特殊内容的处理（header.xml\footer.xml）
// 2.1 处理页眉书签
List<XWPFHeader> headerList = docx.getHeaderList();
List<String> replaceHeaderBookmarks = replaceHeaderAndFooterBookmarkAndValue.keySet().stream()
.filter(item -> item.startsWith("replace_header_")).collect(Collectors.toList());
for (String replaceHeaderBookmark : replaceHeaderBookmarks) {
String bookmarkValue = replaceHeaderAndFooterBookmarkAndValue.get(replaceHeaderBookmark);
exitLoop:
for (XWPFHeader header : headerList) {
// 页眉中的书签存在于表格中的tc的p段落中或直接的p段落中
List<XWPFTable> tables = header.getTables();
for (XWPFTable table : tables) {
List<CTRow> trList = table.getCTTbl().getTrList();
for (CTRow ctRow : trList) {
List<CTTc> ctTcs = ctRow.getTcList();
for (CTTc ctTc : ctTcs) {
for (CTP ctp : ctTc.getPList()) {
List<CTBookmark> bookmarkStartList = ctp.getBookmarkStartList();
if (CollectionUtils.isEmpty(bookmarkStartList)) {
continue;
}
for (CTBookmark bookmarkStart : bookmarkStartList) {
if (bookmarkStart.getName().equals(replaceHeaderBookmark)) {
Node domNode = bookmarkStart.getDomNode();
NodeList childNodes = ctp.getDomNode().getChildNodes();
boolean findBookmark = false;
for (int j = 0; j < childNodes.getLength(); j++) {
Node childNode = childNodes.item(j);
if (!findBookmark && childNode.equals(domNode)) {
findBookmark = true;
}
if (findBookmark) {
// 如果childNode是<w:r>标签则设置它的<w:t>的值为书签值
if (childNode.getNodeName().equals("w:r")) {
NodeList rChildNodes = childNode.getChildNodes();
for (int k = 0; k < rChildNodes.getLength(); k++) {
Node rChildNode = rChildNodes.item(k);
if (rChildNode.getNodeName().equals("w:t")) {
rChildNode.getFirstChild().setNodeValue(bookmarkValue);
break exitLoop;
}
}
}
}
}
}
}
}
}
}
}
List<XWPFParagraph> headerParagraphs = header.getParagraphs();
for (XWPFParagraph paragraph : headerParagraphs) {
List<CTBookmark> bookmarkStartList = paragraph.getCTP().getBookmarkStartList();
if (CollectionUtils.isEmpty(bookmarkStartList)) {
continue;
}
for (CTBookmark bookmarkStart : bookmarkStartList) {
if (bookmarkStart.getName().equals(replaceHeaderBookmark)) {
Node domNode = bookmarkStart.getDomNode();
NodeList childNodes = paragraph.getCTP().getDomNode().getChildNodes();
boolean findBookmark = false;
for (int j = 0; j < childNodes.getLength(); j++) {
Node childNode = childNodes.item(j);
if (!findBookmark && childNode.equals(domNode)) {
findBookmark = true;
}
if (findBookmark) {
// 如果childNode是<w:r>标签则设置它的<w:t>的值为书签值
if (childNode.getNodeName().equals("w:r")) {
NodeList rChildNodes = childNode.getChildNodes();
for (int k = 0; k < rChildNodes.getLength(); k++) {
Node rChildNode = rChildNodes.item(k);
if (rChildNode.getNodeName().equals("w:t")) {
rChildNode.getFirstChild().setNodeValue(bookmarkValue);
break exitLoop;
}
}
}
}
}
}
}
}
}
}
// 2.2、处理页脚书签
List<XWPFFooter> footerList = docx.getFooterList();
List<String> replaceFooterBookmarks = replaceHeaderAndFooterBookmarkAndValue.keySet().stream()
.filter(item -> item.startsWith("replace_footer_")).collect(Collectors.toList());
for (String replaceFooterBookmark : replaceFooterBookmarks) {
String bookmarkValue = replaceHeaderAndFooterBookmarkAndValue.get(replaceFooterBookmark);
exitLoop:
for (XWPFFooter footer : footerList) {
// 页脚中的书签存在于表格中的tc的p段落中或直接的p段落中
List<XWPFTable> tables = footer.getTables();
for (XWPFTable table : tables) {
List<CTRow> trList = table.getCTTbl().getTrList();
for (CTRow ctRow : trList) {
List<CTTc> ctTcs = ctRow.getTcList();
for (CTTc ctTc : ctTcs) {
for (CTP ctp : ctTc.getPList()) {
List<CTBookmark> bookmarkStartList = ctp.getBookmarkStartList();
if (CollectionUtils.isEmpty(bookmarkStartList)) {
continue;
}
for (CTBookmark bookmarkStart : bookmarkStartList) {
if (bookmarkStart.getName().equals(replaceFooterBookmark)) {
Node domNode = bookmarkStart.getDomNode();
NodeList childNodes = ctp.getDomNode().getChildNodes();
boolean findBookmark = false;
for (int j = 0; j < childNodes.getLength(); j++) {
Node childNode = childNodes.item(j);
if (!findBookmark && childNode.equals(domNode)) {
findBookmark = true;
}
if (findBookmark) {
// 如果childNode是<w:r>标签则设置它的<w:t>的值为书签值
if (childNode.getNodeName().equals("w:r")) {
NodeList rChildNodes = childNode.getChildNodes();
for (int k = 0; k < rChildNodes.getLength(); k++) {
Node rChildNode = rChildNodes.item(k);
if (rChildNode.getNodeName().equals("w:t")) {
rChildNode.getFirstChild().setNodeValue(bookmarkValue);
break exitLoop;
}
}
}
}
}
}
}
}
}
}
}
List<XWPFParagraph> footerParagraphs = footer.getParagraphs();
for (XWPFParagraph paragraph : footerParagraphs) {
List<CTBookmark> bookmarkStartList = paragraph.getCTP().getBookmarkStartList();
if (CollectionUtils.isEmpty(bookmarkStartList)) {
continue;
}
for (CTBookmark bookmarkStart : bookmarkStartList) {
if (bookmarkStart.getName().equals(replaceFooterBookmark)) {
Node domNode = bookmarkStart.getDomNode();
NodeList childNodes = paragraph.getCTP().getDomNode().getChildNodes();
boolean findBookmark = false;
for (int j = 0; j < childNodes.getLength(); j++) {
Node childNode = childNodes.item(j);
if (!findBookmark && childNode.equals(domNode)) {
findBookmark = true;
}
if (findBookmark) {
// 如果childNode是<w:r>标签则设置它的<w:t>的值为书签值
if (childNode.getNodeName().equals("w:r")) {
NodeList rChildNodes = childNode.getChildNodes();
for (int k = 0; k < rChildNodes.getLength(); k++) {
Node rChildNode = rChildNodes.item(k);
if (rChildNode.getNodeName().equals("w:t")) {
rChildNode.getFirstChild().setNodeValue(bookmarkValue);
break exitLoop;
}
}
}
}
}
}
}
}
}
}
// 二、insert书签的处理（针对文本、图片、表格）
List<String> insertBookMarks = new ArrayList<>(insertBookmarkAndValue.keySet());
for (String bookmark : insertBookMarks) {
for (XWPFParagraph paragraph : paragraphs) {
CTP ctp = paragraph.getCTP();
List<CTBookmark> bookmarkStartList = ctp.getBookmarkStartList();
if (CollectionUtils.isEmpty(bookmarkStartList)) {
continue;
}
List<CTBookmark> insertBookmarks = bookmarkStartList.stream()
.filter(item -> item.getName().startsWith("insert")).collect(Collectors.toList());
if (CollectionUtils.isEmpty(insertBookmarks)) {
continue;
}
for (CTBookmark bookmarkStart : insertBookmarks) {
int lastUnderscoreIndex = bookmark.lastIndexOf("_");
String insertBookmark = bookmark.substring(0, lastUnderscoreIndex);
if (insertBookmark.equals(bookmarkStart.getName())) {
String insertValue = insertBookmarkAndValue.get(bookmark);
if (insertBookmark.startsWith("insert_text")) {
Node previousSibling = bookmarkStart.getDomNode().getPreviousSibling();
List<XWPFRun> runs = paragraph.getRuns();
boolean anyMatch = runs.stream().anyMatch(item -> item.getCTR().getDomNode() == previousSibling);
if (anyMatch) {
int index = 0;
for (int i = 0; i < runs.size(); i++) {
XWPFRun run = runs.get(i);
if (run.getCTR().getDomNode() == previousSibling) {
index = i;
}
}
XWPFRun run = paragraph.insertNewRun(index);
run.setText(insertValue);
}
} else if (insertBookmark.startsWith("insert_image")) {
Node previousSibling = bookmarkStart.getDomNode().getPreviousSibling();
List<XWPFRun> runs = paragraph.getRuns();
boolean anyMatch = runs.stream().anyMatch(item -> item.getCTR().getDomNode() == previousSibling);
if (anyMatch) {
int index = 0;
for (int i = 0; i < runs.size(); i++) {
XWPFRun run = runs.get(i);
if (run.getCTR().getDomNode() == previousSibling) {
index = i;
}
}
XWPFRun run = paragraph.insertNewRun(index);
InputStream picIs = Files.newInputStream(Paths.get(insertValue));
// 3. 向文档中添加图片数据，并且返回一个 relation id（内部处理好关系表和 media/* 文件）
String filename = "图片.png";
int format = XWPFDocument.PICTURE_TYPE_PNG; // 或者 PICTURE_TYPE_JPEG, etc.
run.addPicture(picIs, format, filename, Units.toEMU(350), // 宽度 200pt 转换为 EMU
Units.toEMU(200) // 高度 100pt 转换为 EMU
);
}
} else if (insertBookmark.startsWith("insert_table")) {
XmlCursor xmlCursor = ctp.newCursor();
xmlCursor.toNextSibling();
Document htmlDoc = Jsoup.parse(insertValue);
Element htmlTable = htmlDoc.selectFirst("table");
if (Objects.isNull(htmlTable)) {
continue;
}
insertHTMLTable(htmlTable, docx, xmlCursor, null, null, null);
}
}
}
}
}
// 三、delete书签的处理（适用所有内容）
// 如果没有传入删除书签，则删除所有删除书签的内容
if (CollectionUtils.isEmpty(deleteBookmarks)) {
deleteBookmarks = new ArrayList<>();
NodeList childNodes = bodyNode.getChildNodes();
for (int i = 0; i < childNodes.getLength(); i++) {
Node childNode = childNodes.item(i);
// 开始书签只位于段落内，删除的开始书签也是如此
NodeList childNodes1 = childNode.getChildNodes();
for (int j = 0; j < childNodes1.getLength(); j++) {
Node childNode1 = childNodes1.item(j);
String nodeName1 = childNode1.getNodeName();
if (nodeName1.equals("w:bookmarkStart")) {
String nodeValue = childNode1.getAttributes().getNamedItem("w:name").getNodeValue();
if (nodeValue.startsWith("delete_")) {
deleteBookmarks.add(nodeValue);
}
}
}
}
}
for (String bookmark : deleteBookmarks) {
// 书签范围内完整的P标签
List<Node> inBookmarkRangePNodes = new ArrayList<>();
// 书签范围内除了完整的P标签之外，到结束标签为止，额外多余的P标签子节点（如果书签跨p,则从第0个子节点计算，不包含结束书签；如果书签不跨p,则包含起始书签，不包含结束书签）
List<Node> inBookmarkRangeExtraPChildNodes = new ArrayList<>();
isBookmarkEnd = getBookmarkStartAndEndRangeNodes(bodyChildNodes, bookmark, inBookmarkRangeExtraPChildNodes, inBookmarkRangePNodes);
// 待其他书签操作结束后，再进行删除操作（特别注意，书签最好独立分开打，不要存在需要同时处理的内容）
if (isBookmarkEnd) {
// body删除p节点
for (int i = inBookmarkRangePNodes.size() - 1; i >= 0; i--) {
Node node = inBookmarkRangePNodes.get(i);
toRemovePNodes.add(node);
}
// p删除子节点(无需移除段落样式，其他书签【可能是其他标题链接】)
for (XWPFParagraph paragraph : paragraphs) {
List<XWPFRun> runs = paragraph.getRuns();
for (int i = runs.size() - 1; i >= 0; i--) {
XWPFRun run = runs.get(i);
CTR ctr = run.getCTR();
Node domNode = ctr.getDomNode();
if (inBookmarkRangeExtraPChildNodes.contains(domNode)) {
paragraph.removeRun(i);
}
}
}
}
}
// 四、原文本内容的特殊适配（不同于开始的对正文内容的特殊字符处理，这里需要处理相关word格式）
// 1、如果文本中存在HTML的上下标标签，则将上下标标签内的内容进行特殊处理
for (XWPFParagraph paragraph : paragraphs) {
List<XWPFRun> runs = paragraph.getRuns();
for (int j = 0; j < runs.size(); j++) {
XWPFRun xwpfRun = runs.get(j);
String text = xwpfRun.getText(0);
if (Objects.isNull(text)) {
continue;
}
CTR ctr = xwpfRun.getCTR();
CTRPr rPr = ctr.getRPr();
if (text.contains("<sub>")) {
String[] split = text.split("<sub>");
ctr.removeT(0);
xwpfRun.setText(split[0]);
int index = 1;
for (String string : split) {
if (!StringUtils.hasText(string)) {
continue;
}
if (string.contains("</sub>")) {
String[] list1 = string.split("</sub>");
XWPFRun run = paragraph.insertNewRun(j + index);
run.getCTR().setRPr(rPr);
CTRPr pr = run.getCTR().getRPr();
pr.addNewVertAlign().setVal(STVerticalAlignRun.SUBSCRIPT);
run.setText(list1[0]);
if (list1.length > 1) {
XWPFRun run1 = paragraph.insertNewRun(j + ++index);
run1.getCTR().setRPr(rPr);
run1.setText(list1[1]);
}
index++;
}
}
}
}
}
for (XWPFParagraph paragraph : paragraphs) {
List<XWPFRun> runs = paragraph.getRuns();
for (int j = 0; j < runs.size(); j++) {
XWPFRun xwpfRun = runs.get(j);
String text = xwpfRun.getText(0);
if (Objects.isNull(text)) {
continue;
}
CTR ctr = xwpfRun.getCTR();
CTRPr rPr = ctr.getRPr();
if (text.contains("<sup>")) {
String[] split = text.split("<sup>");
ctr.removeT(0);
xwpfRun.setText(split[0]);
int index = 1;
for (String string : split) {
if (!StringUtils.hasText(string)) {
continue;
}
if (string.contains("</sup>")) {
String[] list1 = string.split("</sup>");
XWPFRun run = paragraph.insertNewRun(j + index);
run.getCTR().setRPr(rPr);
CTRPr pr = run.getCTR().getRPr();
pr.addNewVertAlign().setVal(STVerticalAlignRun.SUPERSCRIPT);
run.setText(list1[0]);
if (list1.length > 1) {
XWPFRun run1 = paragraph.insertNewRun(j + ++index);
run1.getCTR().setRPr(rPr);
run1.setText(list1[1]);
}
index++;
}
}
}
}
}
// 2、如果表格的锻炼中存在HTML的上下标标签，则将上下标标签内的内容进行特殊处理
List<XWPFTable> tables = docx.getTables();
for (XWPFTable table : tables) {
List<XWPFTableRow> rows = table.getRows();
for (XWPFTableRow row : rows) {
List<XWPFTableCell> cells = row.getTableCells();
for (XWPFTableCell cell : cells) {
List<XWPFParagraph> cellParagraphs = cell.getParagraphs();
for (XWPFParagraph cellParagraph : cellParagraphs) {
List<XWPFRun> runs = cellParagraph.getRuns();
for (int j = 0; j < runs.size(); j++) {
XWPFRun xwpfRun = runs.get(j);
String text = xwpfRun.getText(0);
if (Objects.isNull(text)) {
continue;
}
CTR ctr = xwpfRun.getCTR();
CTRPr rPr = ctr.getRPr();
if (text.contains("<sub>")) {
String[] split = text.split("<sub>");
ctr.removeT(0);
xwpfRun.setText(split[0]);
int index = 1;
for (String string : split) {
if (!StringUtils.hasText(string)) {
continue;
}
if (string.contains("</sub>")) {
String[] list1 = string.split("</sub>");
XWPFRun run = cellParagraph.insertNewRun(j + index);
run.getCTR().setRPr(rPr);
CTRPr pr = run.getCTR().getRPr();
pr.addNewVertAlign().setVal(STVerticalAlignRun.SUBSCRIPT);
run.setText(list1[0]);
if (list1.length > 1) {
XWPFRun run1 = cellParagraph.insertNewRun(j + ++index);
run1.getCTR().setRPr(rPr);
run1.setText(list1[1]);
}
index++;
}
}
}
}
}
}
}
}
for (XWPFTable table : tables) {
List<XWPFTableRow> rows = table.getRows();
for (XWPFTableRow row : rows) {
List<XWPFTableCell> cells = row.getTableCells();
for (XWPFTableCell cell : cells) {
List<XWPFParagraph> cellParagraphs = cell.getParagraphs();
for (XWPFParagraph cellParagraph : cellParagraphs) {
List<XWPFRun> runs = cellParagraph.getRuns();
for (int j = 0; j < runs.size(); j++) {
XWPFRun xwpfRun = runs.get(j);
String text = xwpfRun.getText(0);
if (Objects.isNull(text)) {
continue;
}
CTR ctr = xwpfRun.getCTR();
CTRPr rPr = ctr.getRPr();
if (text.contains("<sup>")) {
String[] split = text.split("<sup>");
ctr.removeT(0);
xwpfRun.setText(split[0]);
int index = 1;
for (String string : split) {
if (!StringUtils.hasText(string)) {
continue;
}
if (string.contains("</sup>")) {
String[] list1 = string.split("</sup>");
XWPFRun run = cellParagraph.insertNewRun(j + index);
run.getCTR().setRPr(rPr);
CTRPr pr = run.getCTR().getRPr();
pr.addNewVertAlign().setVal(STVerticalAlignRun.SUPERSCRIPT);
run.setText(list1[0]);
if (list1.length > 1) {
XWPFRun run1 = cellParagraph.insertNewRun(j + ++index);
run1.getCTR().setRPr(rPr);
run1.setText(list1[1]);
}
index++;
}
}
}
}
}
}
}
}
// 3、如果文本中存在换行符，每遇到一个就在对应的位置添加<w:br/>进行换行
// (首先获取匹配到存在换行\n的run的wr的样式，然后添加到后续到的wr中，特别注意：由于处理操作涉及拆分及新增循环项，为了避免逻辑复杂化因此与下标分开处理)
// 因为以下逻辑会插入新的段落，因此不可使用增强for循环，以免破坏迭代器。（由于插入使用的是段落的光标位置，因此也不必担心影响下标而从后往前迭代，正序迭代即可）
for (int i = 0; i < paragraphs.size(); i++) {
XWPFParagraph paragraph = paragraphs.get(i);
List<XWPFRun> runs = paragraph.getRuns();
for (int j = 0; j < runs.size(); j++) {
XWPFRun xwpfRun = runs.get(j);
String text = xwpfRun.getText(0);
if (Objects.isNull(text)) {
continue;
}
CTR ctr = xwpfRun.getCTR();
CTRPr rPr = ctr.getRPr();
if (text.contains("\n")) {
String[] splitText = text.split("\n");
ctr.removeT(0);
xwpfRun.setText(splitText[0]);
CTP ctp = paragraph.getCTP();
XmlCursor xmlCursor = ctp.newCursor();
xmlCursor.toNextSibling();
for (int k = 1; k < splitText.length; k++) {
// 空内容不换行
if (!StringUtils.hasText(splitText[k])) {
continue;
}
// 在当前位置创建新的段落
XWPFParagraph newParagraph = docx.insertNewParagraph(xmlCursor);
CTP newCtp = newParagraph.getCTP();
newCtp.setPPr(ctp.getPPr());
XWPFRun run = newParagraph.createRun();
run.getCTR().setRPr(rPr);
run.setText(splitText[k]);
xmlCursor = newCtp.newCursor();
xmlCursor.toNextSibling();
}
}
}
}
// 五、逻辑末尾删除P节点
for (Node node : toRemovePNodes) {
bodyNode.removeChild(node);
}
// 六、保存文件
try (OutputStream os = Files.newOutputStream(Paths.get(DOWNLOAD_FILE_PATH))) {
docx.write(os);
}
docx.close();
log.info("处理文档成功");
} catch (Exception e) {
log.error("处理文档异常", e);
}
}
/**
* 插入表格
*
* @param htmlTable html表格
* @param docx 当前文件
* @param cursor 插入位置
* @param pPr 表格单元格中的p标签样式
* @param rPr 表格单元格中的r标签样式
*/
private void insertHTMLTable(Element htmlTable, XWPFDocument docx, XmlCursor cursor, CTTblPr tblPr, CTPPr pPr, CTRPr rPr) {
// 1、计算表格尺寸（考虑 colspan）
Elements rows = htmlTable.select("tr");
int numRows = rows.size();
int maxCols = 0;
for (Element rowElem : rows) {
int cols = 0;
for (Element cellElem : rowElem.select("th,td")) {
int cs = cellElem.hasAttr("colspan") ? Integer.parseInt(cellElem.attr("colspan")) : 1;
cols += cs;
}
maxCols = Math.max(maxCols, cols);
}
// 2、在旧表格位置插入新表格
XWPFTable table = docx.insertNewTbl(cursor);
if (!Objects.isNull(tblPr)) {
table.getCTTbl().setTblPr(tblPr);
}
// 3、初始化表格行和列
XWPFTableRow firstRow = table.getRow(0);
for (int c = 1; c < maxCols; c++) {
firstRow.createCell();
}
for (int r = 1; r < numRows; r++) {
table.createRow();
}
// 4、遍历行和列，填数据，处理行列合并
Map<List<Integer>, String> cellAndText = new HashMap<>();
for (int r = 0; r < numRows; r++) {
XWPFTableRow tableRow = table.getRow(r);
int cols = 0;
int mergeEndCols = 0;
boolean isMergeCols = false;
List<Integer> removeCellIndex = new ArrayList<>();
for (int c = 0; c < maxCols; c++) {
XWPFTableCell cell = tableRow.getCell(c);
if (cell != null) {
// 如果已经被行合并填过，则跳过
Set<List<Integer>> keys = cellAndText.keySet();
boolean isContinue = false;
for (List<Integer> key : keys) {
if (key.get(1) == c && key.get(0) >= r) {
CTTcPr tcPr2 = cell.getCTTc().isSetTcPr() ? cell.getCTTc().getTcPr() : cell.getCTTc().addNewTcPr();
tcPr2.addNewVMerge().setVal(STMerge.CONTINUE);
isContinue = true;
break;
}
}
if (isContinue) {
continue;
}
// 如果处于前置的列合并范围，则删除然后跳过
if (isMergeCols && c < mergeEndCols) {
removeCellIndex.add(c);
continue;
}
// 读取的HTML表格数据
Elements selects = rows.get(r).select("th,td");
Element element = selects.get(cols);
cols++;
// 设置填充内容垂直居中
cell.setVerticalAlignment(XWPFTableCell.XWPFVertAlign.CENTER);
XWPFParagraph para = cell.getParagraphs().get(0);
CTP ctp = para.getCTP();
ctp.setPPr(pPr);
XWPFRun run = para.createRun();
CTR ctr = run.getCTR();
ctr.setRPr(rPr);
// 删除除上下角标标签以外的其他html标签（上下角标后续逻辑末尾进行适配于word的处理）
Safelist safelist = new Safelist();
safelist.addTags("sup", "sub");
String html = element.html();
String result = Jsoup.clean(html, safelist);
run.setText(result);
// 处理列合并
CTTcPr tcPr = cell.getCTTc().isSetTcPr() ? cell.getCTTc().getTcPr() : cell.getCTTc().addNewTcPr();
// 设置列宽度(暂不按照原表格的各列比例处理，则其列宽为自适应)
/* CTTblWidth tcW = tcPr.isSetTcW() ? tcPr.getTcW() : tcPr.addNewTcW();
if (r == 0) {
Elements colgroup = htmlTable.select("colgroup");
if (!colgroup.isEmpty()) {
String width = colgroup.select("col").get(c).attr("style");
if (width.contains("%")) {
int widthPercent = Integer.parseInt(width.replace("%", "").replace("width:", "")
.replace(" ", ""));
tcW.setW(BigInteger.valueOf((long) PAGE_WIDTH_TWIPS / 100 * widthPercent));
tcW.setType(STTblWidth.DXA);
}
} else {
tcW.setW(BigInteger.valueOf(PAGE_WIDTH_TWIPS / maxCols));
tcW.setType(STTblWidth.DXA);
}
}*/
if (element.hasAttr("colspan")) {
int colspan = Integer.parseInt(element.attr("colspan"));
mergeEndCols = c + colspan;
tcPr.addNewGridSpan().setVal(BigInteger.valueOf(colspan));
isMergeCols = true;
} else {
mergeEndCols++;
isMergeCols = false;
}
// 处理行合并
if (element.hasAttr("rowspan")) {
int rowspan = Integer.parseInt(element.attr("rowspan"));
tcPr.addNewVMerge().setVal(STMerge.RESTART);
int nextRowNum = r + rowspan - 1;
List<Integer> cellLocation = Arrays.asList(nextRowNum, c);
String nextCellText = element.text();
cellAndText.put(cellLocation, nextCellText);
}
}
}
// 删除被行合并的单元格（列合并是由不同行的同列单元格的<w:vMerge w:val="restart"/> <w:vMerge/>控制）
removeCellIndex = removeCellIndex.stream().sorted().collect(Collectors.toList());
Collections.reverse(removeCellIndex);
removeCellIndex.forEach(tableRow::removeCell);
}
}
/**
* 在书签范围内的额外的p子节点中，除了替换的第一个内容以外，删除书签之间的其他内容
*
* @param bodyChildNodes body的子节点
* @param inBookmarkRangeExtraPChildNodes 书签范围内的额外的p子节点
* @param bookmarkValue 替换书签的值
* @param docx 文档对象
*/
private void deleteExtraPChildNodes(NodeList bodyChildNodes, List<Node> inBookmarkRangeExtraPChildNodes, String bookmarkValue, XWPFDocument docx) {
// 1、收集待删除的节点（特别注意，待删除的节点必须首先通过集合匹配收集，然后再循环删除.如果在匹配过程中直接删除，则会影响循环的集合的元素，导致删除异常）
List<Node> toRemoveNodes = new ArrayList<>();
for (int i = 0; i < bodyChildNodes.getLength(); i++) {
Node bodyChildNode = bodyChildNodes.item(i);
NodeList childNodes = bodyChildNode.getChildNodes();
boolean findTarget = false;
for (int j = 0; j < childNodes.getLength(); j++) {
Node childNode = childNodes.item(j);
for (Node pChildNode : inBookmarkRangeExtraPChildNodes) {
// 比较内存引用地址，不仅仅是值或结构
if (pChildNode == childNode) {
// 第一个找到的wr即替换的内容，只做内容替换，不做删除
if (childNode.getNodeName().equals("w:r")) {
if (findTarget) {
toRemoveNodes.add(childNode);
} else {
NodeList rChildNodes = childNode.getChildNodes();
for (int z = 0; z < rChildNodes.getLength(); z++) {
if (rChildNodes.item(z).getNodeName().equals("w:t")) {
rChildNodes.item(z).getChildNodes().item(0).setNodeValue(bookmarkValue);
}
}
findTarget = true;
}
}
}
}
}
// 只有额外p子节点时，在某个p匹配到后，则无需循环其他p节点了
if (findTarget) {
break;
}
}
// 2、循环删除多余节点
for (XWPFParagraph paragraph : docx.getParagraphs()) {
List<XWPFRun> runs = paragraph.getRuns();
for (int i = runs.size() - 1; i >= 0; i--) {
XWPFRun run = runs.get(i);
CTR ctr = run.getCTR();
Node domNode = ctr.getDomNode();
if (toRemoveNodes.contains(domNode)) {
paragraph.removeRun(i);
}
}
}
}
/**
* 获取书签范围内完整的P标签，和到结束标签为止额外多余的P标签子节点（基于书签存在于与p平级或者与p第一层子平级的标签节点中）
*
* @param bodyChildNodes body节点的子节点
* @param bookmark 目标书签名
* @param inBookmarkRangeExtraPChildNodes 额外p标签子节点（如果书签跨p,则从第0个子节点计算，不包含结束书签；如果书签不跨p,则包含起始书签，不包含结束书签）
* @param inBookmarkRangePNodes 书签范围内完整的P标签
* @return 书签结束标签是否已找到
*/
private boolean getBookmarkStartAndEndRangeNodes(NodeList bodyChildNodes, String bookmark, List<Node> inBookmarkRangeExtraPChildNodes, List<Node> inBookmarkRangePNodes) {
boolean isBookmarkEnd;
boolean startRecord = false;
isBookmarkEnd = false;
Node startPNode = null;
int continueIndex = 0;
String bookmarkStartId = "";
for (int j = 0; j < bodyChildNodes.getLength(); j++) {
Node bodyChildNode = bodyChildNodes.item(j);
if (!startRecord) {
if (bodyChildNode.getNodeName().equals("w:bookmarkStart")) {
String bookmarkName = bodyChildNode.getAttributes().getNamedItem("w:name").getNodeValue();
if (bookmark.equals(bookmarkName)) {
bookmarkStartId = bodyChildNode.getAttributes().getNamedItem("w:id").getNodeValue();
}
String bookmarkStartId1 = bodyChildNode.getAttributes().getNamedItem("w:id").getNodeValue();
if (bookmarkStartId.equals(bookmarkStartId1)) {
startRecord = true;
startPNode = bodyChildNode;
}
} else if (bodyChildNode.getNodeName().equals("w:p")) {
NodeList pChildNodes = bodyChildNode.getChildNodes();
for (int k = 0; k < pChildNodes.getLength(); k++) {
Node pChildNode = pChildNodes.item(k);
if (pChildNode.getNodeName().equals("w:bookmarkStart")) {
String bookmarkName = pChildNode.getAttributes().getNamedItem("w:name").getNodeValue();
if (bookmark.equals(bookmarkName)) {
bookmarkStartId = pChildNode.getAttributes().getNamedItem("w:id").getNodeValue();
}
String bookmarkStartId1 = pChildNode.getAttributes().getNamedItem("w:id").getNodeValue();
if (bookmarkStartId.equals(bookmarkStartId1)) {
startRecord = true;
startPNode = bodyChildNode;
continueIndex = k;
break;
}
}
}
}
}
if (startRecord) {
// 如果与标志开始的p属于同一p,则接着坐标处理，否则新p从头处理
if (bodyChildNode.getNodeName().equals("w:p")) {
NodeList pChildNodes = bodyChildNode.getChildNodes();
int k = 0;
if (bodyChildNode == startPNode) {
k = continueIndex;
}
for (int x = k; x < pChildNodes.getLength(); x++) {
Node pChildNode = pChildNodes.item(x);
if (pChildNode.getNodeName().equals("w:bookmarkEnd")) {
String bookmarkEndId = pChildNode.getAttributes().getNamedItem("w:id").getNodeValue();
if (bookmarkStartId.equals(bookmarkEndId)) {
isBookmarkEnd = true;
break;
}
}
inBookmarkRangeExtraPChildNodes.add(pChildNode);
}
} else if (bodyChildNode.getNodeName().equals("w:bookmarkEnd")) {
String bookmarkEndId = bodyChildNode.getAttributes().getNamedItem("w:id").getNodeValue();
if (bookmarkStartId.equals(bookmarkEndId)) {
isBookmarkEnd = true;
}
}
// 如果当前P段落内不存在结束书签，则清空子节点保存，并且删除节点集合增加当前P段落节点
if (!isBookmarkEnd) {
inBookmarkRangeExtraPChildNodes.clear();
inBookmarkRangePNodes.add(bodyChildNode);
}
}
if (isBookmarkEnd) {
break;
}
}
return isBookmarkEnd;
}
总结
通过POI处理书签进行内容的增删改，实际就是基于OOXML结构，通过POI进行高级或低级操作，以识别书签标签并进行内容的处理
三、额外补充
1、结合AI的落地应用
可以通过低代码开发平台创建工作流任务，通过 AI 模型根据不同的业务提纲（章节大纲、关键点清单）批量生成文案、数据分析结论、图表解读等“内容片段”。每个生成单元都可以看作是一段需要插入到模板中的内容、并且带有自己书签标识。然后维护一个标准化的 Word 模板，里面预先放置好按结构划分的书签，占位符既标记“标题”“正文”“表格”“图片”所处的位置，也约定了样式（字体、段落、缩进）。将上述对书签的处理发布为接口工具，在工作流中以供调用，最终生成word文档。但是需要注意模型生成内容具有不稳定性并且可能存在幻觉，因此可能需要增加人工校验环节以提高准确性，另外生成内容基本是md格式的内容，如果包含表格，需要使用HTML的表格才能保留行列合并，如果工作流平台是dify且生成内容包含图片，在书签的处理代码中需要根据图片url结合dify存储位置获取真实的图片流进行插入。
工作流的核心思路是，提取提纲及描述，然后根据提纲检索根据描述筛选，最终再进行数据结构整合，然后调用书签处理工具生成word
2、常见异常
异常：XmlValueDisconnectedException
原因：
在遍历或修改 XMLBeans 生成的节点（如调用 XmlCursor 或 CTR.getDomNode()）时，如果该节点已被 DOM 结构移除或重定位，就会抛出此异常。
避免策略：
1、一致地使用同一层 API：要操作结构（插入/删除），尽量用 POI 高级接口，而非直接删 DOM；
2、先修改 POI 对象，再写出文档：不要在同一次流程中混用 DOM 与 XMLBeans 再操作上层 POI 对象（特别注意，修改底层的结构并不会同步到上层的结构中，比如修改DOM不会改变已经生成的XMLBeans对象，修改XMLBeans对象,也不会改变已经生成的POI封装对象（但是会影响底层与上层的关联，会出现XmlValueDisconnectedException），除非写了之后重新读取word(同一库的对象是会相互影响的，比如遍历docx中的XWPFTable，然后根据table的CTTbl等XMLBeans进行判断然后由CTBody移除table,会发现table在docx中依然存在【XMLBeans的操作并未影响POI高级对象】，但是table中的ctTbl属性报错了【XmlValueDisconnectedException，这是由于XMLBeans的操作影响到了同一库的对象，以及高级与XMLBeans的关联】)）；
3、必要时重读文档：如果确实要低级操作，修改后通过 new XWPFDocument(InputStream) 重新构建高层对象。
3、POI操作word建议
如果只是查询和改属性，通过DOM比较方便，如果涉及操作结构（比如插入、删除），建议都使用POI高级API操作（如果硬要使用DOM操作插入删除，请将DOM操作放在所有操作的末尾,j就比如对段落的删除的特殊情况，由于POI高级API并未提供对段落p删除的方法，因此可以记录待删除的p节点，然后逻辑末尾统一删除），一方面对于复杂的对象它可以直接生成完整的标签结构（比如表格、图片，如果用XmlCursor需要逐个标签的构造，很费劲而且容易出错），另一方面可以同步高级对象中的word结构不至于在操作过程中出现底层节点的挂载、获取等异常。另外表格可以通过POI高级接口使用XmlCursor直接在docx中插入，但是XmlCursor必须位于body中与p标签平级（因为表格就是直接位于body中的，如代码如果xmlCursor来自于书签，则要获取段落位置用于表格插入）
扫一扫
4697
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
