这里Word模板填充功能。

有两种方式实现模板填充功能，一种是借助于Aspose工具包中的Aspose.Word工具实现，另一种是借助于Deepoove工具的poi-tl提供的模板引擎实现。

一、Deepoove方式实现

API参考：http://deepoove.com/poi-tl/

借助Deepoove工具包，可以实现自动化、便捷的模板填充操作，替换规则固定，不能根据需要自定义填充规则，有时使用起来会不太方便。

1. Deepoove引入

  1. <dependency>
  2.     <groupId>com.deepoove</groupId>
  3.     <artifactId>poi-tl</artifactId>
  4.     <version>1.6.0-beta1</version>
  5. </dependency>
  7. <!-- 可能用到的Apache poi 依赖 -->
  8. <dependency>
  9.     <groupId>org.apache.poi</groupId>
  10.     <artifactId>poi</artifactId>
  11.     <version>3.16</version>
  12. </dependency>
  13. <dependency>
  14.     <groupId>org.apache.poi</groupId>
  15.     <artifactId>poi-ooxml-schemas</artifactId>
  16.     <version>3.16</version>
  17. </dependency>
  18. <dependency>
  19.     <groupId>org.apache.poi</groupId>
  20.     <artifactId>poi-ooxml</artifactId>
  21.     <version>3.16</version>
  22. </dependency>

2. 填充工具代码

  1. import com.deepoove.poi.XWPFTemplate;
  2. import com.deepoove.poi.config.Configure;
  4. import java.io.*;
  5. import java.util.Map;
  7. /**
  8.  * Word模板填充工具
  9.  *
  10.  * @author maomaochong
  11.  * @date 2021/11/26 14:21
  12.  **/
  13. public class WordRenderUtil {
  14.     /**
  15.      * 填充模板，并导出到输出流
  16.      *
  17.      * 填充规则：
  18.      *      word中模板：{{templateField}}
  19.      *      dataMap中：key为templateField（不带括号），value为任意待填充数据
  20.      *
  21.      * @param templatePath  模板路径
  22.      * @param dataMap   待填充数据集
  23.      * @param outStream 导出输出流
  24.      * @throws IOException
  25.      */
  26.     public static void renderTemplateAndExportToStream(String templatePath, Map dataMap, OutputStream outStream) throws IOException {
  27.         XWPFTemplate xwpfTemplate = null;
  28.         InputStream inputStream = null;
  30.         try {
  31.             // 配置
  32.             Configure config = Configure.newBuilder().build();
  33.             // 读取模板到输入流
  34.             inputStream = new FileInputStream(templatePath);
  36.             // 编译模板，填充数据
  37.             xwpfTemplate = XWPFTemplate
  38.                     .compile(inputStream, config)
  39.                     .render(dataMap);
  40.             // 写入到输出流
  41.             xwpfTemplate.write(outStream);
  43.         } catch (IOException e) {
  44.             throw new RuntimeException("模板填充失败");
  45.         }finally {
  46.             if(xwpfTemplate != null){
  47.                 xwpfTemplate.close();
  48.             }
  49.             // 关流
  50.             if (inputStream != null) {
  51.                 inputStream.close();
  52.             }
  53.         }
  54.     }
  56.     /**
  57.      * 填充模板，并导出到指定文件
  58.      *
  59.      * 填充规则：
  60.      *      word中模板：{{templateField}}
  61.      *      dataMap中：key为templateField（不带括号），value为任意待填充数据
  62.      *
  63.      * @param templatePath  模板路径
  64.      * @param dataMap   待填充数据集
  65.      * @param destDirPath   导出目录
  66.      * @param destFileName  导出文件名
  67.      * @throws IOException
  68.      */
  69.     public static void renderTemplateAndExportToPath(String templatePath, Map dataMap, String destDirPath, String destFileName) throws IOException {
  70.         XWPFTemplate xwpfTemplate = null;
  71.         InputStream inputStream = null;
  73.         try{
  74.             // 配置
  75.             Configure config = Configure.newBuilder().build();
  76.             // 读取模板到输入流
  77.             inputStream = new FileInputStream(templatePath);
  78.             // 编译模板，填充数据
  79.             xwpfTemplate = XWPFTemplate
  80.                     .compile(inputStream, config)
  81.                     .render(dataMap);
  83.             // 目标目录是否存在
  84.             File file = new File(destDirPath);
  85.             if (!file.exists()) {
  86.                 file.mkdirs();
  87.             }
  89.             // 写入到文件
  90.             xwpfTemplate.writeToFile(destDirPath + File.separator + destFileName);
  91.         }catch (IOException e){
  92.             throw new RuntimeException("生成文件失败！");
  93.         }finally {
  94.             if(xwpfTemplate != null){
  95.                 xwpfTemplate.close();
  96.             }
  97.             // 关流
  98.             if (inputStream != null) {
  99.                 inputStream.close();
  100.             }
  101.         }
  103.     }
  104. }

