43. DI コンテナを素の Java で作る

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.reflect.Constructor;
import java.util.LinkedHashMap;
import java.util.Map;

// 「コンテナに作らせてよいクラス」の目印。実行時に読めるよう RUNTIME にする
@Retention(RetentionPolicy.RUNTIME)
@interface Component {
}

class MiniContainer {
    // 型 → 作ったインスタンス。登録表ではなく、作った後の置き場
    private final Map<Class<?>, Object> singletons = new LinkedHashMap<>();
    private int depth = 0;

    @SuppressWarnings("unchecked")
    <T> T get(Class<T> type) {
        // (1) すでに作ってあれば、それを返す
        Object cached = singletons.get(type);
        if (cached != null) {
            log("reuse  " + type.getSimpleName());
            return (T) cached;
        }
        // (2) 目印が付いているか確かめる
        if (!type.isAnnotationPresent(Component.class)) {
            throw new IllegalStateException(type.getName() + " is not annotated with @Component");
        }
        Constructor<?>[] ctors = type.getDeclaredConstructors();
        if (ctors.length != 1) {
            throw new IllegalStateException(type.getName() + " must have exactly one constructor");
        }
        // (3) コンストラクタの引数の型を .class から読み、先にそれらを作る(再帰)
        Constructor<?> ctor = ctors[0];
        Class<?>[] paramTypes = ctor.getParameterTypes();
        log("create " + type.getSimpleName() + " (needs " + paramTypes.length + " dependencies)");
        Object[] args = new Object[paramTypes.length];
        depth++;
        for (int i = 0; i < paramTypes.length; i++) {
            args[i] = get(paramTypes[i]);
        }
        depth--;
        // (4) そろった引数で生成し、置き場に入れる
        try {
            ctor.setAccessible(true);
            Object instance = ctor.newInstance(args);
            singletons.put(type, instance);
            return (T) instance;
        } catch (ReflectiveOperationException e) {
            throw new IllegalStateException("cannot create " + type.getName(), e);
        }
    }

    private void log(String msg) {
        System.out.println("  ".repeat(depth) + msg);
    }
}

@Component
class Clock {
    long now() { return 1_700_000_000L; }
}

@Component
class UserRepository {
    private final Clock clock;
    UserRepository(Clock clock) { this.clock = clock; }
    String find(int id) { return "user-" + id + "@" + clock.now(); }
}

@Component
class UserService {
    private final UserRepository repo;
    private final Clock clock;
    UserService(UserRepository repo, Clock clock) { this.repo = repo; this.clock = clock; }
    String describe(int id) { return repo.find(id); }
}

class Main {
    public static void main(String[] args) {
        MiniContainer container = new MiniContainer();
        // 登録はしていない。渡すのは「欲しい型」だけ
        UserService service = container.get(UserService.class);
        System.out.println(service.describe(42));
        System.out.println("same instance on second get? " + (service == container.get(UserService.class)));
        try {
            container.get(String.class);
        } catch (IllegalStateException e) {
            System.out.println("error: " + e.getMessage());
        }
    }
}

// 出力
// create UserService (needs 2 dependencies)
//   create UserRepository (needs 1 dependencies)
//     create Clock (needs 0 dependencies)
//   reuse  Clock
// user-42@1700000000
// reuse  UserService
// same instance on second get? true
// error: java.lang.String is not annotated with @Component