[poi-tl]转换html内容到word

最新推荐文章于 2024-08-02 19:01:56 发布
最新推荐文章于 2024-08-02 19:01:56 发布
阅读量2.9k 收藏 6
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xuwangcheng14/article/details/106025037
版权

利用jsoup将html解析，递归解析，将不同的html标签内容转换成poi支持的内容。代码仅供参考。

完整代码示例请参见：
https://gitee.com/xuwangcheng/poi-tl-html-to-word

package yi.master.demo;

import cn.hutool.core.io.FileUtil;
import cn.hutool.core.util.ReUtil;
import com.deepoove.poi.NiceXWPFDocument;
import com.deepoove.poi.XWPFTemplate;
import com.deepoove.poi.config.Configure;
import com.deepoove.poi.data.MiniTableRenderData;
import com.deepoove.poi.data.PictureRenderData;
import com.deepoove.poi.data.TextRenderData;
import com.deepoove.poi.policy.AbstractRenderPolicy;
import com.deepoove.poi.policy.PictureRenderPolicy;
import com.deepoove.poi.policy.TextRenderPolicy;
import com.deepoove.poi.render.RenderContext;
import com.deepoove.poi.template.run.RunTemplate;
import com.deepoove.poi.util.TableTools;
import org.apache.commons.lang3.StringUtils;
import org.apache.poi.xwpf.usermodel.*;
import org.jsoup.Jsoup;
import org.jsoup.nodes.Element;
import org.jsoup.nodes.Node;
import org.jsoup.select.Elements;
import org.openxmlformats.schemas.wordprocessingml.x2006.main.STMerge;

import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.util.*;


public class Demo {
    public static void main(String[] args) throws IOException {
        String html = FileUtil.readString("demo.html", "utf-8");

        //配置
        Configure config = Configure.newBuilder().build();
        config.customPolicy("resultHtml", createHtmlRenderPolicy());


        //创建word模板对象
        Map<String, Object> map = new HashMap<String, Object>();
        map.put("resultHtml", html);
        XWPFTemplate template = XWPFTemplate.compile(getResourceInputStream("/out_template.docx"), config).render(map);
        template.writeToFile("D:\\demo.docx");
        template.close();

    }


    /**
     * 获取资源文件的文件流
     *
     * @return
     */
    public static InputStream getResourceInputStream(String filePath) {
        InputStream in = FileUtil.class.getResourceAsStream(filePath);
        if (in != null) {
            return in;
        }
        return null;
    }

    /**
     * 创建测试用例过程记录的渲染策略：解析对应的html并输出到word
     * @author xuwangcheng
     * @date 2019/7/26 10:10
     * @param
     * @return {@link AbstractRenderPolicy}
     */
    private static AbstractRenderPolicy createHtmlRenderPolicy() {
        return new AbstractRenderPolicy() {
            @Override
            protected void afterRender(RenderContext context) {
                // 清空模板标签所在段落
                clearPlaceholder(context, true);
            }

            @Override
            public void doRender(RunTemplate runTemplate, Object data, XWPFTemplate template) throws Exception {
                if (data == null || StringUtils.isBlank(data.toString())) {
                    return;
                }

                //获得Apache POI增强类NiceXWPFDocument
                NiceXWPFDocument doc = template.getXWPFDocument();

                String html = data.toString();
                html = html.replaceAll("&gt;", ">")
                        .replaceAll("&lt;", "<")
                        .replaceAll("&nbsp;", " ")
                        .replaceAll("\\n", "")
                        .replaceAll("<br>", "\n");
                org.jsoup.nodes.Document htmlDoc = Jsoup.parse(html);
                Elements nodes = htmlDoc.body().children();
                XWPFParagraph xwpfParagraph = doc.createParagraph();

                ListIterator<Element> itr = nodes.listIterator();
                while (itr.hasNext()) {
                    Element e = itr.next();
                    xwpfParagraph = parseHtmlToWord(e, doc, xwpfParagraph, true);
                }
            }
        };
    }