3. 测试用例

模板：
template2.docx

  1. import java.io.*;
  2. import java.util.HashMap;
  4. /**
  5.  * @author maomaochong
  6.  * @date 2021/11/26 14:59
  7.  **/
  8. public class Test02 {
  9.     public static void main(String[] args) {
  10.         try {
  11. //            test01();
  12.             test02();
  13.         } catch (Exception e) {
  14.             e.printStackTrace();
  15.         }
  16.     }
  18.     private static void test01() throws Exception {
  19.         HashMap<String, String> map = new HashMap<>();
  21.         map.put("Code", "2021800001");
  22.         map.put("Creator", "小明公司");
  23.         map.put("Year", "2021");
  24.         map.put("Month", "11");
  25.         map.put("Day", "23");
  26.         map.put("ApplyNum", "2021800001");
  27.         map.put("PatentApplyNum", "2021800001");
  28.         map.put("PatentName", "小明小明");
  30.         map.put("Sltz", "\u2611");
  31.         map.put("Bltz", "\u2610");
  33.         WordRenderUtil.renderTemplateAndExportToPath(System.getProperty("user.dir") + File.separator + "template2.docx", map, System.getProperty("user.dir") + File.separator + "wordTemplate\\out", "dest.docx");
  34.     }
  37.     private static void test02() throws Exception {
  38.         HashMap<String, String> map = new HashMap<>();
  40.         map.put("Code", "2021800001");
  41.         map.put("Creator", "小明公司");
  42.         map.put("Year", "2021");
  43.         map.put("Month", "11");
  44.         map.put("Day", "23");
  45.         map.put("ApplyNum", "2021800001");
  46.         map.put("PatentApplyNum", "2021800001");
  47.         map.put("PatentName", "小明小明");
  49.         map.put("Sltz", "\u2611");
  50.         map.put("Bltz", "\u2610");
  52.         ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
  54.         WordRenderUtil.renderTemplateAndExportToStream(System.getProperty("user.dir") + File.separator + "template2.docx", map, byteArrayOutputStream);
  56.     }
  57. }

4. 填充过程中可能会用到的一些特殊符号编码

参考：https://blog.csdn.net/cy_baicai/article/details/82897724

二、Aspose.Word方式实现

参考文档：https://apireference.aspose.com/words/java/com.aspose.words/package-summary

使用Aspose.Word工具来填充Word模板，同时可以使用其携带的工具实现从Word向Pdf的格式转换，比较方便，还可以根据需要自定义模板样式。

1. Aspose.Word引入

由于Aspose.Word是收费库，所以为了学习，从网上找到了绿色方法，仅供学习使用，我们要支持正版。

  1. 获取对应jar包

由于语雀不支持压缩包格式上传，将后缀改为了docx，下载后将后缀改回rar即可。
asposewordforjava15.docx

  1. 在jar包所在目录，使用如下命令将其安装到本地仓库

    1. mvn install:install-file -Dfile=aspose-words-15.8.0-jdk16.jar -DgroupId=com.aspose -DartifactId=aspose-words -Dversion=15.8.0 -Dpackaging=jar

  2. 在pom文件里引入此依赖

    1. <dependency>
    2.   <groupId>com.aspose</groupId>
    3.   <artifactId>aspose-words</artifactId>
    4.   <version>15.8.0</version>
    5. </dependency>
    7. <!-- 可能会用到的Apache poi依赖 -->
    8. <dependency>
    9.   <groupId>org.apache.poi</groupId>
    10.   <artifactId>poi</artifactId>
    11.   <version>3.16</version>
    12. </dependency>
    13. <dependency>
    14.   <groupId>org.apache.poi</groupId>
    15.   <artifactId>poi-ooxml-schemas</artifactId>
    16.   <version>3.16</version>
    17. </dependency>
    18. <dependency>
    19.   <groupId>org.apache.poi</groupId>
    20.   <artifactId>poi-ooxml</artifactId>
    21.   <version>3.16</version>
    22. </dependency>

