Mini-challenge: tự build mini IoC container 80 dòng

import java.io.*;
import java.lang.annotation.*;
import java.lang.reflect.*;
import java.net.URL;
import java.util.*;

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface Component {}

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@interface PostConstruct {}

public class MiniContainer {

    private final String basePackage;
    private final Map<Class<?>, Object> beans = new LinkedHashMap<>();
    private final List<Class<?>> definitions = new ArrayList<>();

    public MiniContainer(String basePackage) throws Exception {
        this.basePackage = basePackage;
        scan();
    }

    private void scan() throws Exception {
        String path = basePackage.replace('.', '/');
        URL root = Thread.currentThread().getContextClassLoader().getResource(path);
        if (root == null) {
            throw new IllegalStateException("Package not found: " + basePackage);
        }
        File dir = new File(root.toURI());
        File[] files = Objects.requireNonNull(dir.listFiles());
        for (File f : files) {
            if (!f.getName().endsWith(".class")) continue;
            String className = basePackage + "." + f.getName().replace(".class", "");
            Class<?> clazz = Class.forName(className);
            if (clazz.isAnnotationPresent(Component.class)) {
                definitions.add(clazz);
            }
        }
        System.out.println("Scanned " + definitions.size() + " components");
    }

    public void start() throws Exception {
        for (Class<?> c : topologicalSort()) {
            Constructor<?> ctor = c.getConstructors()[0];
            Class<?>[] paramTypes = ctor.getParameterTypes();
            Object[] args = new Object[paramTypes.length];
            for (int i = 0; i < paramTypes.length; i++) {
                args[i] = beans.get(paramTypes[i]);
                if (args[i] == null) {
                    throw new IllegalStateException(
                        "Cannot resolve dependency " + paramTypes[i].getName() +
                        " for " + c.getName());
                }
            }
            Object instance = ctor.newInstance(args);
            beans.put(c, instance);
            System.out.println("Instantiated " + c.getSimpleName());
            invokePostConstruct(c, instance);
        }
    }

    private List<Class<?>> topologicalSort() {
        Map<Class<?>, Set<Class<?>>> remaining = new LinkedHashMap<>();
        for (Class<?> c : definitions) {
            Constructor<?> ctor = c.getConstructors()[0];
            Set<Class<?>> deps = new HashSet<>();
            for (Class<?> p : ctor.getParameterTypes()) {
                if (definitions.contains(p)) deps.add(p);
            }
            remaining.put(c, deps);
        }

        List<Class<?>> sorted = new ArrayList<>();
        while (!remaining.isEmpty()) {
            Class<?> ready = null;
            for (Map.Entry<Class<?>, Set<Class<?>>> e : remaining.entrySet()) {
                if (sorted.containsAll(e.getValue())) {
                    ready = e.getKey();
                    break;
                }
            }
            if (ready == null) {
                throw new IllegalStateException(
                    "Circular dependency detected among: " + remaining.keySet());
            }
            sorted.add(ready);
            remaining.remove(ready);
        }
        return sorted;
    }

    private void invokePostConstruct(Class<?> c, Object instance) throws Exception {
        for (Method m : c.getDeclaredMethods()) {
            if (m.isAnnotationPresent(PostConstruct.class)) {
                m.setAccessible(true);
                m.invoke(instance);
                System.out.println("Called @PostConstruct on " + c.getSimpleName());
            }
        }
    }

    @SuppressWarnings("unchecked")
    public <T> T getBean(Class<T> type) {
        Object bean = beans.get(type);
        if (bean == null) {
            throw new IllegalStateException("No bean of type " + type.getName());
        }
        return (T) bean;
    }
}

package com.demo;

@Component
class GreetingService {
    public String greet(String name) { return "Hello, " + name; }
}

@Component
class UserService {
    private final GreetingService greeting;
    private boolean initialized;

    public UserService(GreetingService greeting) {
        this.greeting = greeting;
    }

    @PostConstruct
    void init() { this.initialized = true; }

    public String welcome(String name) {
        if (!initialized) throw new IllegalStateException("not initialized");
        return greeting.greet(name);
    }
}

public class App {
    public static void main(String[] args) throws Exception {
        var container = new MiniContainer("com.demo");
        container.start();
        UserService us = container.getBean(UserService.class);
        System.out.println(us.welcome("OLHub"));
    }
}

Scanned 2 components
Instantiated GreetingService
Instantiated UserService
Called @PostConstruct on UserService
Hello, OLHub