实现基于注解和反射的循环依赖检测框架

题目

实现基于注解和反射的循环依赖检测框架

信息

• 类型：问答
• 难度：⭐⭐⭐

考点

自定义注解设计, 反射动态解析, 循环依赖检测算法, 类加载机制, 注解处理器

快速回答

实现步骤：

1. 定义@Inject注解标记依赖字段
2. 通过反射扫描类成员获取依赖关系
3. 构建有向图表示依赖关系
4. 使用拓扑排序检测循环依赖
5. 实现依赖注入和异常处理

核心挑战：

• 处理泛型类型和接口依赖
• 避免类加载导致的性能问题
• 正确识别构造器注入和字段注入

问题背景

在依赖注入框架中，循环依赖（如A→B→A）会导致栈溢出或空指针异常。本题目要求通过反射和注解实现轻量级循环依赖检测机制。

实现方案

1. 定义注解

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface Inject {}

2. 依赖关系解析

public Map<Class<?>, List<Class<?>>> resolveDependencies(Class<?> startClass) {
    Map<Class<?>, List<Class<?>>> graph = new HashMap<>();
    Queue<Class<?>> queue = new LinkedList<>();
    queue.add(startClass);

    while (!queue.isEmpty()) {
        Class<?> clazz = queue.poll();
        for (Field field : clazz.getDeclaredFields()) {
            if (field.isAnnotationPresent(Inject.class)) {
                Class<?> dependency = field.getType();
                graph.computeIfAbsent(clazz, k -> new ArrayList<>()).add(dependency);
                if (!graph.containsKey(dependency)) {
                    queue.add(dependency);
                }
            }
        }
    }
    return graph;
}

3. 循环依赖检测（拓扑排序）

public boolean hasCycle(Map<Class<?>, List<Class<?>>> graph) {
    Map<Class<?>, Integer> indegree = new HashMap<>();
    for (Class<?> node : graph.keySet()) {
        indegree.putIfAbsent(node, 0);
        for (Class<?> neighbor : graph.get(node)) {
            indegree.put(neighbor, indegree.getOrDefault(neighbor, 0) + 1);
        }
    }

    Queue<Class<?>> queue = new LinkedList<>();
    for (Map.Entry<Class<?>, Integer> entry : indegree.entrySet()) {
        if (entry.getValue() == 0) queue.add(entry.getKey());
    }

    int count = 0;
    while (!queue.isEmpty()) {
        Class<?> node = queue.poll();
        count++;
        if (graph.containsKey(node)) {
            for (Class<?> neighbor : graph.get(node)) {
                indegree.put(neighbor, indegree.get(neighbor) - 1);
                if (indegree.get(neighbor) == 0) queue.add(neighbor);
            }
        }
    }
    return count != indegree.size();
}

关键挑战与解决方案

最佳实践

• 懒加载机制：使用Supplier<?>延迟实例化
• 异常处理：抛出DependencyCycleException包含循环路径
• 作用域控制：结合@Scope注解管理生命周期
• 编译期检测：通过APT(Annotation Processing Tool)提前发现循环依赖

常见错误

// 错误示例：未处理自环
class UserService {
    @Inject
    UserService self;  // 导致自循环依赖
}

// 错误示例：忽略父类字段
Field[] fields = clazz.getDeclaredFields();  // 应改为 clazz.getFields()

扩展知识

• Spring的处理机制：三级缓存（singletonFactories/earlySingletonObjects/singletonObjects）
• JSR-330标准：@Inject与Provider<T>配合解决循环依赖
• 字节码增强方案：使用ASM/CGLIB生成无循环依赖的代理类
• JVM限制：反射调用次数超过阈值（默认15）会抛出InaccessibleObjectException