登录/ 注册
 找回密码
 立即注册
关闭

CSDN热搜

程序园 精品问答 技术交流 资源下载
返回列表 发新帖
首页 › 业界区 › 业界 ›1. markdown转word 第一步: markdown转html

1. markdown转word 第一步: markdown转html

梢疠 昨天 20:40
1. 简介

最近因为项目需求需要将AI输出的结果导出到word中, 但AI输出的格式为markdown格式,因为word展示内容的时候需要有相应的格式(标题, 段落, 列表, 表格等), 所以不能直接将markdown输出到word中, 否则word中展示的就是markdown纯文本了, 调研一番后发现如果想要word展示效果好一点的话需要分成两步

  • 将markdown→html
  • 将html→ooxml(Office Open XML) word内容,word元信息本身就是个xml)
所以本章先实现第一步 markdown → html, 使用的组件为flexmark
2. 环境信息

为了兼容更多的场景, 所以并没有用一些高版本的SDK, 信息如下
  1. Java: 8
  2. Flexmark: 0.60.2
复制代码
3. Maven
  1. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  2.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  3.     <modelVersion>4.0.0</modelVersion>
  5.     <groupId>com.ldx</groupId>
  6.     md2html</artifactId>
  7.     <version>1.0-SNAPSHOT</version>
  9.     <properties>
  10.         <flexmark.version>0.60.2</flexmark.version>
  11.     </properties>
  13.     <dependencies>
  14.         <dependency>
  15.             <groupId>com.vladsch.flexmark</groupId>
  16.             flexmark</artifactId>
  17.             <version>${flexmark.version}</version>
  18.         </dependency>
  19.         <dependency>
  20.             <groupId>com.vladsch.flexmark</groupId>
  21.             flexmark-ext-tables</artifactId>
  22.             <version>${flexmark.version}</version>
  23.         </dependency>
  24.     </dependencies>
  25. </project>
复制代码
4. Markdown转Html
  1. import com.vladsch.flexmark.html.HtmlRenderer;
  2. import com.vladsch.flexmark.parser.Parser;
  3. import com.vladsch.flexmark.util.ast.Node;
  4. import com.vladsch.flexmark.util.data.MutableDataSet;
  6. public class MarkdownToHtml {
  7.     public static String convertMarkdownToHtml(String markdown) {
  8.         // 创建配置集
  9.         MutableDataSet options = new MutableDataSet();
  10.         // 创建解析器和渲染器
  11.         Parser parser = Parser.builder(options).build();
  12.         HtmlRenderer renderer = HtmlRenderer.builder(options).build();
  13.         // 解析 Markdown 文本
  14.         Node document = parser.parse(markdown);
  15.         // 渲染为 HTML
  16.         return renderer.render(document);
  17.     }
  19.     public static void main(String[] args) {
  20.         String markdown = "## 嘉文四世\n" + "\n" + "> 德玛西亚\n" + "\n" + "**给我找些更强的敌人！**";
  21.         final String html = convertMarkdownToHtml(markdown);
  22.         System.out.println(html);
  23.     }
  24. }
复制代码
测试结果如下:
  1. <h2>嘉文四世</h2>
  2. <blockquote>
  3. <p>德玛西亚</p>
  4. </blockquote>
  5. <p><strong>给我找些更强的敌人！</strong></p>
复制代码
5. 高级用法

5.1 启用Table扩展

flexmark 支持多种扩展，需要通过 Extension 注册, 比如启用表格语法, flexmark默认没有启用表格语法比如测试
  1. public static void main(String[] args) {
  2.     String markdown = "| 列1   | 列2   |\n" + "| ----- | ----- |\n" + "| 数据1 | 数据2 |";
  3.     final String html = convertMarkdownToHtml(markdown);
  4.     System.out.println(html);
  5. }
复制代码
测试结果如下:
  1. <p>| 列1   | 列2   |
  2. | ----- | ----- |
  3. | 数据1 | 数据2 |</p>
复制代码
没有将表格转换为html table标签, 所以需要启用表格扩展, 如下:
  1. MutableDataSet options = new MutableDataSet();
  2. // 启用表格扩展，支持 Markdown 表格语法
  3. options.set(Parser.EXTENSIONS, Collections.singletonList(TablesExtension.create()));
  4. // 禁用跨列
  5. options.set(TablesExtension.COLUMN_SPANS, false);
  6. // 表头固定为 1 行
  7. options.set(TablesExtension.MIN_HEADER_ROWS, 1);
  8. options.set(TablesExtension.MAX_HEADER_ROWS, 1);
  9. // 自动补全缺失列、丢弃多余列
  10. options.set(TablesExtension.APPEND_MISSING_COLUMNS, true);
  11. options.set(TablesExtension.DISCARD_EXTRA_COLUMNS, true);
