公司HDFS网盘下载word模板，实现对模板的数据填充和创建临时文件上传

 /**
     * 获取通报单模板，填充模板，并上传网盘返回fileId
     */
    private JSONObject getReport(String reportNo, String projectName, String notificationObject, String notificationReason, HttpServletRequest request) {
        JSONObject returnJson = new JSONObject();

        RestTemplate restTemplate = new RestTemplate();
        HttpHeaders httpHeaders = new HttpHeaders();
        HttpEntity httpEntity = new HttpEntity(httpHeaders);
        InputStream in = null;
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        //填充模板的数据
        JSONObject params = new JSONObject();
        JSONObject tableData = new JSONObject();
        tableData.put("number", reportNo);
        tableData.put("date", DateUtil.format(new Date(), "yyyy-MM-dd").toString());
        tableData.put("title", projectName);
        tableData.put("target", notificationObject);
        tableData.put("reason", notificationReason);
        params.put("tableData", tableData);

        String fileId = null;
        FileOutputStream fos = null;
        BufferedOutputStream bos = null;
        File fi = null;
        try {
            ResponseEntity<byte[]> getTempResponse = restTemplate.exchange(netdiscIP + netdiscDownload + reportTempFileId, HttpMethod.GET, httpEntity, byte[].class);
            ByteArrayInputStream inputStream = new ByteArrayInputStream(getTempResponse.getBody());
            PoiWordUtils.execute(inputStream, out, params);
            byte[] bytes = out.toByteArray();
            HttpHeaders headers = new HttpHeaders();
            //设置名字
            String downloadName = "督查通报建议单.docx";
            //解决chrome/firefox/ie浏览器压缩包名字含有中文时乱码的问题
            String agent = request.getHeader("USER-AGENT");
            if (agent.contains("MSIE") || agent.contains("Trident")) {
                downloadName = java.net.URLEncoder.encode(downloadName, StandardCharsets.UTF_8.toString());
            } else {
                downloadName = new String(downloadName.getBytes(StandardCharsets.UTF_8), StandardCharsets.ISO_8859_1);
            }
            headers.add(HttpHeaders.CONTENT_DISPOSITION, "attachment;fileName="" + downloadName + """);
            headers.add(HttpHeaders.CONNECTION, "close");

            //创建临时文件上传
            String tempFileName = "督查通报建议单_" + System.currentTimeMillis();
            fi = File.createTempFile(tempFileName, ".docx");
            fos = new FileOutputStream(fi);
            bos = new BufferedOutputStream(fos);
            bos.write(bytes);

            //设置请求头
            HttpHeaders requestHeaders = new HttpHeaders();
            MediaType type = MediaType.parseMediaType("multipart/form-data");
            requestHeaders.setContentType(type);
            System.out.println(fi);
            System.out.println(fi.getName());

            //设置请求体，注意是LinkedMultiValueMap
            FileInputStream input = new FileInputStream(fi);
            MultipartFile multipartFile = new MockMultipartFile("file", fi.getName(), "text/plain", IOUtils.toByteArray(input));
            HttpClientResult result = HttpClientUtils.doPostFile(netdiscIP + netdiscUpload, multipartFile);
            JSONObject object = JSONObject.parseObject(result.getContent());
            if (object != null && object.getInteger("code") == 200) {
                fileId = object.getString("data");
            }
            returnJson.put("fileName",tempFileName + ".docx");
            returnJson.put("fileId",fileId );
        } catch (Exception e) {
            throw new RuntimeException(e.getMessage());
        } finally {
            try {
                if (bos != null) {
                    try {
                        bos.close();
                    } catch (IOException e1) {
                        e1.printStackTrace();
                    }
                }
                if (fos != null) {
                    try {
                        fos.close();
                    } catch (IOException e1) {
                        e1.printStackTrace();
                    }
                }
                if (in != null) {
                    in.close();
                }
                fi.delete();
                out.close();
            } catch (IOException e) {
                throw new RuntimeException(e.getMessage());
            }
        }
        return returnJson;
    }