2. 授权文件

附件：license.xml

3. 工具类代码

  1. import com.aspose.words.*;
  2. //import org.apache.commons.lang.StringUtils;
  3. //import org.slf4j.Logger;
  4. //import org.slf4j.LoggerFactory;
  5. import sun.misc.BASE64Decoder;
  7. import java.io.File;
  8. import java.io.FileOutputStream;
  9. import java.io.InputStream;
  10. import java.util.Base64;
  11. import java.util.HashMap;
  12. import java.util.Map;
  13. import java.util.Random;
  14. import java.util.regex.Matcher;
  15. import java.util.regex.Pattern;
  17. /**
  18.  * Aspose工具类
  19.  */
  20. public class AsposeWordsUtils {
  22. //    private static final Logger log = LoggerFactory.getLogger(AsposeWordsUtils.class);
  24.     /**
  25.      * 判断是否有授权文件 如果没有则会认为是试用版，转换的文件会有水印
  26.      *
  27.      * @return
  28.      */
  29.     public static boolean getLicense() throws Exception {
  30.         boolean result = false;
  31.         // 指定授权文件路径
  32.         InputStream is = AsposeWordsUtils.class.getClassLoader().getResourceAsStream("license.xml");
  33.         License aposeLic = new License();
  34.         aposeLic.setLicense(is);
  35.         result = true;
  36.         return result;
  37.     }
  39.     /**
  40.      * doc2pdf工具
  41.      *
  42.      * @param sourcerFile 源文件
  43.      * @param targetFile  目标文件
  44.      */
  45.     public static void doc2pdf(String sourcerFile, String targetFile) throws Exception {
  46.         if (!getLicense()) { // 验证License 若不验证则转化出的pdf文档会有水印产生
  47.             return;
  48.         }
  49.         long old = System.currentTimeMillis();
  50.         File file = new File(targetFile);  // 新建一个空白pdf文档
  51.         FileOutputStream os = new FileOutputStream(file);
  52.         Document doc = new Document(sourcerFile); // sourcerFile是将要被转化的word文档
  53.         doc.save(os, SaveFormat.PDF); // 全面支持DOC, DOCX, OOXML, RTF HTML, OpenDocument, PDF, EPUB, XPS, SWF 相互转换
  54.         os.close();
  55.         long now = System.currentTimeMillis();
  56. //        log.info("共耗时：" + ((now - old) / 1000.0) + "秒");  //转化用时
  57.     }
  59.     /**
  60.      * 获取Word模板文档填充工具
  61.      *
  62.      *
  63.      *  填充规则：
  64.      *      模板（自定义）：{{templateField}}
  65.      *      数据集：key为templateField（不带括号），value为需要填充的任意数据
  66.      *
  67.      * @param inFilePath  文档路径
  68.      * @param outFilePath 输出文档路径
  69.      * @param data        待替换的域的键值
  70.      * @param signCode    签章图片base64编码
  71.      * @return 处理结果
  72.      * @throws Exception
  73.      */
  74.     public static Map<String, String> readwriteWord(String inFilePath, String outFilePath, Map<Object, Object> data, String signCode) throws Exception {
  75.         // 验证License 若不验证则转化出的word文档会有水印产生
  76.         if (!getLicense()) {
  77.             return null;
  78.         }
  80.         Map<String, String> map = new HashMap<>();
  81.         Document doc = null;
  82.         // 定义文档接口
  83.         doc = new Document(inFilePath);
  84.         for (Map.Entry<Object, Object> entry : data.entrySet()) {
  85.             String key = entry.getKey().toString();
  86.             Object value = entry.getValue();
  87.             if (value != null) {
  88.                 Pattern p = Pattern.compile("\n");
  89.                 Matcher m = p.matcher(value.toString());
  90.                 int i = 0;
  91.                 String replaceValue = "";
  92.                 Boolean flag = false;
  93.                 while (m.find()) {
  94.                     // 换行处理
  95.                     replaceValue = value.toString().replace(m.group(), "" + ControlChar.LINE_BREAK + "");
  96.                     flag = true;
  97.                 }
  98.                 if (flag) {
  99.                     // 要求替换的内容是完全匹配时的替换
  100.                     // 可更换模板样式
  101.                     doc.getRange().replace("{{" + key + "}}", replaceValue, true, false);
  102.                 } else {
  103.                     // 要求替换的内容是完全匹配时的替换
  104.                     doc.getRange().replace("{{" + key + "}}", value.toString(), true, false);
  105.                 }
  106.             }
  107.         }
  109.         if(signCode != null && !signCode.isEmpty()){
  110.             DocumentBuilder builder = new DocumentBuilder(doc);
  111.             builder.moveToMergeField("signature");
  112.             BASE64Decoder decoder = new BASE64Decoder();
  113.             byte[] imgByteArr = decoder.decodeBuffer(signCode);
  114.             for (int i = 0; i < imgByteArr.length; ++i) {
  115.                 if (imgByteArr[i] < 0) {// 调整异常数据
  116.                     imgByteArr[i] += 256;
  117.                 }
  118.             }
  119.             builder.insertImage(imgByteArr, RelativeHorizontalPosition.RIGHT_MARGIN, -160, RelativeVerticalPosition.OUTSIDE_MARGIN, -140, 160, 160, WrapType.NONE);
  120.         }
  122.         // 生成四位随机数
  123.         Random ne = new Random();
  124.         int num = ne.nextInt(9999 - 1000 + 1) + 1000;
  125.         String random = String.valueOf(num);
  126.         String fileName = "" + System.currentTimeMillis() + random;
  127.         //替换后的Word
  128.         String docPath = outFilePath + fileName + inFilePath.substring(inFilePath.lastIndexOf("."));
  129.         //生成的PDF位置
  130.         String pdfPath = outFilePath + fileName + ".pdf";
  131.         doc.save(docPath);
  132.         File file = new File(docPath);
  133.         if (file.exists()) {
  134.             // 直接转换为word
  135.             doc2pdf(docPath, pdfPath);
  136.             map.put("pdfPath", pdfPath);
  137.             map.put("docPath", docPath);
  138.         }
  139.         return map;
  140.     }
  141. }