    /**
     * 转换整个html内容为word内容
     * @author xuwangcheng
     * @date 2019/7/29 18:46
     * @param ele ele
     * @param doc doc
     * @param xwpfParagraph xwpfParagraph
     * @return {@link XWPFParagraph}
     */
    private static XWPFParagraph parseHtmlToWord(Element ele, NiceXWPFDocument doc, XWPFParagraph xwpfParagraph
            , boolean isParent) throws Exception {

        //处理img图片
        if ("img".equals(ele.tagName())) {
            parseImgToWord(ele.attr("src"), xwpfParagraph);
            return xwpfParagraph;
        }

        //处理table标签
        if ("table".equals(ele.tagName())) {
            parseTableToWord(doc, ele);
            //有表格的话新建段落
            xwpfParagraph = doc.createParagraph();
            return xwpfParagraph;
        }


        //处理<sup>标签 上标
        if ("sup".equalsIgnoreCase(ele.tagName())) {
            XWPFRun run = xwpfParagraph.createRun();
            run.setText(ele.text());
            // 设置字体加粗;
            run.setBold(true);
            // 设置字体大小;
            run.setFontSize(12);
            run.setFontFamily("Times New Roman", XWPFRun.FontCharRange.ascii);
            run.setFontFamily("宋体", XWPFRun.FontCharRange.eastAsia);
            run.setSubscript(VerticalAlign.SUPERSCRIPT);

            TextRenderPolicy.Helper.renderTextRun(run, new TextRenderData(ele.text()));
            return xwpfParagraph;
        }

        //处理其他文本标签
        String text = ele.ownText();
        boolean continueItr = true;
        //span标签默认全部为文字，不再继续迭代
        if ("span".equalsIgnoreCase(ele.tagName())) {
            text = ele.wholeText();
            continueItr = false;
        }

        boolean enabledBreak = (isParent || StringUtils.isNotBlank(ele.text()))
                && ReUtil.isMatch("(p|h[12345]|li|img)", ele.tagName());
        if (enabledBreak) {
            XWPFRun run = xwpfParagraph.createRun();
            run.addBreak();
        }

        if (StringUtils.isNotBlank(text)) {
            XWPFRun run = xwpfParagraph.createRun();
            TextRenderPolicy.Helper.renderTextRun(run, new TextRenderData(text));
        }


        if (continueItr && ele.children().size() > 0) {
            ListIterator<Element> itr = ele.children().listIterator();
            while (itr.hasNext()) {
                Element me = itr.next();
                xwpfParagraph = parseHtmlToWord(me, doc, xwpfParagraph, false);
            }
        }

        return xwpfParagraph;
    }


    /**
     * 转换图片为word内容
     * @author xuwangcheng
     * @date 2019/7/29 18:45
     * @param imgUrl imgUrl
     * @param xwpfParagraph xwpfParagraph
     */
    private static void parseImgToWord(String imgUrl, XWPFParagraph xwpfParagraph) throws Exception {
        //获取图片本地路径
       String imgRealPath = getImgRealPath(imgUrl);

       if (StringUtils.isBlank(imgRealPath) || !FileUtil.exist(imgRealPath)) {
           return;
       }

        //插入图片
        //获取图片对象
        BufferedImage img = ImageIO.read(new File(imgRealPath));
        //获得图片的宽
        int width = img.getWidth();
        //获得图片的高
        int height = img.getHeight();
        if (width > 600) {
            //获取比例
            int rate = (width / 600 ) + 1;
            width = width / rate - 20;
            height = height / rate;
        }
        PictureRenderData pictureRenderData = new PictureRenderData(width, height, imgRealPath);
        XWPFRun run = xwpfParagraph.createRun();
        PictureRenderPolicy.Helper.renderPicture(run, pictureRenderData);
    }


    /**
     * 通过imgUrl获取本地图片路径
     * @author xuwangcheng
     * @date 2019/11/21 9:47
     * @param imgUrl imgUrl
     * @return {@link String}
     */
    private static String getImgRealPath (String imgUrl) {
        //TODO 获取real_path

        return "H:\\TIM图片20191021151012.gif";
    }

