Java硬编码字符串重复检测及架构测试的测试框架咨询

Awesome question! Let’s break down how to address both your needs—detecting hardcoded strings that duplicate constants, and enforcing architecture rules around constant usage across packages.

1. Detecting Hardcoded Strings That Match Defined Constants #

This requires static code analysis to parse your Java source’s Abstract Syntax Tree (AST), identify hardcoded strings in local/instance variables, and compare them against existing constants. Here are your best options:

ArchUnit + JavaParser (Flexible Combo) #

ArchUnit is great for architecture checks, and pairing it with JavaParser lets you dig into AST details for string matching:

• First, use ArchUnit to pull in all classes from your target packages/directories
• For each class, use JavaParser to generate its AST, then scan for variable initializations with hardcoded strings
• Extract those string values, then cross-check against static final constants in the class or specified packages
• Quick example snippet to get you started:

// Import target classes with ArchUnit
JavaClasses targetClasses = new ClassFileImporter().importPackages("com.your.target.package");

for (JavaClass clazz : targetClasses) {
    // Parse the source file with JavaParser (you'll need to map class to source path)
    CompilationUnit ast = StaticJavaParser.parse(new File(clazz.getSourceLocation().getPath()));
    
    // Look for variable initializers with hardcoded strings
    ast.findAll(VariableDeclarator.class).forEach(var -> {
        var.getInitializer().ifPresent(init -> {
            if (init instanceof StringLiteralExpr) {
                String hardcodedStr = ((StringLiteralExpr) init).getValue();
                // Collect all constant values from the class
                Set<String> constantValues = clazz.getFields().stream()
                    .filter(field -> field.isStatic() && field.isFinal())
                    .map(field -> field.getConstantValue())
                    .filter(Objects::nonNull)
                    .map(Object::toString)
                    .collect(Collectors.toSet());
                
                if (constantValues.contains(hardcodedStr)) {
                    Assert.fail(String.format("Hardcoded string '%s' in %s duplicates a class constant", 
                                              hardcodedStr, clazz.getName()));
                }
            }
        });
    });
}

Custom PMD Rules #

PMD has a robust custom rule system. You can write a rule that:

• Traverses the AST to find string literals
• Collects constant values from the current class
• Flags any matches between hardcoded strings and constants
• This integrates nicely into CI pipelines for automated scans

Custom Checkstyle Checks #

Similar to PMD, Checkstyle lets you build custom checks by extending AbstractCheck. You’ll parse the AST to spot hardcoded strings and compare them against constants, then report violations.

2. Architecture Test: Restrict Constant Usage Across Packages #

This is where ArchUnit shines—it’s built explicitly for these kinds of architectural guardrails, with zero complex AST parsing needed.

ArchUnit Rule Example #

Here’s a simple, readable rule that blocks a restricted package from using constants from another package:

@ArchTest
static final ArchRule block_constant_cross_package_usage = noClasses()
    .that().resideInAPackage("com.your.restricted.package..")
    .should().accessFieldsThat()
        .areStatic()
        .areFinal()
        .and().resideInAPackage("com.your.constants.package..")
    .because("Constants from com.your.constants.package are not allowed in restricted packages");

• This rule scans all classes in the restricted package and fails if any of them access static final fields (constants) from the constants package
• You can tweak it to be more granular—for example, only block specific constant classes, or allow certain exceptions

Final Recommendations #

• For both string duplication checks and architecture rules: Go with ArchUnit + JavaParser. ArchUnit handles the high-level architecture stuff, while JavaParser lets you dive into the AST details for string matching.
• For just architecture rules: ArchUnit is your best bet—its syntax is clean, it integrates with JUnit, and it’s easy to maintain.
• For CI-friendly static scans: PMD or Checkstyle are great options for automated checks that run alongside your build.

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