34｜DI Container（22）：如何对Bind的逻辑进行重构？
徐昊
你好，我是徐昊。今天我们继续使用 TDD 的方式实现注入依赖容器。
回顾代码与任务列表
到目前为止，我们的代码是这样的：
Component.java
package geektime.tdd.di;
import java.lang.annotation.Annotation;
public record Component(Class<?> type, Annotation qualifiers) {
}
ComponentRef.java
package geektime.tdd.di;
import java.lang.annotation.Annotation;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.Objects;
public class ComponentRef<ComponentType> {
public static <ComponentType> ComponentRef<ComponentType> of(Class<ComponentType> component) {
return new ComponentRef(component, null);
}
public static <ComponentType> ComponentRef<ComponentType> of(Class<ComponentType> component, Annotation qualifier) {
return new ComponentRef(component, qualifier);
}
public static ComponentRef of(Type type) {
return new ComponentRef(type, null);
}
public static ComponentRef of(Type type, Annotation qualifier) {
return new ComponentRef(type, qualifier);
}
private Type container;
private Component component;
ComponentRef(Type type, Annotation qualifier) {
init(type, qualifier);
}
protected ComponentRef() {
this(null);
}
protected ComponentRef(Annotation qualifier) {
Type type = ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0];
init(type, qualifier);
}
private void init(Type type, Annotation qualifier) {
if (type instanceof ParameterizedType container) {
this.container = container.getRawType();
this.component = new Component((Class<ComponentType>) container.getActualTypeArguments()[0], qualifier);
} else
this.component = new Component((Class<ComponentType>) type, qualifier);
}
public Type getContainer() {
return container;
}
public Class<?> getComponentType() {
return component.type();
}
public boolean isContainer() {
return container != null;
}
public Component component() {
return component;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
ComponentRef<?> that = (ComponentRef<?>) o;
return Objects.equals(container, that.container) && component.equals(that.component);
}
@Override
public int hashCode() {
return Objects.hash(container, component);
}
}
Context.java
package geektime.tdd.di;
import java.util.Optional;
public interface Context {
<ComponentType> Optional<ComponentType> get(ComponentRef<ComponentType> ref);
}
ContextConfig.java
package geektime.tdd.di;
import jakarta.inject.Provider;
import jakarta.inject.Qualifier;
import jakarta.inject.Scope;
import jakarta.inject.Singleton;
import java.lang.annotation.Annotation;
import java.util.*;
import java.util.function.Function;
public class ContextConfig {
private Map<Component, ComponentProvider<?>> components = new HashMap<>();
private Map<Class<?>, Function<ComponentProvider<?>, ComponentProvider<?>>> scopes = new HashMap<>();
public ContextConfig() {
scope(Singleton.class, SingletonProvider::new);
}
public <Type> void bind(Class<Type> type, Type instance) {
components.put(new Component(type, null), (ComponentProvider<Type>) context -> instance);
}
public <Type> void bind(Class<Type> type, Type instance, Annotation... qualifiers) {
if (Arrays.stream(qualifiers).anyMatch(q -> !q.annotationType().isAnnotationPresent(Qualifier.class)))
throw new IllegalComponentException();
for (Annotation qualifier : qualifiers)
components.put(new Component(type, qualifier), context -> instance);
}
public <Type, Implementation extends Type>
void bind(Class<Type> type, Class<Implementation> implementation) {
bind(type, implementation, implementation.getAnnotations());
}
public <Type, Implementation extends Type>
void bind(Class<Type> type, Class<Implementation> implementation, Annotation... annotations) {
if (Arrays.stream(annotations).map(Annotation::annotationType)
.anyMatch(t -> !t.isAnnotationPresent(Qualifier.class) && !t.isAnnotationPresent(Scope.class)))
throw new IllegalComponentException();
Optional<Annotation> scopeForType = Arrays.stream(implementation.getAnnotations()).filter(a -> a.annotationType().isAnnotationPresent(Scope.class)).findFirst();
List<Annotation> qualifiers = Arrays.stream(annotations).filter(a -> a.annotationType().isAnnotationPresent(Qualifier.class)).toList();
Optional<Annotation> scope = Arrays.stream(annotations).filter(a -> a.annotationType().isAnnotationPresent(Scope.class)).findFirst()
.or(() -> scopeForType);
ComponentProvider<?> injectionProvider = new InjectionProvider<>(implementation);
ComponentProvider<?> provider = scope.<ComponentProvider<?>>map(s -> getScopeProvider(s, injectionProvider)).orElse(injectionProvider);
if (qualifiers.isEmpty()) components.put(new Component(type, null), provider);
for (Annotation qualifier : qualifiers)
components.put(new Component(type, qualifier), provider);
}
private ComponentProvider<?> getScopeProvider(Annotation scope, ComponentProvider<?> provider) {
return scopes.get(scope.annotationType()).apply(provider);
}
public <ScopeType extends Annotation> void scope(Class<ScopeType> scope, Function<ComponentProvider<?>, ComponentProvider<?>> provider) {
scopes.put(scope, provider);
}
static class SingletonProvider<T> implements ComponentProvider<T> {
private T singleton;
private ComponentProvider<T> provider;
public SingletonProvider(ComponentProvider<T> provider) {
this.provider = provider;
}
@Override
public T get(Context context) {
if (singleton == null) singleton = provider.get(context);
return singleton;
}
@Override
public List<ComponentRef<?>> getDependencies() {
return provider.getDependencies();
}
}
public Context getContext() {
components.keySet().forEach(component -> checkDependencies(component, new Stack<>()));
return new Context() {
@Override
public <ComponentType> Optional<ComponentType> get(ComponentRef<ComponentType> ref) {
if (ref.isContainer()) {
if (ref.getContainer() != Provider.class) return Optional.empty();
return (Optional<ComponentType>) Optional.ofNullable(getProvider(ref))
.map(provider -> (Provider<Object>) () -> provider.get(this));
}
return Optional.ofNullable(getProvider(ref)).map(provider -> (ComponentType) provider.get(this));
}
};
}
private <ComponentType> ComponentProvider<?> getProvider(ComponentRef<ComponentType> ref) {
return components.get(ref.component());
}
private void checkDependencies(Component component, Stack<Component> visiting) {
for (ComponentRef<?> dependency : components.get(component).getDependencies()) {
if (!components.containsKey(dependency.component()))
throw new DependencyNotFoundException(component, dependency.component());
if (!dependency.isContainer()) {
if (visiting.contains(dependency.component())) throw new CyclicDependenciesFoundException(visiting);
visiting.push(dependency.component());
checkDependencies(dependency.component(), visiting);
visiting.pop();
}
}
}
interface ComponentProvider<T> {
T get(Context context);
default List<ComponentRef<?>> getDependencies() {
return List.of();
}
}
}
InjectionProvider.java
package geektime.tdd.di;
import jakarta.inject.Inject;
import jakarta.inject.Qualifier;
import java.lang.annotation.Annotation;
import java.lang.reflect.*;
import java.util.*;
import java.util.function.BiFunction;
import java.util.stream.Stream;
import static java.util.Arrays.stream;
import static java.util.stream.Stream.concat;
class InjectionProvider<T> implements ContextConfig.ComponentProvider<T> {
private Injectable<Constructor<T>> injectConstructor;
private List<Injectable<Method>> injectMethods;
private List<Injectable<Field>> injectableFields;
public InjectionProvider(Class<T> component) {
if (Modifier.isAbstract(component.getModifiers())) throw new IllegalComponentException();
this.injectConstructor = getInjectConstructor(component);
this.injectMethods = getInjectMethods(component);
this.injectableFields = getInjectFields(component);
if (injectableFields.stream().anyMatch(f -> Modifier.isFinal(f.element().getModifiers())))
throw new IllegalComponentException();
if (injectMethods.stream().anyMatch(m -> m.element().getTypeParameters().length != 0))
throw new IllegalComponentException();
}
@Override
public T get(Context context) {
try {
T instance = injectConstructor.element().newInstance(injectConstructor.toDependencies(context));
for (Injectable<Field> field : injectableFields)
field.element().set(instance, field.toDependencies(context)[0]);
for (Injectable<Method> method : injectMethods)
method.element().invoke(instance, method.toDependencies(context));
return instance;
} catch (InvocationTargetException | InstantiationException | IllegalAccessException e) {
throw new RuntimeException(e);
}
}
@Override
public List<ComponentRef<?>> getDependencies() {
return concat(concat(Stream.of(injectConstructor), injectableFields.stream()), injectMethods.stream())
.map(Injectable::required).flatMap(Arrays::stream).toList();
}
record Injectable<Element extends AccessibleObject>(Element element, ComponentRef<?>[] required) {
Object[] toDependencies(Context context) {
return stream(required).map(context::get).map(Optional::get).toArray();
}
static <Element extends Executable> Injectable<Element> of(Element element) {
return new Injectable<>(element, stream(element.getParameters()).map(Injectable::toComponentRef).toArray(ComponentRef<?>[]::new));
}
static Injectable<Field> of(Field field) {
return new Injectable<>(field, new ComponentRef<?>[]{toComponentRef(field)});
}
private static ComponentRef<?> toComponentRef(Field field) {
return ComponentRef.of(field.getGenericType(), getQualifier(field));
}
private static ComponentRef<?> toComponentRef(Parameter parameter) {
return ComponentRef.of(parameter.getParameterizedType(), getQualifier(parameter));
}
private static Annotation getQualifier(AnnotatedElement element) {
List<Annotation> qualifiers = stream(element.getAnnotations())
.filter(a -> a.annotationType().isAnnotationPresent(Qualifier.class)).toList();
if (qualifiers.size() > 1) throw new IllegalComponentException();
return qualifiers.stream().findFirst().orElse(null);
}
}
private static <T> List<Injectable<Method>> getInjectMethods(Class<T> component) {
List<Method> injectMethods = traverse(component, (methods, current) -> injectable(current.getDeclaredMethods())
.filter(m -> isOverrideByInjectMethod(methods, m))
.filter(m -> isOverrideByNoInjectMethod(component, m)).toList());
Collections.reverse(injectMethods);
return injectMethods.stream().map(Injectable::of).toList();
}
private static <T> List<Injectable<Field>> getInjectFields(Class<T> component) {
return InjectionProvider.<Field>traverse(component, (fields, current) -> injectable(current.getDeclaredFields()).toList())
.stream().map(Injectable::of).toList();
}
private static <Type> Injectable<Constructor<Type>> getInjectConstructor(Class<Type> implementation) {
List<Constructor<?>> injectConstructors = injectable(implementation.getConstructors()).toList();
if (injectConstructors.size() > 1) throw new IllegalComponentException();
return Injectable.of((Constructor<Type>) injectConstructors.stream().findFirst().orElseGet(() -> defaultConstructor(implementation)));
}
private static <Type> Constructor<Type> defaultConstructor(Class<Type> implementation) {
try {
return implementation.getDeclaredConstructor();
} catch (NoSuchMethodException e) {
throw new IllegalComponentException();
}
}
private static <T> List<T> traverse(Class<?> component, BiFunction<List<T>, Class<?>, List<T>> finder) {
List<T> members = new ArrayList<>();
Class<?> current = component;
while (current != Object.class) {
members.addAll(finder.apply(members, current));
current = current.getSuperclass();
}
return members;
}
private static <T extends AnnotatedElement> Stream<T> injectable(T[] declaredFields) {
return stream(declaredFields).filter(f -> f.isAnnotationPresent(Inject.class));
}
private static boolean isOverride(Method m, Method o) {
return o.getName().equals(m.getName()) && Arrays.equals(o.getParameterTypes(), m.getParameterTypes());
}
private static <T> boolean isOverrideByNoInjectMethod(Class<T> component, Method m) {
return stream(component.getDeclaredMethods()).filter(m1 -> !m1.isAnnotationPresent(Inject.class)).noneMatch(o -> isOverride(m, o));
}
private static boolean isOverrideByInjectMethod(List<Method> injectMethods, Method m) {
return injectMethods.stream().noneMatch(o -> isOverride(m, o));
}
}
任务列表的状态为：
无需构造的组件——组件实例
如果注册的组件不可实例化，则抛出异常
抽象类
接口
构造函数注入
无依赖的组件应该通过默认构造函数生成组件实例
有依赖的组件，通过 Inject 标注的构造函数生成组件实例
如果所依赖的组件也存在依赖，那么需要对所依赖的组件也完成依赖注入
如果组件有多于一个 Inject 标注的构造函数，则抛出异常
如果组件没有 Inject 标注的构造函数，也没有默认构造函数（新增任务）
如果组件需要的依赖不存在，则抛出异常
如果组件间存在循环依赖，则抛出异常
字段注入
通过 Inject 标注将字段声明为依赖组件
如果字段为 final 则抛出异常
依赖中应包含 Inject Field 声明的依赖
方法注入
通过 Inject 标注的方法，其参数为依赖组件
通过 Inject 标注的无参数方法，会被调用
按照子类中的规则，覆盖父类中的 Inject 方法
如果方法定义类型参数，则抛出异常
依赖中应包含 Inject Method 声明的依赖
对 Provider 类型的依赖
从容器中取得组件的 Provider（新增任务）
注入构造函数中可以声明对于 Provider 的依赖
注入字段中可以声明对于 Provider 的依赖
注入方法中可声明对于 Provider 的依赖
将构造函数中的 Provider 加入依赖（新增任务）
将字段中的 Provider 加入依赖（新增任务）
将方法中的 Provider 加入依赖（新增任务）
自定义 Qualifier 的依赖
注册组件时，可额外指定 Qualifier
针对 instance 指定一个 Qualifieri（新增任务）
针对组件指定一个 Qualiifer（新增任务）
针对 instance 指定多个 Qualifieri（新增任务）
针对组件指定多个 Qualiifer（新增任务）
注册组件时，如果不是合法的 Qualifier，则不接受组件注册（新增任务）
寻找依赖时，需同时满足类型与自定义 Qualifier 标注
在检查依赖时使用 Qualifier（新增任务）
在检查循环依赖时使用 Qualifier（新增任务）
构造函数注入可以使用 Qualifier 声明依赖（新增任务）
依赖中包含 Qualifier（新增任务）
如果不是合法的 Qualifier，则组件非法
字段注入可以使用 Qualifier 声明依赖（新增任务）
依赖中包含 Qualifier（新增任务）
如果不是合法的 Qualifier，则组件非法
函数注入可以使用 Qualifier 声明依赖（新增任务）
依赖中包含 Qualifier（新增任务）
如果不是合法的 Qualifier，则组件非法
支持默认 Qualifier——Named（不需要）
注册组件时，可从类对象上提取 Qualifier（不需要）
Singleton 生命周期
注册组件时，可额外指定是否为 Singleton
注册包含 Qualifier 的组件时，可额外指定是否为 Singleton（新增任务）
注册组件时，可从类对象上提取 Scope 标注
对于包含 Singleton 标注的组件，在容器范围内提供唯一实例（不需要）
容器组件默认不是 Single 生命周期
包含 Qualifier 的组件默认不是 Single 生命周期（新增任务）
对于包含 Scope 的组件，检测依赖关系（新增任务）
自定义 Scope 标注
可向容器注册自定义 Scope 标注的回调
确认放弃笔记？
放弃后所记笔记将不保留。
新功能上线，你的历史笔记已初始化为私密笔记，是否一键批量公开？
批量公开的笔记不会为你同步至部落
公开
同步至部落
取消
完成
0/2000
荧光笔
直线
曲线笔记
复制
AI
- 深入了解
- 翻译
- 英语
- 中文简体
- 中文繁体
- 法语
- 德语
- 日语
- 韩语
- 俄语
- 西班牙语
- 阿拉伯语
- 解释
- 总结
徐八叉的文章深入探讨了如何通过重构Bind的逻辑来实现注入依赖容器，并以TDD的方式展示了具体的实现方法。该文章适合想要深入了解依赖注入容器实现原理的技术人员阅读。通过阅读本文，读者可以学习到如何利用TDD的方式来实现注入依赖容器，以及如何对Bind的逻辑进行重构。文章还介绍了任务列表的状态，包括组件实例化、抽象类、接口、构造函数注入、字段注入、方法注入、对Provider类型的依赖以及自定义Qualifier的依赖等内容。这篇文章对于想要深入了解依赖注入容器实现原理的技术人员来说是一篇值得阅读的文章。
仅可试看部分内容，如需阅读全部内容，请付费购买文章所属专栏
《徐昊 · TDD 项目实战 70 讲》，新⼈⾸单¥98
《徐昊 · TDD 项目实战 70 讲》，新⼈⾸单¥98
立即购买
登录 后留言
全部留言(2)
- 最新
- 精选
张铁林https://github.com/vfbiby/tdd-di-container/tree/master 已码完编辑回复: 假期愉快！
2022-06-042
aoe21 ~ 34 笔记 https://wyyl1.com/post/19/09/编辑回复: good work！
2022-05-30
收起评论