    /**
     * 转换表格为word内容
     * @author xuwangcheng
     * @date 2019/7/29 18:45
     * @param doc doc
     * @param ele ele
     */
    private static void parseTableToWord(NiceXWPFDocument doc, Element ele) throws Exception {
        //简化表格html
        org.jsoup.nodes.Document tableDoc = Jsoup.parse(simplifyTable(ele.outerHtml()));
        Elements trList = tableDoc.getElementsByTag("tr");
        Elements tdList = trList.get(0).getElementsByTag("td");

        //创建表格
        XWPFTable xwpfTable = doc.createTable(trList.size(), tdList.size());

        //设置样式
        TableTools.widthTable(xwpfTable, MiniTableRenderData.WIDTH_A4_FULL, tdList.size());
        TableTools.borderTable(xwpfTable, 4);

        //写入表格行和列内容
        Map<String, Boolean>[][] array = new Map[trList.size()][tdList.size()];
        for (int row = 0; row < trList.size(); row++) {
            Element trElement = trList.get(row);
            Elements tds = trElement.getElementsByTag("td");
            for (int col = 0; col < tds.size(); col++) {
                Element colElement = tds.get(col);
                String colspan = colElement.attr("colspan");
                String rowspan = colElement.attr("rowspan");
                String style = colElement.attr("style");
                StringBuilder styleSB = new StringBuilder();
                if (!StringUtils.isEmpty(colspan)) {
                    int colCount = Integer.parseInt(colspan);
                    for (int i = 0; i < colCount - 1; i++) {
                        array[row][col + i + 1] = new HashMap<String, Boolean>();
                        array[row][col + i + 1].put("mergeCol", true);
                    }
                }
                if (!StringUtils.isEmpty(rowspan)) {
                    int rowCount = Integer.parseInt(rowspan);
                    for (int i = 0; i < rowCount - 1; i++) {
                        array[row + i + 1][col] = new HashMap<String, Boolean>();
                        array[row + i + 1][col].put("mergeRow", true);
                    }
                }
                XWPFTableCell tableCell = xwpfTable.getRow(row).getCell(col);
                if (StringUtils.isEmpty(colspan)) {
                    if (col == 0) {
                        if (tableCell.getCTTc().getTcPr() == null) {
                            tableCell.getCTTc().addNewTcPr().addNewHMerge().setVal(STMerge.RESTART);
                        } else {
                            if (tableCell.getCTTc().getTcPr().getHMerge() == null) {
                                tableCell.getCTTc().getTcPr().addNewHMerge().setVal(STMerge.RESTART);
                            } else {
                                tableCell.getCTTc().getTcPr().getHMerge().setVal(STMerge.RESTART);
                            }
                        }
                    } else {
                        if (array[row][col] != null && array[row][col].get("mergeCol") != null && array[row][col].get("mergeCol")) {
                            if (tableCell.getCTTc().getTcPr() == null) {
                                tableCell.getCTTc().addNewTcPr().addNewHMerge().setVal(STMerge.CONTINUE);
                            } else {
                                if (tableCell.getCTTc().getTcPr().getHMerge() == null) {
                                    tableCell.getCTTc().getTcPr().addNewHMerge().setVal(STMerge.CONTINUE);
                                } else {
                                    tableCell.getCTTc().getTcPr().getHMerge().setVal(STMerge.CONTINUE);
                                }
                            }
                            continue;
                        } else {
                            if (tableCell.getCTTc().getTcPr() == null) {
                                tableCell.getCTTc().addNewTcPr().addNewHMerge().setVal(STMerge.RESTART);
                            } else {
                                if (tableCell.getCTTc().getTcPr().getHMerge() == null) {
                                    tableCell.getCTTc().getTcPr().addNewHMerge().setVal(STMerge.RESTART);
                                } else {
                                    tableCell.getCTTc().getTcPr().getHMerge().setVal(STMerge.RESTART);
                                }
                            }
                        }
                    }
                } else {
                    if (tableCell.getCTTc().getTcPr() == null) {
                        tableCell.getCTTc().addNewTcPr().addNewHMerge().setVal(STMerge.RESTART);
                    } else {
                        if (tableCell.getCTTc().getTcPr().getHMerge() == null) {
                            tableCell.getCTTc().getTcPr().addNewHMerge().setVal(STMerge.RESTART);
                        } else {
                            tableCell.getCTTc().getTcPr().getHMerge().setVal(STMerge.RESTART);
                        }
                    }
                }
                if (StringUtils.isEmpty(rowspan)) {
                    if (array[row][col] != null && array[row][col].get("mergeRow") != null && array[row][col].get("mergeRow")) {
                        if (tableCell.getCTTc().getTcPr() == null) {
                            tableCell.getCTTc().addNewTcPr().addNewVMerge().setVal(STMerge.CONTINUE);
                        } else {
                            if (tableCell.getCTTc().getTcPr().getVMerge() == null) {
                                tableCell.getCTTc().getTcPr().addNewVMerge().setVal(STMerge.CONTINUE);
                            } else {
                                tableCell.getCTTc().getTcPr().getVMerge().setVal(STMerge.CONTINUE);
                            }
                        }
                        continue;
                    } else {
                        if (tableCell.getCTTc().getTcPr() == null) {
                            tableCell.getCTTc().addNewTcPr().addNewVMerge().setVal(STMerge.RESTART);
                        } else {
                            if (tableCell.getCTTc().getTcPr().getVMerge() == null) {
                                tableCell.getCTTc().getTcPr().addNewVMerge().setVal(STMerge.RESTART);
                            } else {
                                tableCell.getCTTc().getTcPr().getVMerge().setVal(STMerge.RESTART);
                            }
                        }
                    }
                } else {
                    if (tableCell.getCTTc().getTcPr() == null) {
                        tableCell.getCTTc().addNewTcPr().addNewVMerge().setVal(STMerge.RESTART);
                    } else {
                        if (tableCell.getCTTc().getTcPr().getVMerge() == null) {
                            tableCell.getCTTc().getTcPr().addNewVMerge().setVal(STMerge.RESTART);
                        } else {
                            tableCell.getCTTc().getTcPr().getVMerge().setVal(STMerge.RESTART);
                        }
                    }
                }
                tableCell.removeParagraph(0);
                XWPFParagraph paragraph = tableCell.addParagraph();
                paragraph.setStyle(styleSB.toString());
                if (!StringUtils.isEmpty(style) && style.contains("text-align:center")) {
                    paragraph.setAlignment(ParagraphAlignment.CENTER);
                }

                parseHtmlToWord(colElement, doc, paragraph, true);
            }
        }
    }