4. 测试用例

模板：template2.docx

  1. import java.io.*;
  2. import java.util.HashMap;
  3. import java.util.Map;
  5. /**
  6.  * @author maomaochong
  7.  * @date 2021/11/26 14:59
  8.  **/
  9. public class Test02 {
  10.     public static void main(String[] args) {
  11.         try {
  12.             test03();
  13.         } catch (Exception e) {
  14.             e.printStackTrace();
  15.         }
  16.     }
  19.     private static void test03() throws Exception {
  20.         Map map = new HashMap<>();
  22.         map.put("Code", "2021800001");
  23.         map.put("Creator", "小明公司");
  24.         map.put("Year", "2021");
  25.         map.put("Month", "11");
  26.         map.put("Day", "23");
  27.         map.put("ApplyNum", "2021800001");
  28.         map.put("PatentApplyNum", "2021800001");
  29.         map.put("PatentName", "小明小明");
  31.         map.put("Sltz", "\u2611");
  32.         map.put("Bltz", "\u2610");
  34.         AsposeWordsUtils.readwriteWord(System.getProperty("user.dir") + File.separator + "template2.docx", System.getProperty("user.dir") + File.separator + "wordTemplate\\out\\dest2.docx", map, null);
  35.     }
  36. }

三、Aspose.Word动态生成Word中表格数据

直接展示多类型数据行动态生成，即两个不同类型的数据集合，在表格中动态生成的场景，单行的相对就简单一些，可以参考此种实现方式，更易处理。
image.png

1. 工具类代码

