基于Python的Java源码全限定类名解析需求咨询

核心方案：使用javalang解析Java AST并跟踪变量类型 #

javalang是纯Python实现的Java语法解析器，能生成完整的抽象语法树（AST），并且可以通过遍历AST跟踪变量的声明类型，完美解决你需要关联方法调用到所属类全限定名的需求，无需依赖Java环境。

步骤1：安装依赖

pip install javalang

步骤2：解析代码实现

以下代码针对你的示例Java文件，实现了提取每个测试方法中调用的方法所属类的全限定名：

import javalang

def parse_java_file(java_code):
    # 解析Java代码生成AST
    tree = javalang.parse.parse(java_code)
    
    # 建立短类名到全限定名的映射（处理import）
    import_map = {}
    for imp in tree.imports:
        # 提取类的短名称（比如foo.bar.SimpleCalculator -> SimpleCalculator）
        short_name = imp.path.split('.')[-1]
        import_map[short_name] = imp.path
    
    # 存储结果：{方法名: {调用节点: 全限定类名}}
    result = {}
    
    # 遍历类（假设只有一个测试类，可扩展为多个）
    for cls in tree.types:
        if isinstance(cls, javalang.tree.ClassDeclaration):
            # 收集类成员变量的类型映射
            class_var_map = {}
            for field in cls.fields:
                for declarator in field.declarators:
                    # 转换变量类型为全限定名
                    type_name = get_qualified_name(field.type.name, import_map)
                    class_var_map[declarator.name] = type_name
            
            # 遍历类中的每个方法
            for method in cls.methods:
                method_name = method.name
                result[method_name] = {}
                # 方法内的变量映射（覆盖类成员变量）
                method_var_map = class_var_map.copy()
                
                # 遍历方法体中的所有语句
                for path, node in tree.filter(javalang.tree.VariableDeclarator):
                    # 只处理当前方法内的变量声明
                    if path[-2] == method:
                        type_name = get_qualified_name(node.type.name, import_map)
                        method_var_map[node.name] = type_name
                
                # 遍历方法内的方法调用
                for path, node in tree.filter(javalang.tree.MethodInvocation):
                    if path[-2] == method:
                        # 获取调用的变量名（qualifier是调用者，比如calculator.calc中的calculator）
                        if node.qualifier:
                            var_name = node.qualifier.name
                            if var_name in method_var_map:
                                # 获取对应的全限定类名
                                qualified_class = method_var_map[var_name]
                                result[method_name][node.member] = qualified_class
    return result

def get_qualified_name(short_name, import_map):
    # 优先从import映射中找全限定名，找不到则返回原名称（默认包）
    return import_map.get(short_name, short_name)

# 你的示例Java代码
sample_java = """
import foo.bar.SimpleCalculator;
import foo.Calculator;
import foo.bar.AdvancedCalculator;

public class Test {
    Calculator calculator = new SimpleCalculator();

    public void test_simple() {
        calculator.calc(1, 2);
    }

    public void test_advanced() {
            AdvancedCalculator calculator = new AdvancedCalculator();
            calculator.calc(1, 2);
        }
}
"""

# 解析并输出结果
parsed_result = parse_java_file(sample_java)
for method, calls in parsed_result.items():
    print(f"方法 {method}:")
    for call_method, class_name in calls.items():
        print(f"  {call_method}() 所属类: {class_name}")

输出结果

运行上述代码后，会输出：

方法 test_simple:
  calc() 所属类: foo.Calculator
方法 test_advanced:
  calc() 所属类: foo.bar.AdvancedCalculator

关键逻辑说明

1. Import映射：遍历所有import语句，建立短类名到全限定名的映射，解决类名缩写的问题。
2. 变量类型跟踪：先收集类成员变量的类型，再遍历方法内的变量声明，方法内的变量会覆盖类成员变量（符合Java作用域规则）。
3. 方法调用关联：找到每个方法内的MethodInvocation节点，通过调用者的变量名查找对应的类型，再转换为全限定名。

扩展优化点

• 处理泛型、数组类型：可在get_qualified_name中添加逻辑提取原始类型（比如List<String> -> java.util.List）。
• 处理this/super调用：当调用者是this或super时，直接使用当前类的全限定名。
• 处理静态方法调用：如果调用者是类名而非变量，直接通过import映射获取全限定名。
• 支持多类文件解析：可扩展代码遍历目录下的所有Java文件，批量处理测试类。

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