    /**
     * 简化html中的表格dom
     * @author xuwangcheng
     * @date 2019/7/29 18:39
     * @param tableContent tableContent
     * @return {@link String}
     */
    private static String simplifyTable(String tableContent) {
        if (StringUtils.isEmpty(tableContent)) {
            return null;
        }
        org.jsoup.nodes.Document tableDoc = Jsoup.parse(tableContent);
        Elements trElements = tableDoc.getElementsByTag("tr");
        if (trElements != null) {
            Iterator<Element> eleIterator = trElements.iterator();
            Integer rowNum = 0;
            // 针对于colspan操作
            while (eleIterator.hasNext()) {
                rowNum++;
                Element trElement = eleIterator.next();
                //去除所有样式
                trElement.removeAttr("class");
                Elements tdElements = trElement.getElementsByTag("td");
                List<Element> tdEleList = covertElements2List(tdElements);
                for (int i = 0; i < tdEleList.size(); i++) {
                    Element curTdElement = tdEleList.get(i);
                    //去除所有样式
                    curTdElement.removeAttr("class");
                    Element ele = curTdElement.clone();
                    String colspanValStr = curTdElement.attr("colspan");
                    if (!StringUtils.isEmpty(colspanValStr)) {
                        ele.removeAttr("colspan");
                        Integer colspanVal = Integer.parseInt(colspanValStr);
                        for (int k = 0; k < colspanVal - 1; k++) {
                            curTdElement.after(ele.outerHtml());
                        }
                    }
                }
            }
            // 针对于rowspan操作
            List<Element> trEleList = covertElements2List(trElements);
            Element firstTrEle = trElements.first();
            Elements tdElements = firstTrEle.getElementsByTag("td");
            Integer tdCount = tdElements.size();
            //获取该列下所有单元格
            for (int i = 0; i < tdElements.size(); i++) {
                for (Element trElement : trEleList) {
                    List<Element> tdElementList = covertElements2List(trElement.getElementsByTag("td"));
                    try {
                        tdElementList.get(i);
                    } catch (Exception e) {
                        continue;
                    }
                    Node curTdNode = tdElementList.get(i);
                    Node cNode = curTdNode.clone();
                    String rowspanValStr = curTdNode.attr("rowspan");
                    if (!StringUtils.isEmpty(rowspanValStr)) {
                        cNode.removeAttr("rowspan");
                        Element nextTrElement = trElement.nextElementSibling();
                        Integer rowspanVal = Integer.parseInt(rowspanValStr);
                        for (int j = 0; j < rowspanVal - 1; j++) {
                            Node tempNode = cNode.clone();
                            List<Node> nodeList = new ArrayList<Node>();
                            nodeList.add(tempNode);
                            if (j > 0) {
                                nextTrElement = nextTrElement.nextElementSibling();
                            }
                            Integer indexNum = i + 1;
                            if (i == 0) {
                                indexNum = 0;
                            }
                            if (indexNum.equals(tdCount)) {
                                nextTrElement.appendChild(tempNode);
                            } else {
                                nextTrElement.insertChildren(indexNum, nodeList);
                            }
                        }
                    }
                }
            }
        }
        Element tableEle = tableDoc.getElementsByTag("table").first();
        String tableHtml = tableEle.outerHtml();

        return tableHtml;
    }

