Какая из разновидностей инверсии управления реализуется в ApplicationContext?

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

ApplicationContext в Spring реализует конкретный вид инверсии управления — Dependency Injection (DI) как частный случай IoC. Это фундаментальная концепция Spring Framework.

Типы инверсии управления (IoC)

1. Dependency Injection (Dependency Inversion)

Это то, что реализует ApplicationContext — контейнер управляет созданием и внедрением зависимостей:

// Без IoC: мы сами создаём зависимости
public class UserService {
    private UserRepository repository;
    
    public UserService() {
        this.repository = new UserRepositoryImpl();  // Плотная связь
    }
}

// С IoC (Dependency Injection)
@Service
public class UserService {
    private final UserRepository repository;
    
    // Spring внедрит нужную реализацию
    public UserService(UserRepository repository) {
        this.repository = repository;
    }
}

ApplicationContext автоматически:

• Создаёт объекты (бины)
• Управляет их жизненным циклом
• Внедряет зависимости

2. Service Locator (альтернативный подход)

Менее предпочтителен, но тоже IoC:

// Service Locator (не рекомендуется)
public class UserService {
    private UserRepository repository;
    
    public UserService() {
        this.repository = ServiceLocator.getService(UserRepository.class);
    }
}

3. Factory Pattern (создание объектов)

Фабрика создаёт объекты, но это не полный IoC:

public class UserServiceFactory {
    public static UserService create() {
        return new UserService(new UserRepositoryImpl());
    }
}

Что именно делает ApplicationContext

ApplicationContext — это контейнер, который реализует Constructor Injection, Setter Injection и Field Injection:

Constructor Injection (рекомендуется)

@Service
public class UserService {
    private final UserRepository repository;
    private final EmailService emailService;
    
    // Spring вызовет этот конструктор и внедрит зависимости
    public UserService(UserRepository repository, EmailService emailService) {
        this.repository = repository;
        this.emailService = emailService;
    }
}

Преимущества:

• Зависимости явные
• Immutable поля
• Легче тестировать
• Нет NPE (NullPointerException)

Setter Injection

@Service
public class UserService {
    private UserRepository repository;
    
    @Autowired
    public void setRepository(UserRepository repository) {
        this.repository = repository;
    }
}

Field Injection (не рекомендуется)

@Service
public class UserService {
    @Autowired
    private UserRepository repository;
    // Проблема: сложнее тестировать, может быть null
}

Как ApplicationContext работает

// 1. Инициализация контейнера
ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);

// 2. ApplicationContext сканирует классы
// 3. Находит @Component, @Service, @Repository, @Controller
// 4. Создаёт бины
// 5. Внедряет зависимости через конструктор, setter или field

// 6. Получаем готовый объект с внедрёнными зависимостями
UserService userService = context.getBean(UserService.class);
userService.processUser("John");  // Работает, все зависимости готовы

Конфигурация ApplicationContext

XML конфигурация (старый стиль)

<beans xmlns="http://www.springframework.org/schema/beans">
    <bean id="userRepository" class="com.example.UserRepositoryImpl"/>
    
    <bean id="userService" class="com.example.UserService">
        <constructor-arg ref="userRepository"/>
    </bean>
</beans>

Java конфигурация (современный подход)

@Configuration
public class AppConfig {
    @Bean
    public UserRepository userRepository() {
        return new UserRepositoryImpl();
    }
    
    @Bean
    public UserService userService(UserRepository repository) {
        // Spring автоматически внедрит repository
        return new UserService(repository);
    }
}

Annotation-based (самый простой)

@Service
public class UserService {
    private final UserRepository repository;
    
    public UserService(UserRepository repository) {
        this.repository = repository;
    }
}

@Repository
public class UserRepositoryImpl implements UserRepository {
    // Spring автоматически создаст бин
}

Жизненный цикл бина в ApplicationContext

@Component
public class MyBean {
    @PostConstruct
    public void init() {
        System.out.println("1. Бин создан");
        System.out.println("2. Зависимости внедрены");
        System.out.println("3. Вызван @PostConstruct");
    }
    
    @PreDestroy
    public void cleanup() {
        System.out.println("Бин уничтожается");
    }
}

Порядок:

1. Инстанцирование
2. Внедрение зависимостей
3. Вызов @PostConstruct
4. Использование
5. Вызов @PreDestroy

Пример полной системы

// 1. Interface (абстракция)
public interface UserRepository {
    User findById(Long id);
}

// 2. Реализация
@Repository
public class UserRepositoryImpl implements UserRepository {
    @Override
    public User findById(Long id) {
        return new User(id, "John");
    }
}

// 3. Сервис с зависимостью
@Service
public class UserService {
    private final UserRepository repository;
    
    // Dependency Injection через конструктор
    public UserService(UserRepository repository) {
        this.repository = repository;
    }
    
    public User getUser(Long id) {
        return repository.findById(id);
    }
}

// 4. Контроллер
@RestController
@RequestMapping("/api/users")
public class UserController {
    private final UserService service;
    
    // Опять DI
    public UserController(UserService service) {
        this.service = service;
    }
    
    @GetMapping("/{id}")
    public User getUser(@PathVariable Long id) {
        return service.getUser(id);
    }
}

// 5. Запуск приложения
@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        // ApplicationContext автоматически:
        // - создаёт UserRepositoryImpl
        // - создаёт UserService и внедряет UserRepositoryImpl
        // - создаёт UserController и внедряет UserService
        SpringApplication.run(Application.class, args);
    }
}

ApplicationContext vs BeanFactory

ApplicationContext — это расширенная версия BeanFactory с дополнительными функциями.

Выводы

• ApplicationContext реализует Dependency Injection — конкретный вид IoC
• Механизм: контейнер управляет созданием и связыванием объектов
• Три варианта внедрения: Constructor (рекомендуется), Setter, Field (не рекомендуется)
• Автоматизация: Spring сканирует, создаёт, и связывает бины
• Преимущества: слабая связанность, легче тестировать, гибче
• Это одна из причин популярности Spring: правильная реализация IoC