Java正则表达式开发专家

需求分析

• 订单号固定格式：ORD-YYYYMMDD-XXXXXX
• 约束：
  • 前缀固定为 "ORD"
  • 日期为8位数字（仅格式校验，不在正则内做“真实日历”合法性判断）
  • 尾段为6位仅包含大写字母与数字，且至少包含2个大写字母
• 需要分组提取：日期（YYYYMMDD）与尾段（XXXXXX）
• 提供：正则、示例校验方法、边界与批量测试样例
• 匹配目标（格式上均应匹配）：
  • ORD-20251206-AB12X9
  • ORD-20241130-1A2B3C
  • ORD-20240230-ABC123（注意：日期格式正确，但不是实际存在的日期，需在业务层面做额外的日历校验）

正则表达式

• Java 正则（含命名分组，便于可读性与维护）：

^ORD-(?<date>[0-9]{8})-(?<tail>(?=(?:.*[A-Z]){2,})[A-Z0-9]{6})$

• 解释：
  • ^ORD-：固定前缀
  • (?[0-9]{8})：命名分组 date，8位数字日期（仅格式）
  • -：连字符
  • (?...): 命名分组 tail，尾段6位
    • (?=(?:.*[A-Z]){2,})：正向前瞻，确保接下来的6位中至少出现2个大写字母
    • [A-Z0-9]{6}：6位仅限大写字母或数字
  • $：整串匹配结束
• 选择该写法的原因：
  • 用前瞻在“保持精确长度为6”的同时检查“至少两个大写字母”，避免把长度判断写复杂
  • 全串锚定（^...$）避免子串误匹配
  • 命名分组提升可读性（Java可通过 group("date")/group("tail") 获取）

Java代码实现

import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.time.format.ResolverStyle;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public final class OrderIdValidator {
    // 编译后的正则，建议长期复用，避免重复编译带来的开销
    private static final Pattern ORDER_ID_PATTERN = Pattern.compile(
            "^ORD-(?<date>[0-9]{8})-(?<tail>(?=(?:.*[A-Z]){2,})[A-Z0-9]{6})$"
    );

    // 严格日期解析器：用于“业务层面”的真实日期合法性校验（非正则内完成）
    private static final DateTimeFormatter DATE_FMT_STRICT =
            DateTimeFormatter.ofPattern("uuuuMMdd").withResolverStyle(ResolverStyle.STRICT);

    private OrderIdValidator() {}

    // 仅做格式校验（正则），不验证日期真伪
    public static boolean isFormatValid(String orderId) {
        if (orderId == null) return false;
        return ORDER_ID_PATTERN.matcher(orderId).matches();
    }

    // 同时做格式校验与真实日期校验（严格）
    public static boolean isStrictValid(String orderId) {
        Optional<OrderParts> partsOpt = parse(orderId);
        if (!partsOpt.isPresent()) return false;
        return isRealDate(partsOpt.get().getDate());
    }

    // 分组提取（成功则返回日期与尾段）；仅在格式匹配时返回
    public static Optional<OrderParts> parse(String orderId) {
        if (orderId == null) return Optional.empty();
        Matcher m = ORDER_ID_PATTERN.matcher(orderId);
        if (!m.matches()) return Optional.empty();

        String date = m.group("date");
        String tail = m.group("tail");
        return Optional.of(new OrderParts(orderId, date, tail));
    }

    // 业务层面：严格日期校验（yyyyMMdd必须为真实日期）
    public static boolean isRealDate(String yyyyMMdd) {
        try {
            LocalDate.parse(yyyyMMdd, DATE_FMT_STRICT);
            return true;
        } catch (Exception e) {
            return false;
        }
    }

    // 示例：批量校验并打印结果
    public static void main(String[] args) {
        List<String> samples = new ArrayList<>();
        // 题中样例（格式应匹配）
        samples.add("ORD-20251206-AB12X9");
        samples.add("ORD-20241130-1A2B3C");
        samples.add("ORD-20240230-ABC123"); // 非真实日期

        // 边界/对照样例
        samples.add("ORD-20251206-A12345"); // 尾段仅1个字母 -> 格式应失败
        samples.add("ORD-20251206-123456"); // 尾段0个字母 -> 格式应失败
        samples.add("ORD-20251206-AB12x9"); // 含小写x -> 格式应失败
        samples.add("ORD-20251206-AB12X9X"); // 尾段长度7 -> 格式应失败
        samples.add("ORD-2025120-AB12X9");  // 日期7位 -> 格式应失败
        samples.add("ORD-20251306-AB12X9"); // 13月（格式匹配，但真实日期失败）
        samples.add("XXX-20251206-AB12X9"); // 前缀错误 -> 格式应失败
        samples.add("ORD-abcdefgh-ABC123"); // 日期非数字 -> 格式应失败
        samples.add("ORD-20251206-AB12X@"); // 非法字符@ -> 格式应失败
        samples.add("ORD-20251206-AAAAAA"); // 6字母 -> 格式应通过，真实日期也通过

        for (String s : samples) {
            boolean formatOk = isFormatValid(s);
            Optional<OrderParts> parts = parse(s);
            boolean realDateOk = parts.map(p -> isRealDate(p.getDate())).orElse(false);

            System.out.printf(
                "%-25s | format=%-5s | date=%-8s | tail=%-6s | realDate=%-5s%n",
                s,
                formatOk,
                parts.map(OrderParts::getDate).orElse("-"),
                parts.map(OrderParts::getTail).orElse("-"),
                realDateOk
            );
        }
    }

    // 简单数据承载类
    public static final class OrderParts {
        private final String original;
        private final String date; // yyyyMMdd
        private final String tail; // 6位大写字母/数字（至少2个字母）

        public OrderParts(String original, String date, String tail) {
            this.original = original;
            this.date = date;
            this.tail = tail;
        }
        public String getOriginal() { return original; }
        public String getDate() { return date; }
        public String getTail() { return tail; }
        @Override public String toString() {
            return "OrderParts{date=" + date + ", tail=" + tail + "}";
        }
    }
}