调用其中的dynamicDealTableData()方法。

  1. //import com.alibaba.fastjson.JSONObject;
  2. import com.aspose.words.*;
  3. //import org.apache.commons.lang.StringUtils;
  4. //import org.slf4j.Logger;
  5. //import org.slf4j.LoggerFactory;
  6. import com.joezj.test.DataOne;
  7. import com.joezj.test.DataTwo;
  8. import org.apache.commons.collections4.CollectionUtils;
  9. import org.apache.commons.lang.StringUtils;
  10. import sun.misc.BASE64Decoder;
  12. import java.io.File;
  13. import java.io.FileOutputStream;
  14. import java.io.InputStream;
  15. import java.time.format.DateTimeFormatter;
  16. import java.util.*;
  17. import java.util.List;
  18. import java.util.regex.Matcher;
  19. import java.util.regex.Pattern;
  21. /**
  22.  * Aspose工具类
  23.  */
  24. public class AsposeWordsUtils {
  26. //    private static final Logger log = LoggerFactory.getLogger(AsposeWordsUtils.class);
  28.     /**
  29.      * 判断是否有授权文件 如果没有则会认为是试用版，转换的文件会有水印
  30.      *
  31.      * @return
  32.      */
  33.     public static boolean getLicense() throws Exception {
  34.         boolean result = false;
  35.         // 指定授权文件路径
  36.         InputStream is = AsposeWordsUtils.class.getClassLoader().getResourceAsStream("license.xml");
  37.         License aposeLic = new License();
  38.         aposeLic.setLicense(is);
  39.         result = true;
  40.         return result;
  41.     }
  43.     /**
  44.      * doc2pdf工具
  45.      *
  46.      * @param sourcerFile 源文件
  47.      * @param targetFile  目标文件
  48.      */
  49.     public static void doc2pdf(String sourcerFile, String targetFile) throws Exception {
  50.         if (!getLicense()) { // 验证License 若不验证则转化出的pdf文档会有水印产生
  51.             return;
  52.         }
  53.         long old = System.currentTimeMillis();
  54.         File file = new File(targetFile);  // 新建一个空白pdf文档
  55.         FileOutputStream os = new FileOutputStream(file);
  56.         Document doc = new Document(sourcerFile); // sourcerFile是将要被转化的word文档
  57.         doc.save(os, SaveFormat.PDF); // 全面支持DOC, DOCX, OOXML, RTF HTML, OpenDocument, PDF, EPUB, XPS, SWF 相互转换
  58.         os.close();
  59.         long now = System.currentTimeMillis();
  60. //        log.info("共耗时：" + ((now - old) / 1000.0) + "秒");  //转化用时
  61.     }
  63.     /**
  64.      * 获取Word模板文档填充工具
  65.      *
  66.      *  填充规则：
  67.      *      模板（自定义）：{{templateField}}
  68.      *      数据集：key为templateField（不带括号），value为需要填充的任意数据
  69.      *
  70.      * @param inFilePath  文档路径
  71.      * @param outFilePath 输出文档路径
  72.      * @param data        待替换的域的键值
  73.      * @param signCode    签章图片base64编码
  74.      * @return 处理结果
  75.      * @throws Exception
  76.      */
  77.     public static Map<String, String> readwriteWord(String inFilePath, String outFilePath, Map<Object, Object> data, String signCode) throws Exception {
  78.         // 验证License 若不验证则转化出的word文档会有水印产生
  79.         if (!getLicense()) {
  80.             return null;
  81.         }
  83.         Map<String, String> map = new HashMap<>();
  84.         Document doc = null;
  85.         // 定义文档接口
  86.         doc = new Document(inFilePath);
  87.         for (Map.Entry<Object, Object> entry : data.entrySet()) {
  88.             String key = entry.getKey().toString();
  89.             Object value = entry.getValue();
  90.             if (value != null) {
  91.                 Pattern p = Pattern.compile("\n");
  92.                 Matcher m = p.matcher(value.toString());
  93.                 int i = 0;
  94.                 String replaceValue = "";
  95.                 Boolean flag = false;
  96.                 while (m.find()) {
  97.                     // 换行处理
  98.                     replaceValue = value.toString().replace(m.group(), "" + ControlChar.LINE_BREAK + "");
  99.                     flag = true;
  100.                 }
  101.                 if (flag) {
  102.                     // 要求替换的内容是完全匹配时的替换
  103.                     // 可更换模板样式
  104.                     doc.getRange().replace("{{" + key + "}}", replaceValue, true, false);
  105.                 } else {
  106.                     // 要求替换的内容是完全匹配时的替换
  107.                     doc.getRange().replace("{{" + key + "}}", value.toString(), true, false);
  108.                 }
  109.             }
  110.         }
  112.         if(signCode != null && !signCode.isEmpty()){
  113.             DocumentBuilder builder = new DocumentBuilder(doc);
  114.             builder.moveToMergeField("signature");
  115.             BASE64Decoder decoder = new BASE64Decoder();
  116.             byte[] imgByteArr = decoder.decodeBuffer(signCode);
  117.             for (int i = 0; i < imgByteArr.length; ++i) {
  118.                 if (imgByteArr[i] < 0) {// 调整异常数据
  119.                     imgByteArr[i] += 256;
  120.                 }
  121.             }
  122.             builder.insertImage(imgByteArr, RelativeHorizontalPosition.RIGHT_MARGIN, -160, RelativeVerticalPosition.OUTSIDE_MARGIN, -140, 160, 160, WrapType.NONE);
  123.         }
  125.         // 生成四位随机数
  126.         Random ne = new Random();
  127.         int num = ne.nextInt(9999 - 1000 + 1) + 1000;
  128.         String random = String.valueOf(num);
  129.         String fileName = "" + System.currentTimeMillis() + random;
  130.         //替换后的Word
  131.         String docPath = outFilePath + fileName + inFilePath.substring(inFilePath.lastIndexOf("."));
  132.         //生成的PDF位置
  133.         String pdfPath = outFilePath + fileName + ".pdf";
  134.         doc.save(docPath);
  135.         File file = new File(docPath);
  136.         if (file.exists()) {
  137.             // 直接转换为word
  138.             doc2pdf(docPath, pdfPath);
  139.             map.put("pdfPath", pdfPath);
  140.             map.put("docPath", docPath);
  141.         }
  142.         return map;
  143.     }
  145.     /**
  146.      * Word中动态生成表格数据
  147.      * @param inFilePath    源文件
  148.      * @param outFilePath   目标文件
  149.      * @param listOne   数据集1
  150.      * @param listTwo   数据集2
  151.      * @throws Exception
  152.      */
  153.     public static void dynamicDealTableData(String inFilePath, String outFilePath, List<DataOne> listOne, List<DataTwo> listTwo) throws Exception {
  154.         // 验证License
  155.         if (!getLicense()) {
  156.             return;
  157.         }
  159.         DateTimeFormatter df = DateTimeFormatter.ofPattern("yyyy年MM月dd日");
  161.         // 读取源文件
  162.         Document doc = new Document(inFilePath);
  163.         // 获取word中的第一个表格，index指定表格位置
  164.         Table table = (Table) doc.getChild(NodeType.TABLE, 0, true);
  166.         /**
  167.          * 下边的处理方式可能比较繁琐，总之逻辑就是：
  168.          *          如果数据集1有数据的话，就要根据 数据集1 的 模板行号 加上 其数据量来计算出
  169.          *                                      数据集2 的 模板行号 再处理
  170.          */
  171.         // 数据集1 模板数据首行
  172.         int DataOneLineNum = 7;
  174.         // 处理 数据集1
  175.         if (CollectionUtils.isEmpty(listOne)) {     // 数据集1 无数据
  176.             // 获取模板行
  177.             Range dataOneRange = table.getRows().get(DataOneLineNum).getRange();
  179.             dataOneRange.replace("Index", String.valueOf(1), true, true);
  180.             dataOneRange.replace("ApplyNoItem", "", true, true);
  181.             dataOneRange.replace("ApplyNameItem", "", true, true);
  182.             dataOneRange.replace("ApplyDateItem", "", true, true);
  184.             // 数据集2 模板数据首行(无 数据集1数据)
  185.             int listTwoLineNum_NonListOne = DataOneLineNum + 2;
  187.             // 无 数据集2数据
  188.             if (CollectionUtils.isEmpty(listTwo)) {
  189.                 // 获取模板行
  190.                 Range listTwoRange = table.getRows().get(listTwoLineNum_NonListOne).getRange();
  192.                 listTwoRange.replace("IndexMotel", String.valueOf(1), true, true);
  193.                 listTwoRange.replace("ApplyNo", "", true, true);
  194.                 listTwoRange.replace("ApplyDate", "", true, true);
  195.                 listTwoRange.replace("ApplyName", "", true, true);
  196.                 listTwoRange.replace("UploaderType", "", true, true);
  197.                 listTwoRange.replace("Remarks", "", true, true);
  198.             } else {
  199.                 int temp = listTwoLineNum_NonListOne;
  201.                 for (int index = 0; index < listTwo.size(); index++) {
  202.                     // 复制模板行
  203.                     Node node = table.getRows().get(listTwoLineNum_NonListOne).deepClone(true);
  205.                     // 插入到第八行后
  206.                     table.getRows().insert(temp + 1, node);
  207.                     Range applyValidAmountRange = table.getRows().get(temp + 1).getRange();
  208.                     // 加行
  209.                     temp++;
  211.                     // 序号
  212.                     applyValidAmountRange.replace("IndexMotel", String.valueOf(index + 1), true, true);
  214.                     // 申请号
  215.                     if (StringUtils.isNotBlank(listTwo.get(index).getApplyNo())) {
  216.                         applyValidAmountRange.replace("ApplyNo", listTwo.get(index).getApplyNo(), true, true);
  217.                     }else{
  218.                         applyValidAmountRange.replace("ApplyNo", "", true, true);
  219.                     }
  221.                     // 申请日期
  222.                     if (Objects.nonNull(listTwo.get(index).getApplyDate())) {
  223.                         applyValidAmountRange.replace("ApplyDate", df.format(listTwo.get(index).getApplyDate()), true, true);
  224.                     }else{
  225.                         applyValidAmountRange.replace("ApplyDate", "", true, true);
  226.                     }
  228.                     // 名称
  229.                     if (StringUtils.isNotBlank(listTwo.get(index).getApplyName())) {
  230.                         applyValidAmountRange.replace("ApplyName", listTwo.get(index).getApplyName(), true, true);
  231.                     }else{
  232.                         applyValidAmountRange.replace("ApplyName", "", true, true);
  233.                     }
  235.                     // 类型
  236.                     if (StringUtils.isNotBlank(listTwo.get(index).getType())) {
  237.                         applyValidAmountRange.replace("UploaderType", listTwo.get(index).getType(), true, true);
  238.                     }else{
  239.                         applyValidAmountRange.replace("UploaderType", "", true, true);
  240.                     }
  242.                     // 备注
  243.                     if (StringUtils.isNotBlank(listTwo.get(index).getApplyRemark())) {
  244.                         applyValidAmountRange.replace("Remarks", listTwo.get(index).getApplyRemark(), true, true);
  245.                     }else{
  246.                         applyValidAmountRange.replace("Remarks", "", true, true);
  247.                     }
  248.                 }
  250.                 // 删除模板行数据
  251.                 table.getRows().get(listTwoLineNum_NonListOne).remove();
  252.             }
  254.         } else {
  255.             // 处理 数据集1
  256.             int temp = DataOneLineNum;
  258.             for (int index = 0; index < listOne.size(); index++) {
  259.                 // 复制第八行
  260.                 Node node = table.getRows().get(DataOneLineNum).deepClone(true);
  262.                 // 插入到第八行后
  263.                 table.getRows().insert(temp + 1, node);
  264.                 Range range = table.getRows().get(temp + 1).getRange();
  265.                 // 加行
  266.                 temp++;
  268.                 // 序号
  269.                 range.replace("Index", String.valueOf(index + 1), true, true);
  271.                 // 申请号
  272.                 if (StringUtils.isNotBlank(listOne.get(index).getApplyNo())) {
  273.                     range.replace("ApplyNoItem", listOne.get(index).getApplyNo(), true, true);
  274.                 }else{
  275.                     range.replace("ApplyNoItem", "", true, true);
  276.                 }
  277.                 // 名称
  278.                 if (StringUtils.isNotBlank(listOne.get(index).getApplyName())) {
  279.                     range.replace("ApplyNameItem", listOne.get(index).getApplyName(), true, true);
  280.                 }else {
  281.                     range.replace("ApplyNameItem", "", true, true);
  282.                 }
  283.                 // 申请日期
  284.                 if (StringUtils.isNotBlank(df.format(listOne.get(index).getApplyDate()))) {
  285.                     range.replace("ApplyDateItem", df.format(listOne.get(index).getApplyDate()), true, true);
  286.                 } else {
  287.                     range.replace("ApplyDateItem", "", true, true);
  288.                 }
  290.             }
  292.             // 数据集2 数据首行(存在 数据集1)
  293.             int dataTwoLineNum = DataOneLineNum + listTwo.size() + 2;
  295.             // 处理 截至上一年度在审未决和有效授权专利拥有量
  296.             if (CollectionUtils.isEmpty(listTwo)) {
  297.                 // 获取模板行
  298.                 Range dataTwoRange = table.getRows().get(dataTwoLineNum).getRange();
  300.                 dataTwoRange.replace("IndexMotel", String.valueOf(1), true, true);
  301.                 dataTwoRange.replace("ApplyNo", "", true, true);
  302.                 dataTwoRange.replace("ApplyDate", "", true, true);
  303.                 dataTwoRange.replace("ApplyName", "", true, true);
  304.                 dataTwoRange.replace("UploaderType", "", true, true);
  305.                 dataTwoRange.replace("Remarks", "", true, true);
  306.             } else {
  307.                 int temp2 = dataTwoLineNum;
  309.                 for (int index = 0; index < listTwo.size(); index++) {
  310.                     // 复制模板行
  311.                     Node node = table.getRows().get(dataTwoLineNum).deepClone(true);
  313.                     // 插入到第八行后
  314.                     table.getRows().insert(temp2 + 1, node);
  315.                     Range applyValidAmountRange = table.getRows().get(temp2 + 1).getRange();
  316.                     // 加行
  317.                     temp2++;
  319.                     // 序号
  320.                     applyValidAmountRange.replace("IndexMotel", String.valueOf(index + 1), true, true);
  322.                     // 申请号
  323.                     if (StringUtils.isNotBlank(listTwo.get(index).getApplyNo())) {
  324.                         applyValidAmountRange.replace("ApplyNo", listTwo.get(index).getApplyNo(), true, true);
  325.                     }else{
  326.                         applyValidAmountRange.replace("ApplyNo", "", true, true);
  327.                     }
  329.                     // 申请日期
  330.                     if (Objects.nonNull(listTwo.get(index).getApplyDate())) {
  331.                         applyValidAmountRange.replace("ApplyDate", df.format(listTwo.get(index).getApplyDate()), true, true);
  332.                     }else{
  333.                         applyValidAmountRange.replace("ApplyDate", "", true, true);
  334.                     }
  336.                     // 名称
  337.                     if (StringUtils.isNotBlank(listTwo.get(index).getApplyName())) {
  338.                         applyValidAmountRange.replace("ApplyName", listTwo.get(index).getApplyName(), true, true);
  339.                     }else{
  340.                         applyValidAmountRange.replace("ApplyName", "", true, true);
  341.                     }
  343.                     // 类型
  344.                     if (StringUtils.isNotBlank(listTwo.get(index).getType())) {
  345.                         applyValidAmountRange.replace("UploaderType", listTwo.get(index).getType(), true, true);
  346.                     }else{
  347.                         applyValidAmountRange.replace("UploaderType", "", true, true);
  348.                     }
  350.                     // 备注
  351.                     if (StringUtils.isNotBlank(listTwo.get(index).getApplyRemark())) {
  352.                         applyValidAmountRange.replace("Remarks", listTwo.get(index).getApplyRemark(), true, true);
  353.                     }else{
  354.                         applyValidAmountRange.replace("Remarks", "", true, true);
  355.                     }
  356.                 }
  358.                 // 删除模板行数据
  359.                 table.getRows().get(DataOneLineNum + listTwo.size() + 2).remove();
  360.             }
  362.             // 删除 数据集1 模板行
  363.             table.getRows().get(DataOneLineNum).remove();
  364.         }
  366.         // 保存到本地
  367.         doc.save(outFilePath);
  369.     }
  370. }