复制代码
测试结果如下:
  1. <table>
  2. <thead>
  3. <tr><th>列1</th><th>列2</th></tr>
  4. </thead>
  5. <tbody>
  6. <tr><td>数据1</td><td>数据2</td></tr>
  7. </tbody>
  8. </table>
复制代码
5.2 标签属性扩展

flexmark支持对标签属性的操作, 需要实现其AttributeProviderFactory类, 比如给对应标签添加class属性, 如下:
  1. HtmlRenderer renderer = HtmlRenderer.builder(options)
  2.   .attributeProviderFactory(new IndependentAttributeProviderFactory() {
  3.     @Override
  4.     public @NotNull AttributeProvider apply(@NotNull LinkResolverContext context) {
  5.       return (node, part, attributes) -> {
  6.         // 标题
  7.         if (node instanceof Heading) {
  8.           Heading heading = (Heading) node;
  9.           attributes.addValue("class", "heading" + heading.getLevel());
  10.         }
  12.         // 正文
  13.         if (node instanceof Text) {
  14.           attributes.addValue("class", "Normal");
  15.         }
  17.         // 段落
  18.         if (node instanceof Paragraph) {
  19.           attributes.addValue("class", "paragraph");
  20.         }
  22.         // 无序列表
  23.         if (node instanceof BulletList) {
  24.           attributes.addValue("class", "bulletList");
  25.         }
  27.         // 有序列表
  28.         if (node instanceof OrderedList) {
  29.           attributes.addValue("class", "bulletList");
  30.         }
  32.         // 表格
  33.         if (node instanceof TableBlock) {
  34.           attributes.addValue("class", "tableBlock");
  35.         }
  36.       };
  38.     }
  39.   })
  40.   .build();
复制代码
测试如下内容:
  1. public static void main(String[] args) {
  2.     String markdown = "## 嘉文四世\n" + "\n" + "> 德玛西亚\n" + "\n" + "**给我找些更强的敌人！**\n" + "\n" + "| 列1   | 列2   |\n" + "| ----- | ----- |\n" + "| 数据1 | 数据2 |";
  3.     final String html = convertMarkdownToHtml(markdown);
  4.     System.out.println(html);
  5. }
复制代码
测试结果如下:
  1. <h2>嘉文四世</h2>
  2. <blockquote>
  3. <p>德玛西亚</p>
  4. </blockquote>
  5. <p><strong>给我找些更强的敌人！</strong></p><table>
  6. <thead>
  7. <tr><th>列1</th><th>列2</th></tr>
  8. </thead>
  9. <tbody>
  10. <tr><td>数据1</td><td>数据2</td></tr>
  11. </tbody>
  12. </table>
复制代码
5.3 完善Html结构

上述的测试结果中输出的都是markdown语句翻译后的html代码块, 并不是一个完整的html页面内容, 比如要将结果输出成html文件并展示的话还需要html完整的骨架标签如:等, 这时候就需要使用jsoup进行优化

  • 添加对应的坐标
    1. <jsoup.version>1.17.2</jsoup.version>
    3. <dependency>
    4.     <groupId>org.jsoup</groupId>
    5.     jsoup</artifactId>
    6.     <version>${jsoup.version}</version>
    7. </dependency>
    复制代码
  • 完善html结构
    1. public static String wrapperHtml(String htmlContent) {
    2.     org.jsoup.nodes.Document jsoupDoc = Jsoup.parse(htmlContent);
    3.     jsoupDoc.outputSettings()
    4.         // 内容输出时遵循XML语法规则
    5.         .syntax(org.jsoup.nodes.Document.OutputSettings.Syntax.xml)
    6.         // 内容转义时遵循xhtml规范
    7.         .escapeMode(Entities.EscapeMode.xhtml)
    8.         // 禁用格式化输出
    9.         .prettyPrint(false);
    10.     return jsoupDoc.html();
    11. }
    13. public static void main(String[] args) {
    14.     String markdown = "## 嘉文四世\n" + "\n" + "> 德玛西亚\n" + "\n" + "**给我找些更强的敌人！**\n" + "\n" + "| 列1   | 列2   |\n" + "| ----- | ----- |\n" + "| 数据1 | 数据2 |";
    15.     final String html = convertMarkdownToHtml(markdown);
    16.     final String wrappedHtml = wrapperHtml(html);
    17.     System.out.println(wrappedHtml);
    18. }
    复制代码
    测试结果如下:
    1. <h2>嘉文四世</h2>
    2. <blockquote>
    3. <p>德玛西亚</p>
    4. </blockquote>
    5. <p><strong>给我找些更强的敌人！</strong></p><table>
    6. <thead>
    7. <tr><th>列1</th><th>列2</th></tr>
    8. </thead>
    9. <tbody>
    10. <tr><td>数据1</td><td>数据2</td></tr>
    11. </tbody>
    12. </table>
    复制代码
