Какой контейнер Spring Boot реализует принцип зависимости кода от абстракций?

ApplicationContext: контейнер Spring Boot для Dependency Injection

Что такое ApplicationContext?

ApplicationContext — это центральный IoC контейнер (Inversion of Control) в Spring Boot/Spring Framework, который реализует принцип зависимости кода от абстракций (Dependency Inversion Principle из SOLID).

ApplicationContext:

• Управляет созданием и жизненным циклом объектов (beans)
• Внедряет зависимости через конструктор, setter или field injection
• Позволяет коду зависеть от интерфейсов, а не от конкретных реализаций

Как ApplicationContext реализует DIP

Dependency Inversion Principle (DIP):

Высокоуровневые модули не должны зависеть от низкоуровневых. Оба должны зависеть от абстракций.

// ❌ Плохо: прямая зависимость от конкретной реализации
public class UserService {
    private MySQLDatabase database = new MySQLDatabase();  // Зависит от конкретной БД
    
    public User getUser(Long id) {
        return database.findById(id);
    }
}

// ✅ Хорошо: зависимость от абстракции (interface)
public interface UserRepository {
    User findById(Long id);
}

public class UserService {
    private UserRepository repository;  // Зависит от интерфейса
    
    public UserService(UserRepository repository) {
        this.repository = repository;
    }
    
    public User getUser(Long id) {
        return repository.findById(id);
    }
}

Роль ApplicationContext

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

// 1. Определяем абстракцию (interface)
public interface UserRepository {
    User findById(Long id);
}

// 2. Создаём реализацию (bean)
@Repository
public class JpaUserRepository implements UserRepository {
    @Override
    public User findById(Long id) {
        // реализация
    }
}

// 3. UserService зависит только от интерфейса
@Service
public class UserService {
    private UserRepository repository;
    
    // ApplicationContext внедрит нужную реализацию
    public UserService(UserRepository repository) {
        this.repository = repository;
    }
}

// 4. Spring ApplicationContext управляет всем
@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        // ApplicationContext создаёт beans и внедряет зависимости
        ApplicationContext context = SpringApplication.run(Application.class, args);
        
        UserService service = context.getBean(UserService.class);
        // UserService получил JpaUserRepository автоматически!
    }
}

Типы ApplicationContext

1. ClassPathXmlApplicationContext (старое, конфигурация через XML)

ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

2. AnnotationConfigApplicationContext (аннотации)

@Configuration
public class AppConfig {
    @Bean
    public UserRepository userRepository() {
        return new JpaUserRepository();
    }
}

ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);

3. SpringApplication.run() (Spring Boot)

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        ApplicationContext context = SpringApplication.run(Application.class, args);
    }
}

Практический пример с DIP

// 1. Абстракция (интерфейс)
public interface PaymentProcessor {
    void processPayment(BigDecimal amount);
}

// 2. Конкретные реализации
@Component
public class CreditCardProcessor implements PaymentProcessor {
    @Override
    public void processPayment(BigDecimal amount) {
        System.out.println("Processing credit card: " + amount);
    }
}

@Component
public class PayPalProcessor implements PaymentProcessor {
    @Override
    public void processPayment(BigDecimal amount) {
        System.out.println("Processing PayPal: " + amount);
    }
}

// 3. Высокоуровневый модуль зависит от абстракции
@Service
public class OrderService {
    private final PaymentProcessor paymentProcessor;
    
    public OrderService(PaymentProcessor paymentProcessor) {
        this.paymentProcessor = paymentProcessor;
    }
    
    public void createOrder(BigDecimal total) {
        // Не зависит от конкретной реализации!
        paymentProcessor.processPayment(total);
    }
}

// 4. Конфигурация
@Configuration
public class PaymentConfig {
    @Bean
    public PaymentProcessor paymentProcessor() {
        // Можно легко переключить реализацию
        return new CreditCardProcessor();
        // или return new PayPalProcessor();
    }
}

// 5. Использование
@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        ApplicationContext context = SpringApplication.run(Application.class, args);
        
        OrderService orderService = context.getBean(OrderService.class);
        orderService.createOrder(BigDecimal.valueOf(100));
        // Выведет: Processing credit card: 100
    }
}

Методы внедрения зависимостей

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

@Service
public class UserService {
    private final UserRepository repository;
    
    // Spring внедрит через конструктор
    public UserService(UserRepository repository) {
        this.repository = repository;
    }
}

**2. Setter Injection

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

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

@Service
public class UserService {
    @Autowired
    private UserRepository repository;  // Сложнее тестировать
}

Как ApplicationContext находит реализацию

// 1. По типу (Type matching)
@Service
public class UserService {
    private UserRepository repository;  // Ищет bean типа UserRepository
    
    public UserService(UserRepository repository) {
        this.repository = repository;
    }
}

// 2. По имени (Name matching)
@Repository("jpaUserRepository")
public class JpaUserRepository implements UserRepository { }

@Service
public class UserService {
    public UserService(@Qualifier("jpaUserRepository") UserRepository repo) {
        // Внедрит именно jpaUserRepository
    }
}

// 3. По первичности (Primary)
@Repository
@Primary
public class JpaUserRepository implements UserRepository { }  // Используется по умолчанию

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

public class UserRepository {
    
    @PostConstruct
    public void init() {
        System.out.println("1. Bean создан");
    }
    
    public void save(User user) {
        System.out.println("2. Бин используется");
    }
    
    @PreDestroy
    public void cleanup() {
        System.out.println("3. Bean уничтожается");
    }
}

Преимущества использования ApplicationContext

• Слабая связанность — код зависит от интерфейсов, а не от реализаций
• Лёгкое тестирование — можно подменять реализации на mock объекты
• Гибкость — можно менять реализацию без изменения кода
• Централизованное управление — все зависимости в одном месте

// Тестирование с mock
@ExtendWith(MockitoExtension.class)
public class UserServiceTest {
    
    @Mock
    private UserRepository repository;
    
    @InjectMocks
    private UserService service;
    
    @Test
    public void testGetUser() {
        User user = new User();
        when(repository.findById(1L)).thenReturn(user);
        
        User result = service.getUser(1L);
        
        assertEquals(user, result);
    }
}

Резюме

ApplicationContext — это IoC контейнер, который реализует Dependency Inversion Principle благодаря:

1. Управлению бинами — создание и регистрация объектов
2. Внедрению зависимостей — код не создаёт зависимости сам
3. Работе с абстракциями — связь между компонентами через интерфейсы
4. Конфигурируемости — можно менять реализации без изменения кода

Это позволяет писать гибкий, тестируемый и поддерживаемый код.