サンプルコードで身につける: DI コンテナを素の Java で作る

import java.lang.reflect.Constructor;

class Clock {
}

class UserRepository {
    UserRepository(Clock clock) { }
}

class UserService {
    UserService(UserRepository repo, Clock clock) { }
}

class Main {
    public static void main(String[] args) {
        Class<?>[] types = { Clock.class, UserRepository.class, UserService.class };
        for (Class<?> type : types) {
            // コンストラクタを .class から取り出し、引数の型を読む
            Constructor<?> ctor = type.getDeclaredConstructors()[0];
            Class<?>[] params = ctor.getParameterTypes();
            System.out.println(type.getName() + " needs " + params.length + ":");
            for (Class<?> p : params) {
                System.out.println("  " + p.getName());
            }
        }
    }
}

// 出力
// Clock needs 0:
// UserRepository needs 1:
//   Clock
// UserService needs 2:
//   UserRepository
//   Clock

class Clock {
    Clock() { System.out.println("new Clock"); }
    long now() { return 1_700_000_000L; }
}

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

class UserService {
    private final UserRepository repo;
    private final Clock clock;
    UserService(UserRepository repo, Clock clock) {
        this.repo = repo;
        this.clock = clock;
        System.out.println("new UserService");
    }
    String describe(int id) { return repo.find(id); }
}

class Main {
    public static void main(String[] args) {
        // コンテナなし: 作る順番と、同じ Clock を2か所に渡すことを人が書く
        Clock clock = new Clock();
        UserRepository repo = new UserRepository(clock);
        UserService service = new UserService(repo, clock);
        System.out.println(service.describe(42));
    }
}

// 出力
// new Clock
// new UserRepository
// new UserService
// user-42@1700000000

import java.lang.reflect.Constructor;
import java.util.HashMap;
import java.util.Map;

// ログを省いた最小のコンテナ(目印の確認も省略)
class MiniContainer {
    private final Map<Class<?>, Object> singletons = new HashMap<>();

    Object get(Class<?> type) throws Exception {
        Object cached = singletons.get(type);
        if (cached != null) {
            return cached;
        }
        Constructor<?> ctor = type.getDeclaredConstructors()[0];
        Class<?>[] paramTypes = ctor.getParameterTypes();
        Object[] args = new Object[paramTypes.length];
        for (int i = 0; i < paramTypes.length; i++) {
            args[i] = get(paramTypes[i]);
        }
        Object instance = ctor.newInstance(args);
        singletons.put(type, instance);
        return instance;
    }
}

class Clock {
    Clock() { System.out.println("new Clock"); }
}

// 後から足したクラス。コンテナにも main にも、これの名前は出てこない
class AuditLog {
    AuditLog(Clock clock) { System.out.println("new AuditLog"); }
}

class UserRepository {
    UserRepository(Clock clock) { System.out.println("new UserRepository"); }
}

class UserService {
    // 引数に AuditLog を1つ足しただけ
    UserService(UserRepository repo, AuditLog audit, Clock clock) {
        System.out.println("new UserService");
    }
}

class Main {
    public static void main(String[] args) throws Exception {
        MiniContainer container = new MiniContainer();
        container.get(UserService.class);
    }
}

// 出力
// new Clock
// new UserRepository
// new AuditLog
// new UserService

import java.lang.reflect.Constructor;
import java.util.HashMap;
import java.util.Map;

class MiniContainer {
    private final Map<Class<?>, Object> singletons = new HashMap<>();
    int calls = 0;

    Object get(Class<?> type) throws Exception {
        calls++;
        Object cached = singletons.get(type);
        if (cached != null) {
            return cached;
        }
        Constructor<?> ctor = type.getDeclaredConstructors()[0];
        Class<?>[] paramTypes = ctor.getParameterTypes();
        Object[] args = new Object[paramTypes.length];
        for (int i = 0; i < paramTypes.length; i++) {
            args[i] = get(paramTypes[i]);
        }
        Object instance = ctor.newInstance(args);
        singletons.put(type, instance); // 置き場に入るのはコンストラクタが返った後
        return instance;
    }
}

// A を作るには B が要り、B を作るには A が要る
class A {
    A(B b) { }
}

class B {
    B(A a) { }
}

class Main {
    public static void main(String[] args) throws Exception {
        MiniContainer container = new MiniContainer();
        try {
            container.get(A.class);
            System.out.println("created A");
        } catch (StackOverflowError e) {
            System.out.println("caught: " + e);
            System.out.println("get() was entered more than 100 times? " + (container.calls > 100));
            System.out.println("the same pair repeats: get(A) -> get(B) -> get(A) -> ...");
        }
    }
}

// 出力(get に入った回数そのものは、実行のたび・環境ごとに変わるので表示していない)
// caught: java.lang.StackOverflowError
// get() was entered more than 100 times? true
// the same pair repeats: get(A) -> get(B) -> get(A) -> ...

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

@Retention(RetentionPolicy.RUNTIME)
@interface Component {
}

class MiniContainer {
    private final Map<Class<?>, Object> singletons = new HashMap<>();

    Object get(Class<?> type) throws Exception {
        Object cached = singletons.get(type);
        if (cached != null) {
            return cached;
        }
        if (type.isInterface()) {
            throw new IllegalStateException(type.getName() + " is an interface: which implementation?");
        }
        if (!type.isAnnotationPresent(Component.class)) {
            throw new IllegalStateException(type.getName() + " is not annotated with @Component");
        }
        Constructor<?> ctor = type.getDeclaredConstructors()[0];
        Class<?>[] paramTypes = ctor.getParameterTypes();
        Object[] args = new Object[paramTypes.length];
        for (int i = 0; i < paramTypes.length; i++) {
            args[i] = get(paramTypes[i]);
        }
        Object instance = ctor.newInstance(args);
        singletons.put(type, instance);
        return instance;
    }
}

interface Notifier {
    void send(String message);
}

@Component
class MailNotifier implements Notifier {
    public void send(String message) { System.out.println("mail: " + message); }
}

@Component
class AlertService {
    // 引数の型はインターフェース
    AlertService(Notifier notifier) { }
}

class Main {
    public static void main(String[] args) throws Exception {
        Constructor<?> ctor = AlertService.class.getDeclaredConstructors()[0];
        System.out.println("parameter type = " + ctor.getParameterTypes()[0].getName());
        System.out.println("is interface?  = " + ctor.getParameterTypes()[0].isInterface());
        try {
            new MiniContainer().get(AlertService.class);
        } catch (IllegalStateException e) {
            System.out.println("error: " + e.getMessage());
        }
    }
}

// 出力
// parameter type = Notifier
// is interface?  = true
// error: Notifier is an interface: which implementation?