6. 完整测试代码
  1. package md2html;
  3. import com.vladsch.flexmark.ast.BulletList;
  4. import com.vladsch.flexmark.ast.Heading;
  5. import com.vladsch.flexmark.ast.OrderedList;
  6. import com.vladsch.flexmark.ast.Paragraph;
  7. import com.vladsch.flexmark.ast.Text;
  8. import com.vladsch.flexmark.ext.tables.TableBlock;
  9. import com.vladsch.flexmark.ext.tables.TablesExtension;
  10. import com.vladsch.flexmark.html.AttributeProvider;
  11. import com.vladsch.flexmark.html.HtmlRenderer;
  12. import com.vladsch.flexmark.html.IndependentAttributeProviderFactory;
  13. import com.vladsch.flexmark.html.renderer.LinkResolverContext;
  14. import com.vladsch.flexmark.parser.Parser;
  15. import com.vladsch.flexmark.util.ast.Node;
  16. import com.vladsch.flexmark.util.data.MutableDataSet;
  17. import org.jetbrains.annotations.NotNull;
  18. import org.jsoup.Jsoup;
  19. import org.jsoup.nodes.Entities;
  21. import java.util.Collections;
  23. public class MarkdownToHtml {
  24.     public static String convertMarkdownToHtml(String markdown) {
  25.         // 创建配置集
  26.         MutableDataSet options = new MutableDataSet();
  27.         // 启用表格扩展，支持 Markdown 表格语法
  28.         options.set(Parser.EXTENSIONS, Collections.singletonList(TablesExtension.create()));
  29.         // 禁用跨列
  30.         options.set(TablesExtension.COLUMN_SPANS, false);
  31.         // 表头固定为 1 行
  32.         options.set(TablesExtension.MIN_HEADER_ROWS, 1);
  33.         options.set(TablesExtension.MAX_HEADER_ROWS, 1);
  34.         // 自动补全缺失列、丢弃多余列
  35.         options.set(TablesExtension.APPEND_MISSING_COLUMNS, true);
  36.         options.set(TablesExtension.DISCARD_EXTRA_COLUMNS, true);
  37.         // 创建解析器和渲染器
  38.         Parser parser = Parser.builder(options)
  39.                               .build();
  40.         HtmlRenderer renderer = HtmlRenderer.builder(options)
  41.                                             .attributeProviderFactory(new IndependentAttributeProviderFactory() {
  42.                                                 @Override
  43.                                                 public @NotNull AttributeProvider apply(@NotNull LinkResolverContext context) {
  44.                                                     return (node, part, attributes) -> {
  45.                                                         // 标题
  46.                                                         if (node instanceof Heading) {
  47.                                                             Heading heading = (Heading) node;
  48.                                                             attributes.addValue("class", "heading" + heading.getLevel());
  49.                                                         }
  51.                                                         // 正文
  52.                                                         if (node instanceof Text) {
  53.                                                             attributes.addValue("class", "Normal");
  54.                                                         }
  56.                                                         // 段落
  57.                                                         if (node instanceof Paragraph) {
  58.                                                             attributes.addValue("class", "paragraph");
  59.                                                         }
  61.                                                         // 无序列表
  62.                                                         if (node instanceof BulletList) {
  63.                                                             attributes.addValue("class", "bulletList");
  64.                                                         }
  66.                                                         // 有序列表
  67.                                                         if (node instanceof OrderedList) {
  68.                                                             attributes.addValue("class", "bulletList");
  69.                                                         }
  71.                                                         // 表格
  72.                                                         if (node instanceof TableBlock) {
  73.                                                             attributes.addValue("class", "tableBlock");
  74.                                                         }
  75.                                                     };
  77.                                                 }
  78.                                             })
  79.                                             .build();
  81.         // 解析 Markdown 文本
  82.         Node document = parser.parse(markdown);
  83.         // 渲染为 HTML
  84.         return renderer.render(document);
  85.     }
  87.     public static String wrapperHtml(String htmlContent) {
  88.         org.jsoup.nodes.Document jsoupDoc = Jsoup.parse(htmlContent);
  89.         jsoupDoc.outputSettings()
  90.                 // 内容输出时遵循XML语法规则
  91.                 .syntax(org.jsoup.nodes.Document.OutputSettings.Syntax.xml)
  92.                 // 内容转义时遵循xhtml规范
  93.                 .escapeMode(Entities.EscapeMode.xhtml)
  94.                 // 禁用格式化输出
  95.                 .prettyPrint(false);
  96.         return jsoupDoc.html();
  97.     }
  99.     public static void main(String[] args) {
  100.         String markdown = "## 嘉文四世\n" + "\n" + "> 德玛西亚\n" + "\n" + "**给我找些更强的敌人！**\n" + "\n" + "| 列1   | 列2   |\n" + "| ----- | ----- |\n" + "| 数据1 | 数据2 |";
  101.         final String html = convertMarkdownToHtml(markdown);
  102.         final String wrappedHtml = wrapperHtml(html);
  103.         System.out.println(wrappedHtml);
  104.     }
  105. }
