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);
}
private Type container;
private Component component;
ComponentRef(Type type, Annotation qualifier) {
init(type, qualifier);
}
protected ComponentRef() {
Type type = ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0];
init(type, null);
}
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 java.lang.annotation.Annotation;
import java.util.*;
public class ContextConfig {
private Map<Component, ComponentProvider<?>> components = new HashMap<>();
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) {
components.put(new Component(type, null), new InjectionProvider<>(implementation));
}
public <Type, Implementation extends Type>
void bind(Class<Type> type, Class<Implementation> implementation, 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), new InjectionProvider<>(implementation));
}
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<Class<?>> visiting) {
for (ComponentRef dependency : components.get(component).getDependencies()) {
if (!components.containsKey(dependency.component()))
throw new DependencyNotFoundException(component.type(), dependency.getComponentType());
if (!dependency.isContainer()) {
if (visiting.contains(dependency.getComponentType())) throw new CyclicDependenciesFoundException(visiting);
visiting.push(dependency.getComponentType());
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 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 Constructor<T> injectConstructor;
private List<Field> injectFields;
private List<Method> injectMethods;
public InjectionProvider(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 {
T instance = injectConstructor.newInstance(toDependencies(context, injectConstructor));
for (Field field : injectFields) field.set(instance, toDependency(context, field));
for (Method method : injectMethods) method.invoke(instance, toDependencies(context, method));
return instance;
} catch (InvocationTargetException | InstantiationException | IllegalAccessException e) {
throw new RuntimeException(e);
}
}
@Override
public List<ComponentRef> getDependencies() {
return concat(concat(stream(injectConstructor.getParameters()).map(Parameter::getParameterizedType),
injectFields.stream().map(Field::getGenericType)),
injectMethods.stream().flatMap(m -> stream(m.getParameters()).map(Parameter::getParameterizedType)))
.map(ComponentRef::of).toList();
}
private static <T> List<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;
}
private static <T> List<Field> getInjectFields(Class<T> component) {
return traverse(component, (fields, current) -> injectable(current.getDeclaredFields()).toList());
}
private static <Type> Constructor<Type> getInjectConstructor(Class<Type> implementation) {
List<Constructor<?>> injectConstructors = injectable(implementation.getConstructors()).toList();
if (injectConstructors.size() > 1) throw new IllegalComponentException();
return (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));
}
private static Object[] toDependencies(Context context, Executable executable) {
return stream(executable.getParameters()).map(p -> toDependency(context, p.getParameterizedType())).toArray(Object[]::new);
}
private static Object toDependency(Context context, Field field) {
return toDependency(context, field.getGenericType());
}
private static Object toDependency(Context context, Type type) {
return context.get(ComponentRef.of(type)).get();
}
}
荧光笔
直线
曲线
