Какие знаешь способы реализации инверсии управления помимо Spring?

Инверсия управления (IoC) без Spring

Инверсия управления — это архитектурный принцип, который передаёт ответственность за создание и управление объектами с самого приложения на специальный контейнер или механизм. Существует множество способов реализовать IoC вне экосистемы Spring.

1. Паттерн Service Locator

Это простейший способ реализации IoC. Объекты запрашивают зависимости через центральный локатор:

public class ServiceLocator {
    private static final Map<Class<?>, Object> services = new HashMap<>();

    public static void register(Class<?> type, Object implementation) {
        services.put(type, implementation);
    }

    public static <T> T getService(Class<T> type) {
        return (T) services.get(type);
    }
}

// Использование
ServiceLocator.register(UserRepository.class, new UserRepositoryImpl());
UserRepository repo = ServiceLocator.getService(UserRepository.class);

Плюсы: простая реализация, минимальные зависимости. Минусы: скрытые зависимости, сложнее тестировать.

2. Конструкторная инъекция вручную

Мануальная передача зависимостей через конструктор — классический способ:

public class UserService {
    private final UserRepository userRepository;
    private final EmailService emailService;

    public UserService(UserRepository userRepository, EmailService emailService) {
        this.userRepository = userRepository;
        this.emailService = emailService;
    }

    public void registerUser(String email) {
        User user = new User(email);
        userRepository.save(user);
        emailService.sendWelcomeEmail(email);
    }
}

// В point of entry приложения
public static void main(String[] args) {
    UserRepository repo = new UserRepositoryImpl();
    EmailService email = new EmailServiceImpl();
    UserService service = new UserService(repo, email);
}

Плюсы: явные зависимости, легко тестировать, нет магии. Минусы: много boilerplate кода при большом количестве зависимостей.

3. Factory Pattern (Фабрика)

Объекты создаются через фабрику, которая управляет их жизненным циклом:

public class ObjectFactory {
    public UserRepository createUserRepository() {
        return new UserRepositoryImpl();
    }

    public EmailService createEmailService() {
        return new EmailServiceImpl();
    }

    public UserService createUserService() {
        return new UserService(
            createUserRepository(),
            createEmailService()
        );
    }
}

// Использование
ObjectFactory factory = new ObjectFactory();
UserService service = factory.createUserService();

Плюсы: централизованное управление созданием, легко менять реализации. Минусы: требует явного написания кода для каждого объекта.

4. Dependency Injection через библиотеку Google Guice

Гугловская IoC библиотека, более лёгкая, чем Spring:

public class AppModule extends AbstractModule {
    @Override
    protected void configure() {
        bind(UserRepository.class).to(UserRepositoryImpl.class);
        bind(EmailService.class).to(EmailServiceImpl.class);
    }
}

@Inject
public class UserService {
    private final UserRepository userRepository;
    private final EmailService emailService;

    @Inject
    public UserService(UserRepository userRepository, EmailService emailService) {
        this.userRepository = userRepository;
        this.emailService = emailService;
    }
}

// Использование
Injector injector = Guice.createInjector(new AppModule());
UserService service = injector.getInstance(UserService.class);

Плюсы: автоматическая инъекция, типобезопасность, меньше настроек чем Spring. Минусы: менее популярна, меньше документации.

5. Java Service Provider Interface (SPI)

Встроенный механизм Java для обнаружения реализаций:

// UserRepositoryProvider.java
public interface UserRepositoryProvider {
    UserRepository getUserRepository();
}

// Файл: META-INF/services/UserRepositoryProvider
// Содержит: com.example.UserRepositoryProviderImpl

public class Main {
    public static void main(String[] args) {
        ServiceLoader<UserRepositoryProvider> loader = 
            ServiceLoader.load(UserRepositoryProvider.class);
        UserRepository repo = loader.findFirst()
            .map(UserRepositoryProvider::getUserRepository)
            .orElseThrow();
    }
}

Плюсы: встроено в Java, без зависимостей, хорошо для плагинов. Минусы: минимальная функциональность, требует конфигурации файлов.

6. Обработка через аннотации (самодельный контейнер)

Можно создать собственный простой контейнер с аннотациями:

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface Inject { }

public class SimpleContainer {
    private final Map<Class<?>, Object> registry = new HashMap<>();

    public void register(Class<?> type, Object instance) {
        registry.put(type, instance);
    }

    public <T> T getInstance(Class<T> type) throws IllegalAccessException {
        Object instance = registry.get(type);
        if (instance == null) throw new RuntimeException("Not found: " + type);
        
        for (Field field : instance.getClass().getDeclaredFields()) {
            if (field.isAnnotationPresent(Inject.class)) {
                field.setAccessible(true);
                Object dependency = registry.get(field.getType());
                field.set(instance, dependency);
            }
        }
        return (T) instance;
    }
}

// Использование
SimpleContainer container = new SimpleContainer();
container.register(UserRepository.class, new UserRepositoryImpl());
container.register(UserService.class, new UserService());
UserService service = container.getInstance(UserService.class);

Выводы

Каждый подход имеет свою область применения: для маленьких проектов подходит конструкторная инъекция, для средних — Factory Pattern или Guice, для больших — Spring Framework. Понимание этих механизмов позволяет выбирать оптимальное решение для каждой задачи.