复制代码
7. 封装工具类

为了更方便的使用flexmark, 我将其常用的方法封装成链式调用的工具类, 内容如下:
  1. import com.vladsch.flexmark.ast.BlockQuote;
  2. import com.vladsch.flexmark.ast.BulletList;
  3. import com.vladsch.flexmark.ast.Code;
  4. import com.vladsch.flexmark.ast.Emphasis;
  5. import com.vladsch.flexmark.ast.FencedCodeBlock;
  6. import com.vladsch.flexmark.ast.Heading;
  7. import com.vladsch.flexmark.ast.Image;
  8. import com.vladsch.flexmark.ast.IndentedCodeBlock;
  9. import com.vladsch.flexmark.ast.Link;
  10. import com.vladsch.flexmark.ast.ListItem;
  11. import com.vladsch.flexmark.ast.OrderedList;
  12. import com.vladsch.flexmark.ast.Paragraph;
  13. import com.vladsch.flexmark.ast.StrongEmphasis;
  14. import com.vladsch.flexmark.ast.ThematicBreak;
  15. import com.vladsch.flexmark.ext.tables.TableBlock;
  16. import com.vladsch.flexmark.ext.tables.TablesExtension;
  17. import com.vladsch.flexmark.html.AttributeProvider;
  18. import com.vladsch.flexmark.html.AttributeProviderFactory;
  19. import com.vladsch.flexmark.html.HtmlRenderer;
  20. import com.vladsch.flexmark.html.IndependentAttributeProviderFactory;
  21. import com.vladsch.flexmark.html.renderer.LinkResolverContext;
  22. import com.vladsch.flexmark.parser.Parser;
  23. import com.vladsch.flexmark.util.ast.Document;
  24. import com.vladsch.flexmark.util.ast.Node;
  25. import com.vladsch.flexmark.util.data.MutableDataSet;
  26. import lombok.extern.slf4j.Slf4j;
  27. import org.jetbrains.annotations.NotNull;
  28. import org.jsoup.Jsoup;
  29. import org.jsoup.nodes.Entities;
  31. import java.io.BufferedReader;
  32. import java.io.File;
  33. import java.io.FileReader;
  34. import java.io.IOException;
  35. import java.io.InputStream;
  36. import java.io.InputStreamReader;
  37. import java.util.Collections;
  39. /**
  40. * markdown 工具类
  41. *
  42. * @author ludangxin
  43. * @since 2025/10/14
  44. */
  45. @Slf4j
  46. public class Markdowns {
  48.     public static MarkdownBuilder builder(InputStream inputStream, String charset) {
  49.         String markdownContent = readMarkdownContent(inputStream, charset);
  50.         return builder(markdownContent);
  51.     }
  53.     public static MarkdownBuilder builder(InputStream inputStream) {
  54.         String markdownContent = readMarkdownContent(inputStream);
  55.         return builder(markdownContent);
  56.     }
  58.     public static MarkdownBuilder builder(File file) {
  59.         String markdownContent = readMarkdownContent(file);
  60.         return builder(markdownContent);
  61.     }
  63.     public static MarkdownBuilder builder(String markdownContent) {
  64.         return new MarkdownBuilder().content(markdownContent);
  65.     }
  67.     public static String readMarkdownContent(File file) {
  68.         if (file == null || !file.exists()) {
  69.             return "";
  70.         }
  72.         try {
  73.             return readMarkdownContent(new FileReader(file));
  74.         }
  75.         catch (Exception e) {
  76.             log.error("failed to read markdown content", e);
  77.         }
  79.         return "";
  80.     }
  82.     public static String readMarkdownContent(InputStream inputStream) {
  83.         try {
  84.             return readMarkdownContent(new InputStreamReader(inputStream));
  85.         }
  86.         catch (Exception e) {
  87.             log.error("failed to read markdown content", e);
  88.         }
  90.         return "";
  91.     }
  93.     public static String readMarkdownContent(InputStream inputStream, String charset) {
  94.         if (charset == null || charset.isEmpty()) {
  95.             return readMarkdownContent(new InputStreamReader(inputStream));
  96.         }
  98.         try {
  99.             return readMarkdownContent(new InputStreamReader(inputStream, charset));
  100.         }
  101.         catch (Exception e) {
  102.             log.error("failed to read markdown content", e);
  103.         }
  105.         return "";
  106.     }
  108.     public static String readMarkdownContent(InputStreamReader inputStreamReader) {
  109.         try (BufferedReader reader = new BufferedReader(inputStreamReader)) {
  110.             StringBuilder sb = new StringBuilder();
  111.             String line;
  112.             while ((line = reader.readLine()) != null) {
  113.                 sb.append(line);
  114.                 sb.append(System.lineSeparator());
  115.             }
  116.             return sb.toString();
  117.         }
  118.         catch (IOException e) {
  119.             log.error("failed to read markdown content", e);
  120.         }
  122.         return "";
  123.     }
  125.     public static class MarkdownBuilder {
  126.         private String content;
  128.         private MutableDataSet options;
  130.         private AttributeProviderFactory attributeProviderFactory;
  132.         private AttributeProvider attributeProvider;
  134.         private MarkdownBuilder content(String content) {
  135.             this.content = content;
  136.             return this;
  137.         }
  139.         public MarkdownBuilder options(MutableDataSet options) {
  140.             this.options = options;
  141.             return this;
  142.         }
  144.         public MarkdownBuilder attributeProviderFactory(AttributeProviderFactory attributeProviderFactory) {
  145.             this.attributeProviderFactory = attributeProviderFactory;
  146.             return this;
  147.         }
  149.         public MarkdownBuilder attributeProvider(AttributeProvider attributeProvider) {
  150.             this.attributeProvider = attributeProvider;
  151.             return this;
  152.         }
  154.         public MarkdownBuilder printContent() {
  155.             System.out.println(content);
  156.             return this;
  157.         }
  159.         public boolean isMarkdown() {
  160.             if (content == null || content.trim()
  161.                                           .isEmpty()) {
  162.                 return false;
  163.             }
  165.             final Document document = this.buildDocument();
  167.             return hasMarkdownNodes(document);
  168.         }
  170.         public Document buildDocument() {
  171.             Parser parser = Parser.builder(this.getOptionsOrDefault())
  172.                                   .build();
  174.             return parser.parse(content);
  175.         }
  177.         public String buildHtmlContent() {
  178.             return this.wrapperHtml(this.getHtmlRenderer()
  179.                                         .render(this.buildDocument()));
  180.         }
  182.         public String buildRawHtmlContent() {
  183.             return this.getHtmlRenderer()
  184.                        .render(this.buildDocument());
  185.         }
  187.         public String buildRawHtmlIfMarkdown() {
  188.             if (this.isMarkdown()) {
  189.                 return this.buildRawHtmlContent();
  190.             }
  192.             return content;
  193.         }
  195.         public String buildHtmlIfMarkdown() {
  196.             if (this.isMarkdown()) {
  197.                 return this.buildHtmlContent();
  198.             }
  200.             return content;
  201.         }
  203.         private HtmlRenderer getHtmlRenderer() {
  204.             final HtmlRenderer.Builder builder = HtmlRenderer.builder(getOptionsOrDefault());
  206.             if (attributeProviderFactory != null) {
  207.                 builder.attributeProviderFactory(attributeProviderFactory);
  208.             }
  210.             if (attributeProviderFactory == null && attributeProvider != null) {
  211.                 final IndependentAttributeProviderFactory independentAttributeProviderFactory = new IndependentAttributeProviderFactory() {
  212.                     @Override
  213.                     public @NotNull AttributeProvider apply(@NotNull LinkResolverContext linkResolverContext) {
  214.                         return attributeProvider;
  215.                     }
  216.                 };
  217.                 builder.attributeProviderFactory(independentAttributeProviderFactory);
  218.             }
  220.             return builder.build();
  221.         }
  223.         private MutableDataSet getOptionsOrDefault() {
  224.             if (options == null) {
  225.                 return this.defaultOptions();
  226.             }
  227.             else {
  228.                 return options;
  229.             }
  230.         }
  232.         private MutableDataSet defaultOptions() {
  233.             MutableDataSet options = new MutableDataSet();
  234.             // 启用表格扩展，支持 Markdown 表格语法
  235.             options.set(Parser.EXTENSIONS, Collections.singletonList(TablesExtension.create()));
  236.             // 禁用跨列
  237.             options.set(TablesExtension.COLUMN_SPANS, false);
  238.             // 表头固定为 1 行
  239.             options.set(TablesExtension.MIN_HEADER_ROWS, 1);
  240.             options.set(TablesExtension.MAX_HEADER_ROWS, 1);
  241.             // 自动补全缺失列、丢弃多余列
  242.             options.set(TablesExtension.APPEND_MISSING_COLUMNS, true);
  243.             options.set(TablesExtension.DISCARD_EXTRA_COLUMNS, true);
  244.             return options;
  245.         }
  247.         private String wrapperHtml(String htmlContent) {
  248.             org.jsoup.nodes.Document jsoupDoc = Jsoup.parse(htmlContent);
  249.             jsoupDoc.outputSettings()
  250.                     // 内容输出时遵循XML语法规则
  251.                     .syntax(org.jsoup.nodes.Document.OutputSettings.Syntax.xml)
  252.                     // 内容转义时遵循xhtml规范
  253.                     .escapeMode(Entities.EscapeMode.xhtml)
  254.                     // 禁用格式化输出
  255.                     .prettyPrint(false);
  256.             return jsoupDoc.html();
  257.         }
  259.         /**
  260.          * 检查 AST 中是否存在 Markdown 特有节点（非纯文本段落）
  261.          */
  262.         private static boolean hasMarkdownNodes(Node node) {
  263.             if (node == null) {
  264.                 return false;
  265.             }
  267.             // 判断当前节点是否为 Markdown 特有节点（非纯文本）
  268.             if (isMarkdownSpecificNode(node)) {
  269.                 return true;
  270.             }
  272.             // 递归检查子节点
  273.             Node child = node.getFirstChild();
  274.             while (child != null) {
  275.                 if (hasMarkdownNodes(child)) {
  276.                     return true;
  277.                 }
  278.                 child = child.getNext();
  279.             }
  281.             return false;
  282.         }
  284.         /**
  285.          * 判定节点是否为 Markdown 特有节点（非纯文本段落）
  286.          * 纯文本段落（Paragraph）且无任何格式（如链接、粗体等）则视为非 Markdown
  287.          */
  288.         private static boolean isMarkdownSpecificNode(Node node) {
  289.             // 标题（# 标题）
  290.             if (node instanceof Heading) {
  291.                 return true;
  292.             }
  293.             // 列表（有序/无序）
  294.             if (node instanceof BulletList || node instanceof OrderedList) {
  295.                 return true;
  296.             }
  297.             // 列表项
  298.             if (node instanceof ListItem) {
  299.                 return true;
  300.             }
  301.             // 链接（[文本](url)）
  302.             if (node instanceof Link) {
  303.                 return true;
  304.             }
  305.             // 图片（![alt](url)）
  306.             if (node instanceof Image) {
  307.                 return true;
  308.             }
  309.             // 粗体（**文本** 或 __文本__）
  310.             if (node instanceof StrongEmphasis) {
  311.                 return true;
  312.             }
  313.             // 斜体（*文本* 或 _文本_）
  314.             if (node instanceof Emphasis) {
  315.                 return true;
  316.             }
  317.             // 代码块（```代码```）
  318.             if (node instanceof FencedCodeBlock || node instanceof IndentedCodeBlock) {
  319.                 return true;
  320.             }
  321.             // 表格（| 表头 | ... |）
  322.             if (node instanceof TableBlock) {
  323.                 return true;
  324.             }
  325.             // 引用（> 引用内容）
  326.             if (node instanceof BlockQuote) {
  327.                 return true;
  328.             }
  329.             // 水平线（--- 或 ***）
  330.             if (node instanceof ThematicBreak) {
  331.                 return true;
  332.             }
  334.             // 段落节点需进一步检查是否包含 inline 格式（如粗体、链接等）
  335.             if (node instanceof Paragraph) {
  336.                 return hasInlineMarkdownNodes(node);
  337.             }
  339.             // 其他节点（如文本节点）视为非特有
  340.             return false;
  341.         }
  343.         /**
  344.          * 检查段落中是否包含 inline 格式（如粗体、链接等）
  345.          */
  346.         private static boolean hasInlineMarkdownNodes(Node paragraph) {
  347.             Node child = paragraph.getFirstChild();
  348.             while (child != null) {
  349.                 // 若段落中包含任何 Markdown  inline 节点，则视为 Markdown
  350.                 if (child instanceof Link || child instanceof Image || child instanceof StrongEmphasis || child instanceof Emphasis || child instanceof Code) {
  351.                     return true;
  352.                 }
  353.                 child = child.getNext();
  354.             }
  355.             return false;
  356.         }
  357.     }
  358. }