2. 测试用例

模板：template1.docx

  1. import java.io.File;
  2. import java.time.LocalDateTime;
  3. import java.util.ArrayList;
  4. import java.util.List;
  6. /**
  7.  * @author maomaochong
  8.  * @date 2021/11/29 10:49
  9.  **/
  10. public class Test03 {
  11.     public static void main(String[] args) throws Exception {
  12.         test01();
  13.     }
  15.     private static void test01() throws Exception {
  16.         List<DataOne> listOne = new ArrayList<>();
  17.         List<DataTwo> listTwo = new ArrayList<>();
  19.         listOne.add(new DataOne("123", "1123", LocalDateTime.now(), "ceshi", "123123"));
  20.         listOne.add(new DataOne("333", "2231", LocalDateTime.now(), "ceshi2", "123113"));
  22.         listTwo.add(new DataTwo("1122", "2233", "123133", LocalDateTime.now(), "测试1", "类型1", "备注"));
  23.         listTwo.add(new DataTwo("3322", "1221", "123133", LocalDateTime.now(), "测试2", "类型2", "备注2"));
  25.         AsposeWordsUtils.dynamicDealTableData(System.getProperty("user.dir") + File.separator + "template1.docx", System.getProperty("user.dir") + File.separator + "wordTemplate\\out\\dest3.docx", listOne, listTwo);
  26.     }
  27. }

生成效果：
image.png