PoiWordUtils：

@Slf4j
public class PoiWordUtils {

    /**
     * 顿号
     */
    private static final String DUNHAO = "、";

    /**
     * 执行
     *
     * @param in     模板输入流
     * @param out    文件输出流
     * @param params params
     * @Author LIZHIQIANG
     * @Date Create in 2020/1/14 9:58
     */
    public static void execute(InputStream in, OutputStream out, JSONObject params) {
        try {
            XWPFDocument document = new XWPFDocument(in);
            //需要循环的段落${listRow}开头,暂定最多三个
            List<XWPFParagraph> targetParagraphs1 = new ArrayList<>();
            List<XWPFParagraph> targetParagraphs2 = new ArrayList<>();
            List<XWPFParagraph> targetParagraphs3 = new ArrayList<>();
            List<IBodyElement> bodyElements = document.getBodyElements();
            for (IBodyElement element : bodyElements) {
                //文本段落对象
                if (element instanceof XWPFParagraph) {
                    XWPFParagraph paragraph = (XWPFParagraph) element;
                    //段落内容
                    String paragraphText = paragraph.getParagraphText();

                    //空段落跳过
                    if (paragraphText.isEmpty()) {
                        continue;
                    }
                    //需要循环的段落
                    if (paragraphText.startsWith("${listRow1}")) {
                        targetParagraphs1.add(paragraph);
                        continue;
                    }
                    if (paragraphText.startsWith("${listRow2}")) {
                        targetParagraphs2.add(paragraph);
                        continue;
                    }
                    if (paragraphText.startsWith("${listRow3}")) {
                        targetParagraphs3.add(paragraph);
                        continue;
                    }
                    //处理普通段落
                    processParagraph(paragraph, params);
                } else if (element instanceof XWPFTable) {
                    XWPFTable table = (XWPFTable) element;
                    List<XWPFTableRow> rows = table.getRows();
                    String tableDataString = params.getString("tableData");
                    JSONObject tableData = JSON.parseObject(tableDataString);
                    System.out.println(JSON.toJSONString(tableData,true));
                    if (tableData == null) {
                        continue;
                    }
                    //需要循环的tableRows
                    List<XWPFTableRow> targetTableRows = new ArrayList<>();
                    List<Integer> targetTableRowsPos = new ArrayList<>();
                    for (int i = 0; i < rows.size(); i++) {
                        XWPFTableRow row = rows.get(i);
                        List<XWPFTableCell> cells = row.getTableCells();
                        String firstParagraphText2 = cells.get(0).getParagraphs().get(0).getParagraphText();
                        String firstParagraphText = cells.get(0).getParagraphs().get(0).getText();
                        if (firstParagraphText.startsWith("${listTables")) {
                            targetTableRows.add(row);
                            targetTableRowsPos.add(i);
                            continue;
                        }
                        for (XWPFTableCell cell : cells) {
                            List<XWPFParagraph> paragraphs = cell.getParagraphs();
                            for (XWPFParagraph paragraph : paragraphs) {
                                processParagraph(paragraph, tableData);
                            }
                        }
                    }
                    processTableRows(table, targetTableRows, targetTableRowsPos, tableData);
                }

            }
            //处理循环段落
            processParagraphs(document, targetParagraphs1, params, "1");
            processParagraphs(document, targetParagraphs2, params, "2");
            processParagraphs(document, targetParagraphs3, params, "3");
            document.write(out);

        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 处理普通段落
     *
     * @param paragraph paragraph
     * @param params    params
     * @Author LIZHIQIANG
     * @Date Create in 2020/1/14 9:38
     */
    private static void processParagraph(XWPFParagraph paragraph, JSONObject params) {

        List<XWPFRun> runs = paragraph.getRuns();
        //需要循环替换的单元
        List<XWPFRun> targetRuns1 = new ArrayList<>();
        List<XWPFRun> targetRuns2 = new ArrayList<>();
        List<XWPFRun> targetRuns3 = new ArrayList<>();
        for (XWPFRun run : runs) {
            String runKey = run.text();
            System.out.println(runKey);
            if (!runKey.startsWith("${") || !runKey.endsWith("}")) {
                continue;
            }
            if ("${#}".equals(runKey)) {
                run.setText("", 0);
                continue;
            }
            if ("${listTables1}".equals(runKey)) {
                run.setText("", 0);
                continue;
            }
            if (runKey.startsWith("${listRow")) {
                run.setText("", 0);
                continue;
            }
            //添加需要循环的单元
            if (runKey.startsWith("${listRuns1")) {
                targetRuns1.add(run);
                continue;
            }
            if (runKey.startsWith("${listRuns2")) {
                targetRuns2.add(run);
                continue;
            }
            if (runKey.startsWith("${listRuns3")) {
                targetRuns3.add(run);
                continue;
            }
            String key = runKey.replace("${", "").replace("}", "");
            String value = params.getString(key);
            if (!StringUtils.isEmpty(value)) {
                run.setText(value, 0);
            } else {
                run.setText("", 0);
                log.warn("处理普通段落单元失败：{},找不到替换数据", runKey);
            }
        }
        //处理需要循环的单元
        processRuns(paragraph, targetRuns1, params, "1");
        processRuns(paragraph, targetRuns2, params, "2");
        processRuns(paragraph, targetRuns3, params, "3");
    }

    /**
     * 处理需要循环的单元
     *
     * @param paragraph  paragraph
     * @param targetRuns targetRuns
     * @param params     params
     * @return void
     * @Author LIZHIQIANG
     * @Date Create in 2020/3/1 18:06
     */
    private static void processRuns(XWPFParagraph paragraph, List<XWPFRun> targetRuns, JSONObject params, String sorting) {

        if (targetRuns.isEmpty() || params.isEmpty()) {
            return;
        }
        //默认key
        String defaultKey = "listRuns" + sorting;
        JSONArray jsonArray = params.getJSONArray(defaultKey);
        //循环需要替换的数据
        for (int i = 0; i < jsonArray.size(); i++) {
            Object data = jsonArray.get(i);
            //参数 一次循环的参数
            JSONObject param = JSON.parseObject(data.toString());
            //循环需要替换的单元
            for (XWPFRun run : targetRuns) {

                String runKey = run.text();
                XWPFRun newRun = paragraph.createRun();
                CTRPr rPr = run.getCTR().getRPr();
                newRun.getCTR().setRPr(rPr);
                //处理顿号
                if (runKey.equals("${" + defaultKey + "DUNHAO}")) {
                    if (i == jsonArray.size() - 1) {
                        newRun.setText("", 0);
                        continue;
                    }
                    newRun.setText(DUNHAO);
                    continue;
                }
                String key = runKey.replace("${", "").replace("}", "");
                String value = param.getString(key);
                if (!StringUtils.isEmpty(value)) {
                    newRun.setText(value);
                } else {
                    log.warn("处理循环单元失败：{},找不到对应值", runKey);
                    newRun.setText("", 0);
                }

            }
        }
        for (XWPFRun run : targetRuns) {
            run.setText("", 0);
        }

    }

    /**
     * 处理循环段落（新增段落后删模板段落）
     *
     * @param document         document
     * @param targetParagraphs targetParagraphs
     * @param params           params
     * @Author LIZHIQIANG
     * @Date Create in 2020/1/14 9:38
     */
    private static void processParagraphs(XWPFDocument document, List<XWPFParagraph> targetParagraphs, JSONObject params, String sorting) {

        if (targetParagraphs.isEmpty() || params.isEmpty()) {
            return;
        }
        String listKey = "listRow" + sorting;
        JSONArray jsonArray = params.getJSONArray(listKey);
        if (jsonArray == null) {
            return;
        }

        //document.insertNewParagraph(cursor) 插到这个光标前面 所以反转
        Collections.reverse(targetParagraphs);
        Collections.reverse(jsonArray);
        //需要追加的此段落后 最后一个
        XWPFParagraph lastParagraph = document.getParagraphArray(document.getPosOfParagraph(targetParagraphs.get(0)));
        //循环需要替换的数据
//        for (int i = 0; i < jsonArray.size(); i++) {
//            Object data = jsonArray.get(i);
//            //参数 一次循环的参数
//            JSONObject param = JSON.parseObject(data.toString());
//            System.out.println(JSON.toJSONString(param,true));
//            for (XWPFParagraph paragraph : targetParagraphs) {
//                System.out.println("处理段落："+paragraph.getText());
//                //根据光标插入段落
//                //需要追加的此段落光标后 最后一个
//                XmlCursor cursor = lastParagraph.getCTP().newCursor();
//                XWPFParagraph newPar = document.insertNewParagraph(cursor);
//
//                lastParagraph = newPar;
//                //重置光标 最后插入的光标是这个
//                //获取段落对象的样式的ppr标签
//                CTPPr pPr = paragraph.getCTP().getPPr();
//                newPar.getCTP().setPPr(pPr);
//                List<XWPFRun> runs = paragraph.getRuns();
//
//                //需要循环替换的单元
//                List<XWPFRun> targetRuns1 = new ArrayList<>();
//                List<XWPFRun> targetRuns2 = new ArrayList<>();
//                List<XWPFRun> targetRuns3 = new ArrayList<>();
//                for (XWPFRun run : runs) {
//                    String runKey = run.text();
//                    CTRPr rPr = run.getCTR().getRPr();
//                    XWPFRun newRun = newPar.createRun();
//                    newRun.getCTR().setRPr(rPr);
//                    if (!runKey.startsWith("${") || !runKey.endsWith("}")) {
//                        newRun.setText(runKey);
//                        continue;
//                    }
//                    //添加需要循环的单元
//                    if (runKey.startsWith("${listRuns1")) {
//                        targetRuns1.add(run);
//                        continue;
//                    }
//                    if (runKey.startsWith("${listRuns2")) {
//                        targetRuns2.add(run);
//                        continue;
//                    }
//                    if (runKey.startsWith("${listRuns3")) {
//                        targetRuns3.add(run);
//                        continue;
//                    }
//                    if (("${" + listKey + "}").equals(runKey)) {
//                        newRun.setText("");
//                        continue;
//                    }
//                    if ("${#}".equals(runKey)) {
//                        run.setText("", 0);
//                        continue;
//                    }
//                    String key = runKey.replace("${", "").replace("}", "");
//                    String value = param.getString(key);
//                    if (!StringUtils.isEmpty(value)) {
//                        newRun.setText(value);
////                        System.out.println("处理单元："+runKey+" > "+value);
//                        continue;
//                    } else {
//                        log.warn("处理循环模板段落单元失败：{},找不到对应值", runKey);
//                    }
//                    newRun.setText(runKey);
//                }
//                //===处理需要循环的单元
//                processRuns(newPar, targetRuns1, param, "1");
//                processRuns(newPar, targetRuns2, param, "2");
//                processRuns(newPar, targetRuns3, param, "3");
//
//            }
//        }
        //删除模板集合段落
        XmlCursor lastCursor = lastParagraph.getCTP().newCursor();
        for (Object data : jsonArray) {
            JSONObject param = JSON.parseObject(data.toString());
            for (XWPFParagraph paragraph : targetParagraphs) {
                //根据光标插入段落
                XWPFParagraph newPar = document.insertNewParagraph(lastCursor);
                //重置光标 最后插入的光标是这个
                lastCursor = newPar.getCTP().newCursor();
                //复制段落
                copyParagraph(paragraph, newPar);
                //处理普通段落
                processParagraph(newPar, param);
            }
        }
        for (XWPFParagraph paragraph : targetParagraphs) {
            document.removeBodyElement(document.getPosOfParagraph(paragraph));
        }
    }

    /**
     * 处理循环的表格行
     *
     * @param table              table
     * @param targetTableRows    targetTableRows
     * @param targetTableRowsPos targetTableRowsPos
     * @param params             params
     * @return void
     * @Author LIZHIQIANG
     * @Date Create in 2020/3/5 20:56
     */
    private static void processTableRows(XWPFTable table, List<XWPFTableRow> targetTableRows, List<Integer> targetTableRowsPos, JSONObject params) {
        if (targetTableRows.isEmpty() || params.isEmpty()) {
            return;
        }
        //默认key
        String defaultKey = "listTables1";
        JSONArray jsonArray = params.getJSONArray(defaultKey);
        if (jsonArray == null) {
            return;
        }

        for (int i = 0; i < targetTableRows.size(); i++) {
            XWPFTableRow row = targetTableRows.get(i);
            //循环需要替换的数据
            for (Object data : jsonArray) {
                //参数 一次循环的参数
                JSONObject param = JSON.parseObject(data.toString());
                XWPFTableRow newRow = table.createRow();
                copyTableRow(row, newRow);
                List<XWPFTableCell> newRowCells = newRow.getTableCells();
                for (XWPFTableCell newRowCell : newRowCells) {
                    List<XWPFParagraph> paragraphs = newRowCell.getParagraphs();
                    for (XWPFParagraph paragraph : paragraphs) {
                        processParagraph(paragraph, param);
                    }
                }
            }
            table.removeRow(targetTableRowsPos.get(i));
        }
    }


    /**
     * 复制单元
     *
     * @param target target
     * @param source source
     */
    private static void copyRun(XWPFRun source, XWPFRun target) {
        // 设置run属性
        target.getCTR().setRPr(source.getCTR().getRPr());
        // 设置文本
        target.setText(source.text());
    }

    /**
     * 复制段落
     *
     * @param source 源段落
     * @param target 目标段落
     */
    private static void copyParagraph(XWPFParagraph source, XWPFParagraph target) {
        // 设置run属性
        target.getCTP().setPPr(source.getCTP().getPPr());
        //清除新段落的单元
        List<XWPFRun> targetRuns = target.getRuns();
        if (targetRuns != null && targetRuns.size() > 0) {
            for (int pos = 0; pos < targetRuns.size(); pos++) {
                target.removeRun(pos);
            }
        }
        //复制源段落的单元到目标段落
        for (XWPFRun sourceRun : source.getRuns()) {
            XWPFRun targetRun = target.createRun();
            copyRun(sourceRun, targetRun);
        }
    }

    /**
     * 复制表格列
     *
     * @param source 源
     * @param target 目标
     */
    private static void copyTableCell(XWPFTableCell source, XWPFTableCell target) {
        // 设置TableCell属性
        target.getCTTc().setTcPr(source.getCTTc().getTcPr());

        List<XWPFParagraph> targetParagraphs = target.getParagraphs();
        if (targetParagraphs != null && targetParagraphs.size() > 0) {
            for (int pos = 0; pos < targetParagraphs.size(); pos++) {
                target.removeParagraph(pos);
            }
        }
        List<XWPFParagraph> sourceParagraphs = source.getParagraphs();
        for (XWPFParagraph sourceParagraph : sourceParagraphs) {
            XWPFParagraph targetParagraph = target.addParagraph();
            copyParagraph(sourceParagraph, targetParagraph);
        }
    }

    /**
     * 复制表格行
     *
     * @param source 源
     * @param target 目标
     */
    private static void copyTableRow(XWPFTableRow source, XWPFTableRow target) {
        // 设置TableRow属性
        target.getCtRow().setTrPr(source.getCtRow().getTrPr());

        List<XWPFTableCell> sourceCells = source.getTableCells();
        List<XWPFTableCell> targetCells = target.getTableCells();
        //复制列及其属性和内容
        for (int pos = 0; pos < sourceCells.size(); pos++) {
            XWPFTableCell sourceCell = sourceCells.get(pos);
            XWPFTableCell targetCell = targetCells.get(pos);
            copyTableCell(sourceCell, targetCell);
        }
    }

}