复制代码
8. 测试示例
  1. import com.vladsch.flexmark.ast.BulletList;
  2. import com.vladsch.flexmark.ast.Heading;
  3. import com.vladsch.flexmark.ast.OrderedList;
  4. import com.vladsch.flexmark.ast.Paragraph;
  5. import com.vladsch.flexmark.ast.Text;
  6. import com.vladsch.flexmark.ext.tables.TableBlock;
  7. import lombok.SneakyThrows;
  8. import lombok.extern.slf4j.Slf4j;
  9. import org.junit.Test;
  11. import java.io.File;
  12. import java.io.FileInputStream;
  13. import java.io.InputStream;
  14. import java.nio.file.Files;
  15. import java.nio.file.Paths;
  17. /**
  18. * 测试工具类
  19. *
  20. * @author ludangxin
  21. * @since 2025/10/14
  22. */
  23. @Slf4j
  24. public class Md2htmlTest {
  25.     @Test
  26.     public void given_md_str_then_print_complete_html() {
  27.         final String html = Markdowns.builder("# 简介 \n hello world~")
  28.                                   // 打印md内容
  29.                                   .printContent()
  30.                                   // 构建html内容, 自动完善html结构
  31.                                   .buildHtmlContent();
  32.         log.info(html);
  33.         // # 简介
  34.         // hello world~
  35.         //[main] INFO md2html.Md2htmlTest -- <html><head></head><body><h1>简介</h1>
  36.         //<p>hello world~</p>
  37.         //</body></html>
  38.     }
  42.     @Test
  43.     public void given_md_str_then_print_raw_html() {
  44.         final String html = Markdowns.builder("# 简介 \n hello world~")
  45.                                   // 构建raw html内容
  46.                                   .buildRawHtmlContent();
  47.         log.info(html);
  48.         //[main] INFO md2html.Md2htmlTest -- <h1>简介</h1>
  49.         //<p>hello world~</p>
  50.     }
  52.     @Test
  53.     public void given_md_file_then_print_raw_html() {
  54.         final String html = Markdowns.builder(new File("src/test/resources/test.md"))
  55.                                   // 构建raw html内容
  56.                                   .buildRawHtmlContent();
  57.         log.info(html);
  58.         //[main] INFO md2html.Md2htmlTest -- <h2>嘉文四世</h2>
  59.         //<blockquote>
  60.         //<p>德玛西亚</p>
  61.         //</blockquote>
  62.         //<p><strong>给我找些更强的敌人！</strong></p>
  63.         //<table>
  64.         //<thead>
  65.         //<tr><th>列1</th><th>列2</th></tr>
  66.         //</thead>
  67.         //<tbody>
  68.         //<tr><td>数据1</td><td>数据2</td></tr>
  69.         //</tbody>
  70.         //</table>
  71.     }
  73.     @Test
  74.     @SneakyThrows
  75.     public void given_md_stream_then_print_complete_html() {
  76.         final InputStream fileInputStream = Files.newInputStream(Paths.get("src/test/resources/test.md"));
  77.         final String html = Markdowns.builder(fileInputStream)
  78.                                      // 构建html内容
  79.                                      .buildHtmlContent();
  80.         log.info(html);
  81.         //[main] INFO md2html.Md2htmlTest -- <html><head></head><body><h2>嘉文四世</h2>
  82.         //<blockquote>
  83.         //<p>德玛西亚</p>
  84.         //</blockquote>
  85.         //<p><strong>给我找些更强的敌人！</strong></p>
  86.         //<table>
  87.         //<thead>
  88.         //<tr><th>列1</th><th>列2</th></tr>
  89.         //</thead>
  90.         //<tbody>
  91.         //<tr><td>数据1</td><td>数据2</td></tr>
  92.         //</tbody>
  93.         //</table>
  94.         //</body></html>
  95.     }
  97.     @Test
  98.     public void given_non_md_content_then_print_complete_html() {
  99.         // 输入非markdown语法的内容
  100.         final String html = Markdowns.builder("hello world~")
  101.                                      // 构建html内容 (如果内容是md语法则转换为html, 如不不是 则原样输出)
  102.                                      .buildHtmlIfMarkdown();
  103.         // 输入非markdown语法的内容
  104.         final String html2 = Markdowns.builder("## hello world~")
  105.                                      // 构建html内容 (如果内容是md语法则转换为html, 如不不是 则原样输出)
  106.                                      .buildHtmlIfMarkdown();
  107.         log.info(html);
  108.         //[main] INFO md2html.Md2htmlTest -- hello world~
  109.         log.info(html2);
  110.         //[main] INFO md2html.Md2htmlTest -- <html><head></head><body><h2>hello world~</h2>
  111.     }
  113.     @Test
  114.     @SneakyThrows
  115.     public void given_md_stream_and_attr_provider_then_print_raw_html() {
  116.         final InputStream fileInputStream = Files.newInputStream(Paths.get("src/test/resources/test.md"));
  117.         final String html = Markdowns.builder(fileInputStream)
  118.                         .attributeProvider((node, attributablePart, attributes) -> {
  119.                             // 标题
  120.                             if (node instanceof Heading) {
  121.                                 Heading heading = (Heading) node;
  122.                                 attributes.addValue("class", "heading" + heading.getLevel());
  123.                             }
  125.                             // 正文
  126.                             if (node instanceof Text) {
  127.                                 attributes.addValue("class", "Normal");
  128.                             }
  130.                             // 段落
  131.                             if (node instanceof Paragraph) {
  132.                                 attributes.addValue("class", "paragraph");
  133.                             }
  135.                             // 无序列表
  136.                             if (node instanceof BulletList) {
  137.                                 attributes.addValue("class", "bulletList");
  138.                             }
  140.                             // 有序列表
  141.                             if (node instanceof OrderedList) {
  142.                                 attributes.addValue("class", "bulletList");
  143.                             }
  145.                             // 表格
  146.                             if (node instanceof TableBlock) {
  147.                                 attributes.addValue("class", "tableBlock");
  148.                             }
  149.                         })
  150.                         .buildRawHtmlContent();
  151.         log.info(html);
  152.         //[main] INFO md2html.Md2htmlTest -- <h2 >嘉文四世</h2>
  153.         //<blockquote>
  154.         //<p >德玛西亚</p>
  155.         //</blockquote>
  156.         //<p ><strong>给我找些更强的敌人！</strong></p>
  157.         //<table >
  158.         //<thead>
  159.         //<tr><th>列1</th><th>列2</th></tr>
  160.         //</thead>
  161.         //<tbody>
  162.         //<tr><td>数据1</td><td>数据2</td></tr>
  163.         //</tbody>
  164.         //</table>
  165.     }
  166. }
复制代码
9. 小节

本章使用flexmark将markdown内容转换为html内容, 并介绍了其高级的配置功能和使用jsoup完善html结构,最后封装链式调用的工具类和对应的单元测试代码, 能够方便的将各种形式的markdown内容转换为html内容, 下一章将介绍将html转换为word内容
10. 源码

测试过程中的代码已全部上传至github, 欢迎点赞收藏 仓库地址: https://github.com/ludangxin/markdown2html

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！
markdownword第一步html

使用道具 举报

相关推荐
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册
发帖
梢疠
昨天 20:40

0

粉丝关注

19

主题发布

板块介绍填写区域，请于后台编辑
微信扫一扫