如何查找所有静态导入的类与值？（仅用于报表生成工具）

静态导入的符号在编译后会被直接替换为对应的全限定名引用，ClassLoader在运行时完全保留这些导入信息。要为报表生成工具收集静态导入的值，只能从源代码分析或编译期字节码处理入手，以下是几种可行方案：

方案1：Groovy AST转换（编译期收集） #

利用Groovy的AST转换能力，在编译阶段直接扫描源代码中的静态导入声明，收集所需信息。

实现代码 #

package org.example.reporting

import org.codehaus.groovy.ast.ASTNode
import org.codehaus.groovy.ast.ImportNode
import org.codehaus.groovy.control.CompilePhase
import org.codehaus.groovy.control.SourceUnit
import org.codehaus.groovy.transform.ASTTransformation
import org.codehaus.groovy.transform.GroovyASTTransformation

@GroovyASTTransformation(phase = CompilePhase.SEMANTIC_ANALYSIS)
class StaticImportCollector implements ASTTransformation {

    @Override
    void visit(ASTNode[] nodes, SourceUnit sourceUnit) {
        // 筛选所有静态导入节点
        def staticImports = sourceUnit.imports.findAll { ImportNode node ->
            node.staticImport
        }

        // 收集并输出（可替换为写入报表逻辑）
        staticImports.each { importNode ->
            def importedClass = importNode.type.name
            def importedMember = importNode.fieldName ?: importNode.methodName
            println "静态导入: ${importedClass}.${importedMember} (来源文件: ${sourceUnit.name})"
        }
    }
}

使用方式 #

在需要分析的Groovy文件顶部添加注解启用转换：

@ASTTest(phase = SEMANTIC_ANALYSIS, value = { new org.example.reporting.StaticImportCollector().visit(ast, sourceUnit) })
package org.example

// 原业务代码...

方案2：Groovy Compiler API解析源代码 #

直接通过Groovy Compiler API加载源代码，解析语法树后提取静态导入信息。

import org.codehaus.groovy.control.CompilerConfiguration
import org.codehaus.groovy.control.SourceUnit
import org.codehaus.groovy.tools.javac.JavaAwareCompilationUnit

// 初始化编译配置
def config = new CompilerConfiguration()
def compilationUnit = new JavaAwareCompilationUnit(config)

// 添加要分析的源文件
compilationUnit.addSource("MyService.groovy", new File("MyService.groovy").text)
compilationUnit.compile()

// 遍历源单元收集静态导入
compilationUnit.sourceUnits.each { SourceUnit su ->
    def staticImports = su.imports.findAll { it.staticImport }
    staticImports.each { importNode ->
        println "找到静态导入: ${importNode.type.name}.${importNode.fieldName}"
    }
}

方案3：字节码分析（ASM库） #

如果只有编译后的class文件，可通过ASM库扫描字节码中的常量引用，反向推断静态导入的成员（需结合源代码文件匹配验证）。

核心代码片段 #

import org.objectweb.asm.ClassReader;
import org.objectweb.asm.tree.ClassNode;
import org.objectweb.asm.tree.FieldInsnNode;

import java.io.FileInputStream;
import java.io.IOException;

public class StaticImportAnalyzer {
    public static void analyzeClassFile(String classFilePath) throws IOException {
        try (FileInputStream fis = new FileInputStream(classFilePath)) {
            ClassReader cr = new ClassReader(fis);
            ClassNode cn = new ClassNode();
            cr.accept(cn, ClassReader.SKIP_DEBUG);

            // 遍历方法指令，查找枚举常量引用
            cn.methods.forEach(method -> {
                method.instructions.forEach(instruction -> {
                    if (instruction.getOpcode() == org.objectweb.asm.Opcodes.GETSTATIC) {
                        FieldInsnNode fieldInsn = (FieldInsnNode) instruction;
                        if (fieldInsn.owner.endsWith("MyTestEnum")) {
                            System.out.println("引用的枚举常量: " + fieldInsn.owner + "." + fieldInsn.name);
                        }
                    }
                });
            });
        }
    }

    public static void main(String[] args) throws IOException {
        analyzeClassFile("target/classes/org/example/MyService.class");
    }
}

关键说明 #

ClassLoader无法获取静态导入信息的本质是：Groovy编译时会将静态导入的符号直接替换为全限定名引用，运行时已不存在"静态导入"这一层抽象，因此必须在编译阶段或源代码层面做收集。

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