使用说明

• 仅需格式校验时（不关心日期真伪）：调用 isFormatValid(orderId) 或 parse(orderId) 提取分组。
• 需要严格校验真实日期时：调用 isStrictValid(orderId)（内部先匹配正则，再用 LocalDate 严格解析）。
• 获取分组：
  • 命名分组 date：YYYYMMDD（字符串）
  • 命名分组 tail：尾段6位（大写字母与数字，至少2字母）
• 性能建议：将 Pattern 静态编译并复用；避免每次用 Pattern.matches 触发隐式重编译。

测试示例（期望结论）

• 应匹配（格式）：
  • ORD-20251206-AB12X9 → format=true，realDate=true
  • ORD-20241130-1A2B3C → format=true，realDate=true
  • ORD-20240230-ABC123 → format=true，realDate=false（2月30日不存在）
• 不应匹配（格式）：
  • ORD-20251206-A12345 → 尾段字母仅1个
  • ORD-20251206-123456 → 尾段无字母
  • ORD-20251206-AB12x9 → 含小写
  • ORD-20251206-AB12X9X → 尾段长度错误
  • ORD-2025120-AB12X9 → 日期长度错误
  • XXX-20251206-AB12X9 → 前缀错误
  • ORD-abcdefgh-ABC123 → 日期非数字
  • ORD-20251206-AB12X@ → 非法字符
• 格式匹配但真实日期失败（若启用严格校验）：
  • ORD-20240230-ABC123
  • ORD-20251306-AB12X9

最佳实践

• 使用全串锚定 ^...$，避免子串误匹配。
• 采用命名分组（? ...）、（? ...）提高可读性。
• 将“真实日期合法性”从正则中剥离，使用 LocalDate 严格解析，既保证表达式简洁，又提升可维护性。
• 复用已编译的 Pattern，避免重复编译带来的性能损耗。
• 明确大小写规则：尾段仅允许 [A-Z0-9]，不要使用 CASE_INSENSITIVE 以免误接纳小写。
• 输入为外部来源时，注意做空值检查与长度上限限制（本例已通过正则与 null 判断覆盖）。

需求分析

• 目标：从 Markdown 文本中提取普通超链接的文本与 URL，忽略图片语法 ![...](...) 与反引号包裹的代码片段（包括行内 ... 与围栏 ...）。
• 约束：
  • 仅匹配 http|https|ftp 三类 URL。
  • 链接文本允许包含空格与转义字符（如 \]）。
  • 返回两分组：(text, url)。
  • 忽略代码中的“伪链接”，也忽略图片语法。