    /**
     * 转换Elements为list
     * @author xuwangcheng
     * @date 2019/7/29 18:40
     * @param curElements curElements
     * @return {@link List}
     */
    private static List<Element> covertElements2List(Elements curElements){
        List<Element> elementList = new ArrayList<Element>();
        Iterator<Element> eleIterator = curElements.iterator();
        while(eleIterator.hasNext()){
            Element curlement = eleIterator.next();
            elementList.add(curlement);
        }
        return elementList;
    }
}
以前，我总以为自己是菜鸟，也总想着早起的鸟儿有虫吃。直到有一天我想飞，才愕然的发现自己没有翅膀和羽毛，我竟然是菜虫！早起的虫儿被鸟吃……原来，百足应该厚积薄发！
白卡pala
关注
Java生成Word-＞PDF-＞图片：基于poi-tl 进行word模板渲染
iOS逆向与安全
08-08 225
需求： 根据数据生成图文样式的Word文档，例如电子协议、设备安装表。处理包含照片的渲染数据。
java使用POI实现html和word相互转换
08-26
主要为大家详细介绍了java使用POI实现html和word的相互转换，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
利用Poi-tl将富文本Html转换为Word文件
01-08
poi-tl相关的请参考：http://deepoove.com/poi-tl/ 相关思路是先通过Jsoup将富文本Html迭代循环，在特定的方法里处理每一个标签，目前支持处理的标签包括img,table,sup,以及类似span,h等文本标签，其他的标签处理需要自己自定义处理。另外这种方法不会保存富文本的一些样式，但是足够了。至于如何转换就需要借助poi-tl的模板功能和工具类。 想要具体的Demo请看：https://gitee.com/xuwangcheng/poi-tl-html-to-word 有疑问请加QQ群：468324085 作者：白卡pala
poi-tl 使用springEl 表达式实现自定义函数
最新发布
PointerIsSoul的博客
08-02 586
poi-tl 踩坑
Java利用poi-tl实现富文本HTML转Word
你是我一生的追求
04-09 1512
poi-tl-ext 0.3.3的版本，在实际用的过程中，对于如下html解析有误，升级到0.3.18解决问题。如果html里有table，则原生table加边框样式不生效，需要添加td样式，如将。升级版本前生成word结果：发现合计等表格没有了，而且备注下面的边框少了一个。【注意：】依赖的版本，不能乱改，可能会有冲突。好了，运行看结果吧。
基于poi-tl的html转word简单功能实现
叽叽叽叽叽叽叽叽叽叽叽叽叽叽叽叽
08-18 654
出于项目需求，要将页面文本编辑器的代码转为并且嵌入word模版中。在网上找到了大佬的模板，然后试了试，稍微改造了一下。 https://gitee.com/xuwangcheng/html-to-word/tree/master 改造的点： 版本升级，原本项目就已经使用了1.9.0版本的poi-tl，示例代码中是1.6.0，担心版本降级引发同事的代码报错，改了部分代码； 大佬的代码是递归执行并且只处理了最下面一层，举个栗子： <b><font size="4">你好</fo
word转换成html（poi）
willie_chen的专栏
08-17 798
使用word转换成html常见问题：版本、图片无法显示问题。 版本 异常：(The supplied data appears to be in the Office 2007+ XML. You are calling the part of POI that deals with OLE2 Office Documents. You need to call a different part...
使用较新poi版本实现word 转 html
lijianghuai的博客
10-16 4503
import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io.IOException; import java.io.InputStream; import java.util.Map; import javax.xml.parsers.DocumentBuilderFactory...
poi-tl实现根据模板生成合同和html转doc，doc转docx的Demo
07-25
在`poitl-demo`这个压缩包文件中，我们可以期待找到一个完整的Java项目，包含了必要的源代码、依赖库和运行指南。通过研究和运行这些示例，开发者可以深入理解`poi-tl`的工作原理，学习如何设置模板、插入数据以及...
java使用poi将word文档转为html
01-14
使用poi将word文档转为html文档，亲测可用，上传之前专门测试过！有完整的代码，直接下载运行即可！
poi-tl引擎实现world模板内容替换(支持docx)
07-30
* poi-tl引擎实现world模板内容替换(支持docx) * 依赖poi-tl,commons-lang3, poi-ooxml-schemas, poi-ooxml, poi,slf4j
html2wordtemplate.docx
06-16
Java利用poi-tl实现富文本HTML转Word 附件
利用POI将word转换成html实现在线阅读
04-21
转换Word到HTML的核心步骤如下： 1. **读取Word文档**：使用HWPFDocument或XWPFDocument类根据文档格式打开Word文件。如果是Word 2003格式（.doc），则使用HWPFDocument；如果是Word 2007及以上版本（.docx），则...
SpringBoot+Poi-tl根据Word模板动态生成word(含动态行表格)
热门推荐
12程序猿的博客
12-23 1万+
SpringBoot+Poi-tl根据Word模板动态生成含动态表格的word文档。 Poi-tl官方文档：http://deepoove.com/poi-tl/ 实现过程 1.添加必要依赖 <!-- word导出 --> <!-- poi-tl是基于Apache POI的Word模板引擎。poi-tl依赖的是poi3.16版本 --> <dependency> <groupId>com.deepoove</groupId> <ar
POI html 转为 word文档
qq_49306973的博客
11-20 595
目前，POI已经成为了Java开发中创建、读/写Microsoft Office文档的标准库之一，有很多Java程序都使用它来操作Office文档。通过以上介绍，我们可以看出使用POI将HTML页面转化为Word文档是一种十分实用的功能，它可以帮助我们在日常工作中快速、准确地实现对各种文本内容的处理。POI封装了Java一些操作Office软件的API，能够帮助我们更加方便地操作Word、Excel等文档格式，提高我们的工作效率，为我们的工作带来更多的便捷。
Java POI导出富文本的内容到word文档
qq_39672880的博客
03-14 7226
当创建使用富文本编辑器，操作完的数据，传输到后台都是带有html标签的
使用poi-tl根据富文本编辑器代码生成word下载功能
贤和知识点收藏
06-07 1477
poi-tl在线生成word文档
poi-tl html转word
04-30
Poi-tl是一款开源的Java操作Office文档的工具，它可以非常方便地实现将html转换为Word文档的功能。使用Poi-tl，我们可以轻松地将HTML文件转换为DOCX格式的Word文档。在进行HTML转Word操作前，我们需要先将HTML文件转换为Word的XML格式，然后再通过Poi-tl将XML文件转换为DOCX格式的Word文档。Poi-tl提供了丰富的API，可以实现包括设置Word文档样式、插入表格、插入图片、插入超链接等多种功能。 使用Poi-tl进行HTML转Word操作，需要先在项目中引入Poi-tl的maven依赖。然后，我们需要定义一个模板文件，在模板文件中定义Word文档的格式和样式，同时也需要定义好HTML文件中标签和样式的对应关系。最后，使用Poi-tl的API读取HTML文件，解析它的内容，并根据模板文件生成Word文档。 总之，Poi-tl是一款非常方便的工具，能够实现将HTML文件快速转换为Word文档的功能，使得开发人员可以用更简单的方式生成Word文档，提高开发效率和代码质量。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

白卡pala

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值