学习笔记

主题

2026-07-31

22-DI Container（10）：怎样将大粒度的测试重构为等效的小粒度测试代码？ ​

你好，我是徐昊。今天我们继续使用TDD的方式实现注入依赖容器。

回顾代码与任务列表 ​

到目前为止，我们的代码是这样的：

ContextConfig.java:

package geektime.tdd.di;

import java.util.*;
import static java.util.List.of;

public class ContextConfig {
    private Map<Class<?>, ComponentProvider<?>> providers = new HashMap<>();
    
    public <Type> void bind(Class<Type> type, Type instance) {
        providers.put(type, new ComponentProvider<Type>() {
            @Override
            public Type get(Context context) {
                return instance;
            }
            @Override
            public List<Class<?>> getDependencies() {
                return of();
            }
        });
    }
    
    public <Type, Implementation extends Type>
    void bind(Class<Type> type, Class<Implementation> implementation) {
        providers.put(type, new ConstructorInjectionProvider<>(implementation));
    }
    
    public Context getContext() {
        providers.keySet().forEach(component -> checkDependencies(component, new Stack<>()));
        return new Context() {
            @Override
            public <Type> Optional<Type> get(Class<Type> type) {
                return Optional.ofNullable(providers.get(type)).map(provider -> (Type) provider.get(this));
            }
        };
    }
    
    private void checkDependencies(Class<?> component, Stack<Class<?>> visiting) {
        for (Class<?> dependency: providers.get(component).getDependencies()) {
            if (!providers.containsKey(dependency)) throw new DependencyNotFoundException(component, dependency);
            if (visiting.contains(dependency)) throw new CyclicDependenciesFoundException(visiting);
            visiting.push(dependency);
            checkDependencies(dependency, visiting);
            visiting.pop();
        }
    }
    
    interface ComponentProvider<T> {
        T get(Context context);
        List<Class<?>> getDependencies();
    }
}

ConstructorInjectionProvider.java:

package geektime.tdd.di;

import jakarta.inject.Inject;
import java.lang.reflect.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import static java.util.Arrays.stream;
import static java.util.stream.Stream.concat;

class ConstructorInjectionProvider<T> implements ContextConfig.ComponentProvider<T> {

    private Constructor<T> injectConstructor;
    private List<Field> injectFields;
    private List<Method> injectMethods;
    
    public ConstructorInjectionProvider(Class<T> component) {
        if (Modifier.isAbstract(component.getModifiers())) throw new IllegalComponentException();
        this.injectConstructor = getInjectConstructor(component);
        this.injectFields = getInjectFields(component);
        this.injectMethods = getInjectMethods(component);
        if (injectFields.stream().anyMatch(f -> Modifier.isFinal(f.getModifiers()))) throw new IllegalComponentException();
        if (injectMethods.stream().anyMatch(m -> m.getTypeParameters().length != 0)) throw new IllegalComponentException();
    }