• 难点与边界：
  • Markdown 链接形式：text，需仅捕获 url，不包含可选的 title。
  • URL 可能包含成对圆括号，如 .../a(b)c，需避免在第一个 ) 处提早结束。
  • 图片 ![...] 与普通链接 [...] 的区分。
  • 反引号代码片段的屏蔽（不参与匹配）。

为保证可维护性与性能，采用“两阶段策略”：

1. 先用正则屏蔽代码片段（替换为空格，不改变索引长度）。
2. 再用专门的链接正则提取匹配。

正则表达式

主匹配（提取普通超链接，忽略图片）：

• Java 字符串常量形式（用于 Pattern.compile）：

(?<!!)\[((?:\\.|[^\[\]\n])+?)\]\(\s*((?:https?|ftp)://[^\s)]+(?:\([^ \s)]*\)[^\s)]*)*)\s*(?:\s+(?:"[^"]*"|'[^']*'|\([^)]*\)))?\s*\)

• 各部分说明：
  • (?<!!)：负向前瞻，确保 [ 前一字符不是 !（排除图片 ![...](...)）。
  • \[((?:\\.|[^\[\]\n])+?)\]：捕获链接文本（第1组）。
    • (?:\\.|[^\[\]\n])+? 允许转义字符（如 \]）与除 [] 和换行外的任意字符，惰性匹配。
  • \( 与 \)：包裹 URL（及可选 title）。
  • \s*((?:https?|ftp)://[^\s)]+(?:\([^ \s)]*\)[^\s)]*)*)\s*：捕获 URL（第2组）。
    • 仅允许 http|https|ftp。
    • [^ \s)]+(?:\([^ \s)]*\)[^\s)]*)* 允许 URL 中出现成对的圆括号，不被外层 ) 提前截断。
  • (?:\s+(?:"[^"]*"|'[^']*'|\([^)]*\)))?：可选的 title（不计入 URL 捕获）。
  • 结尾 \s*\)：关闭链接的 )。

代码片段屏蔽（两类）：

• 围栏代码块：``` ... ```（跨行）
  • `(?s)```.*?````
• 行内代码：`[^`]*`

Java代码实现

import java.util.*;
import java.util.regex.*;

/**
 * 从 Markdown 文本中提取普通超链接 (text, url)，忽略图片和反引号代码片段。
 */
public class MarkdownLinkExtractor {

    // 1) 屏蔽代码片段的正则
    private static final Pattern CODE_FENCE = Pattern.compile("(?s)```.*?```"); // 跨行围栏代码块
    private static final Pattern CODE_INLINE = Pattern.compile("`[^`]*`");     // 行内代码

    // 2) 提取普通链接的正则（两组：1=text, 2=url）
    private static final String LINK_REGEX =
            "(?<!!)\\[((?:\\\\.|[^\\[\\]\\n])+?)\\]\\(\\s*((?:https?|ftp)://[^\\s)]+(?:\\([^\\s)]*\\)[^\\s)]*)*)\\s*(?:\\s+(?:\"[^\"]*\"|'[^']*'|\\([^)]*\\)))?\\s*\\)";
    private static final Pattern LINK_PATTERN = Pattern.compile(LINK_REGEX);

    // 3) 反转义链接文本中的常见转义（如 \], \[, \(, \), \\）
    private static final Pattern LINK_TEXT_ESCAPES = Pattern.compile("\\\\([\\\\\\[\\]\\(\\)])");

    public static class Link {
        public final String text;
        public final String url;
        public Link(String text, String url) { this.text = text; this.url = url; }
        @Override public String toString() { return "(" + text + ", " + url + ")"; }
    }

    /**
     * 提取 Markdown 普通链接 (text, url)，忽略图片与反引号代码。
     */
    public static List<Link> extractMarkdownLinks(String markdown) {
        if (markdown == null || markdown.isEmpty()) return Collections.emptyList();

        // 第一步：屏蔽代码片段（替换为空格，保持长度不变，避免打乱后续匹配的索引）
        String masked = maskBySpaces(markdown, CODE_FENCE);
        masked = maskBySpaces(masked, CODE_INLINE);

        // 第二步：在屏蔽后的文本中查找普通链接
        List<Link> result = new ArrayList<>();
        Matcher m = LINK_PATTERN.matcher(masked);
        while (m.find()) {
            String rawText = m.group(1);
            String url = m.group(2);

            // 反转义链接文本中的常见转义序列
            String text = unescapeLinkText(rawText);

            result.add(new Link(text, url));
        }
        return result;
    }

    // 用空格覆盖匹配到的区间（不改变字符串长度）
    private static String maskBySpaces(String input, Pattern p) {
        Matcher m = p.matcher(input);
        StringBuilder sb = new StringBuilder(input);
        while (m.find()) {
            for (int i = m.start(); i < m.end(); i++) {
                sb.setCharAt(i, ' ');
            }
        }
        return sb.toString();
    }

    // 将 \[, \], \(, \), \\ 反转义为本体
    private static String unescapeLinkText(String s) {
        return LINK_TEXT_ESCAPES.matcher(s).replaceAll("$1");
    }

    // Demo
    public static void main(String[] args) {
        String md = ""
                + "这是正文 [接口文档](https://docs.example.org/v1/api) 与 [下载](ftp://files.example.org/a.zip)。\n"
                + "![图](https://img.example.org/i.png) `代码含 [假链](http://x)`\n";

        List<Link> links = extractMarkdownLinks(md);
        for (Link link : links) {
            System.out.println(link);
        }
    }
}

