Java中如何实现自定义字段名对象构建及编译时静态检查？

要实现直接通过字段访问正则命名捕获组结果、且编译时校验字段合法性的需求，同时避免手动编写子类的繁琐，以下是几种简洁可行的方案：

方案1：Lambda绑定的类型安全捕获（无需代码生成） #

利用Java的Lambda表达式和方法引用，将捕获结果直接绑定到变量，编译时即可校验变量名称的正确性，彻底避免运行时拼写错误。

实现代码 #

import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class SafeRegex {
    private final List<Consumer<String>> captureHandlers = new ArrayList<>();
    private final StringBuilder patternBuilder = new StringBuilder();

    // 初始化第一个捕获组
    public static SafeRegex capture(String regex, Consumer<String> resultHandler) {
        SafeRegex instance = new SafeRegex();
        instance.patternBuilder.append(regex);
        instance.captureHandlers.add(resultHandler);
        return instance;
    }

    // 添加字面量匹配
    public SafeRegex literal(String text) {
        patternBuilder.append(Pattern.quote(text));
        return this;
    }

    // 添加后续捕获组
    public SafeRegex captureNext(String regex, Consumer<String> resultHandler) {
        patternBuilder.append(regex);
        captureHandlers.add(resultHandler);
        return this;
    }

    // 执行匹配并绑定结果
    public void match(String input) {
        Pattern pattern = Pattern.compile(patternBuilder.toString());
        Matcher matcher = pattern.matcher(input);
        
        if (!matcher.find()) {
            throw new IllegalArgumentException("输入字符串不匹配正则规则");
        }

        // 按顺序将捕获结果传递给绑定的处理器
        for (int i = 0; i < captureHandlers.size(); i++) {
            captureHandlers.get(i).accept(matcher.group(i + 1));
        }
    }
}

使用示例 #

import java.util.concurrent.atomic.AtomicReference;

public class Main {
    public static void main(String[] args) {
        AtomicReference<String> left = new AtomicReference<>();
        AtomicReference<String> right = new AtomicReference<>();

        new SafeRegex()
            .capture("\\d+", left::set)
            .literal(" + ")
            .captureNext("\\d+", right::set)
            .match("12 + 5");

        assert Integer.parseInt(left.get()) == 12;
        // 若误写为lft::set，编译阶段直接报错，无运行时风险
    }
}

方案2：注解驱动的编译时代码生成 #

通过自定义注解和注解处理器，在编译阶段根据正则表达式自动生成包含对应字段的结果类，完全实现编译时字段校验，体验最接近需求描述的理想形态。

步骤1：定义注解 #

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.SOURCE)
@Target(ElementType.TYPE)
public @interface RegexPattern {
    String value(); // 传入带命名捕获组的正则表达式
}

步骤2：编写注解处理器（核心逻辑） #

注解处理器会解析@RegexPattern中的正则表达式，提取命名捕获组，自动生成包含对应字段的结果类和匹配方法。核心逻辑示例：

// 注解处理器简化示例（需继承AbstractProcessor实现完整逻辑）
public class RegexProcessor extends AbstractProcessor {
    @Override
    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
        for (TypeElement annotation : annotations) {
            Set<? extends Element> elements = roundEnv.getElementsAnnotatedWith(annotation);
            for (Element element : elements) {
                RegexPattern regexAnn = element.getAnnotation(RegexPattern.class);
                String patternStr = regexAnn.value();
                
                // 解析正则中的命名捕获组（需实现正则解析逻辑）
                List<String> groupNames = extractNamedGroups(patternStr);
                
                // 生成结果类的Java代码
                generateResultClass(element.getSimpleName().toString(), groupNames, patternStr);
            }
        }
        return true;
    }

    // 生成结果类代码的逻辑
    private void generateResultClass(String baseName, List<String> groupNames, String patternStr) {
        String className = baseName + "Result";
        StringBuilder code = new StringBuilder();
        code.append("public class ").append(className).append(" {\n");
        
        // 生成public字段
        for (String name : groupNames) {
            code.append("    public final String ").append(name).append(";\n");
        }
        
        // 生成构造方法
        code.append("    private ").append(className).append("(");
        for (int i = 0; i < groupNames.size(); i++) {
            if (i > 0) code.append(", ");
            code.append("String ").append(groupNames.get(i));
        }
        code.append(") {\n");
        for (String name : groupNames) {
            code.append("        this.").append(name).append(" = ").append(name).append(";\n");
        }
        code.append("    }\n");
        
        // 生成静态匹配方法
        code.append("    public static ").append(className).append(" match(String input) {\n");
        code.append("        java.util.regex.Pattern pattern = java.util.regex.Pattern.compile(\"")
            .append(patternStr.replace("\\", "\\\\"))
            .append("\");\n");
        code.append("        java.util.regex.Matcher matcher = pattern.matcher(input);\n");
        code.append("        if (matcher.find()) {\n");
        code.append("            return new ").append(className).append("(");
        for (int i = 0; i < groupNames.size(); i++) {
            if (i > 0) code.append(", ");
            code.append("matcher.group(\"").append(groupNames.get(i)).append("\")");
        }
        code.append(");\n");
        code.append("        }\n");
        code.append("        throw new IllegalArgumentException(\"无匹配结果\");\n");
        code.append("    }\n");
        code.append("}\n");
        
        // 将代码写入文件（需使用Filer API实现）
        writeClassFile(className, code.toString());
    }
}

步骤3：使用注解生成结果类 #

@RegexPattern("(?<left>\\d+) + (?<right>\\d+)")
public interface SumMatcher {}

编译后会自动生成SumMatcherResult类，使用方式：

public class Main {
    public static void main(String[] args) {
        SumMatcherResult result = SumMatcherResult.match("12 + 5");
        assert Integer.parseInt(result.left) == 12;
        // 若误写result.lft，编译直接报错
    }
}

方案3：Record + 编译时代码生成（Java 16+） #

结合Java 16引入的Record特性（不可变数据类），通过编译时工具生成对应Record类，兼顾简洁性和类型安全。

生成的Record类示例 #

public record SumResult(String left, String right) {
    public static SumResult match(String input) {
        java.util.regex.Pattern pattern = java.util.regex.Pattern.compile("(?<left>\\d+) + (?<right>\\d+)");
        java.util.regex.Matcher matcher = pattern.matcher(input);
        if (matcher.find()) {
            return new SumResult(matcher.group("left"), matcher.group("right"));
        }
        throw new IllegalArgumentException("无匹配结果");
    }
}

使用方式 #

SumResult result = SumResult.match("12 + 5");
assert Integer.parseInt(result.left()) == 12;
// 拼写错误会直接触发编译失败

方案对比 #

内容的提问来源于stack exchange，提问作者user3310334