    @Override
    public T get(Context context) {
        try {
            Object[] dependencies = stream(injectConstructor.getParameters())
                    .map(p -> context.get(p.getType()).get())
                    .toArray(Object[]::new);
            T instance = injectConstructor.newInstance(dependencies);
            for (Field field : injectFields)
                field.set(instance, context.get(field.getType()).get());
            for (Method method : injectMethods)
                method.invoke(instance, stream(method.getParameterTypes()).map(t -> context.get(t).get())
                        .toArray(Object[]::new));
            return instance;
        } catch (InvocationTargetException | InstantiationException | IllegalAccessException e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    public List<Class<?>> getDependencies() {
        return concat(concat(stream(injectConstructor.getParameters()).map(Parameter::getType),
                        injectFields.stream().map(Field::getType)),
                injectMethods.stream().flatMap(m -> stream(m.getParameterTypes()))
        ).toList();
    }
    
    private static <T> List<Method> getInjectMethods(Class<T> component) {
        List<Method> injectMethods = new ArrayList<>();
        Class<?> current = component;
        while (current != Object.class) {
            injectMethods.addAll(stream(current.getDeclaredMethods()).filter(m -> m.isAnnotationPresent(Inject.class))
                    .filter(m -> injectMethods.stream().noneMatch(o -> o.getName().equals(m.getName()) &&
                            Arrays.equals(o.getParameterTypes(), m.getParameterTypes())))
                    .filter(m -> stream(component.getDeclaredMethods()).filter(m1 -> !m1.isAnnotationPresent(Inject.class))
                            .noneMatch(o -> o.getName().equals(m.getName()) &&
                                    Arrays.equals(o.getParameterTypes(), m.getParameterTypes())))
                    .toList());
            current = current.getSuperclass();
        }
        Collections.reverse(injectMethods);
        return injectMethods;
    }

    private static <T> List<Field> getInjectFields(Class<T> component) {
        List<Field> injectFields = new ArrayList<>();
        Class<?> current = component;
        while (current != Object.class) {
            injectFields.addAll(stream(current.getDeclaredFields()).filter(f -> f.isAnnotationPresent(Inject.class))
                    .toList());
            current = current.getSuperclass();
        }
        return injectFields;
    }
    
    private static <Type> Constructor<Type> getInjectConstructor(Class<Type> implementation) {
        List<Constructor<?>> injectConstructors = stream(implementation.getConstructors())
                .filter(c -> c.isAnnotationPresent(Inject.class)).collect(Collectors.toList());
        if (injectConstructors.size() > 1) throw new IllegalComponentException();
        return (Constructor<Type>) injectConstructors.stream().findFirst().orElseGet(() -> {
            try {
                return implementation.getDeclaredConstructor();
            } catch (NoSuchMethodException e) {
                throw new IllegalComponentException();
            }
        });
    }
}

Context.java:
package geektime.tdd.di;


import java.util.Optional;


public interface Context {
    <Type> Optional<Type> get(Class<Type> type);
}

任务列表状态为：

  • 无需构造的组件——组件实例

  • 如果注册的组件不可实例化，则抛出异常

    • 抽象类
    • 接口

  • 构造函数注入

    • 无依赖的组件应该通过默认构造函数生成组件实例
    • 有依赖的组件，通过Inject标注的构造函数生成组件实例
    • 如果所依赖的组件也存在依赖，那么需要对所依赖的组件也完成依赖注入
    • 如果组件有多于一个Inject标注的构造函数，则抛出异常
    • 如果组件没有Inject标注的构造函数，也没有默认构造函数（新增任务）
    • 如果组件需要的依赖不存在，则抛出异常
    • 如果组件间存在循环依赖，则抛出异常

  • 字段注入

    • 通过Inject标注将字段声明为依赖组件
    • 如果字段为final则抛出异常
    • 依赖中应包含Inject Field声明的依赖

  • 方法注入

    • 通过Inject标注的方法，其参数为依赖组件
    • 通过Inject标注的无参数方法，会被调用
    • 按照子类中的规则，覆盖父类中的Inject方法
    • 如果方法定义类型参数，则抛出异常
    • 依赖中应包含Inject Method声明的依赖

  • 对Provider类型的依赖

    • 注入构造函数中可以声明对于Provider的依赖
    • 注入字段中可以声明对于Provider的依赖
    • 注入方法中可声明对于Provider的依赖

  • 自定义Qualifier的依赖

    • 注册组件时，可额外指定Qualifier
    • 注册组件时，可从类对象上提取Qualifier
    • 寻找依赖时，需同时满足类型与自定义Qualifier标注
    • 支持默认Qualifier——Named

  • Singleton生命周期

    • 注册组件时，可额外指定是否为Singleton
    • 注册组件时，可从类对象上提取Singleton标注
    • 对于包含Singleton标注的组件，在容器范围内提供唯一实例
    • 容器组件默认不是Single生命周期

  • 自定义Scope标注

    • 可向容器注册自定义Scope标注的回调

视频演示 ​

让我们进入今天的部分：

思考题 ​

在进入下节课之前，希望你能认真思考如下两个问题，并选择最有感触的一道进行回答。

  1. 你是怎么发现坏味道的？在重构的过程中，都使用了哪些重构手法呢？
  2. 如果要对ContainerTest进行文档化改造，你会怎么做呢？

欢迎把你的想法分享在留言区，也欢迎把你的项目代码的链接分享出来。相信经过你的思考与实操，学习效果会更好！

最近更新