使用说明

• 将上述类保存并运行，输出为所提取的 (text, url) 列表。
• 适用于一般 Markdown 文本：
  • 自动屏蔽行内反引号代码 ... 与围栏代码 ...
  • 忽略图片 ![alt](url)
  • 仅提取 http|https|ftp 链接
  • 支持 URL 中的成对括号
  • 支持链接文本中的常见反斜杠转义
• 注意：
  • 该实现不尝试完整解析 Markdown 所有边界（如极端嵌套或罕见语法组合）。如果需要 100% 完整规范支持，建议使用专业 Markdown 解析器后再筛选链接节点。

测试示例

输入（包含题目给定用例）：

1. 基本与忽略规则

• 文本：
  • 这是正文 接口文档 与 下载。
  • 代码含 [假链](http://x)
• 预期输出：
  • (接口文档, https://docs.example.org/v1/api)
  • (下载, ftp://files.example.org/a.zip)

2. 含 title 的链接（title 不应进入 url）

• 文本：请看 站点。
• 预期：
  • (站点, https://example.com)

3. URL 含括号

• 文本：参考 文档。
• 预期：
  • (文档, https://example.com/a(b)c?d=e(f)g)

4. 行内代码忽略

• 文本：代码里的 [假链](https://no.example) 与 真链。
• 预期：
  • (真链, https://ok.example)

5. 围栏代码忽略

• 文本：

  ```js
  // [假链](https://no.example)
  

  外面有 真链

• 预期：
  • (真链, https://ok.example)

6. 链接文本转义

• 文本：有]括号
• 预期：
  • (有]括号, https://x.example/path)

7. 非允许协议不匹配

• 文本：邮件
• 预期：无匹配

最佳实践

• 性能与可维护性：
  • 先屏蔽代码片段，再匹配链接，避免复杂且脆弱的“单正则”解决方案，降低回溯风险。
  • 将 Pattern 预编译为静态常量，避免重复编译开销。
  • URL 子模式采用“允许括号配对的常见写法”：
    • [^\\s)]+(?:\\([^\\s)]*\\)[^\\s)]*)*，在大多数实际 URL 中表现稳定。
• 可靠性：
  • 如需更完整的 Markdown 支持（嵌套、中括号内复杂结构、引用式链接等），建议用专业 Markdown 解析库（如 flexmark-java）构建 AST 再抽取节点。
• 国际化与编码：
  • Java 字符串与 Pattern 默认支持 Unicode；如涉及更复杂的 Unicode 分类，可启用相应的 Unicode 特性或在字符类中显式列举。
• 安全：
  • 在使用提取到的 URL 前，应按业务需求进行协议白名单验证（此处已限定为 http/https/ftp），并做好后续网络访问的安全校验。