Как получить бины из контейнера?

# Получение бинов из Spring контейнера

1. Основной способ: @Autowired (Dependency Injection)

Рекомендуемый и наиболее чистый способ.

@Service
public class UserService {
    // На поле
    @Autowired
    private UserRepository userRepository;
    
    // Или лучше: через конструктор (immutable)
    private final UserRepository userRepository;
    
    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
    
    public User getUserById(Long id) {
        return userRepository.findById(id).orElse(null);
    }
}

@RestController
@RequestMapping("/api/v1/users")
public class UserController {
    private final UserService userService;
    
    @Autowired
    public UserController(UserService userService) {
        this.userService = userService;
    }
    
    @GetMapping("/{id}")
    public User getUser(@PathVariable Long id) {
        return userService.getUserById(id);
    }
}

Плюсы:

• Автоматическое внедрение зависимостей
• Легко тестировать (можно передать mock'и)
• Явная зависимость
• Immutable объекты (через конструктор)

2. ApplicationContext - получение бина программно

Когда нужен прямой доступ к контейнеру.

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.stereotype.Component;

@Component
public class BeanAccessor {
    @Autowired
    private ApplicationContext context;
    
    // Получить бин по типу
    public <T> T getBean(Class<T> requiredType) {
        return context.getBean(requiredType);
    }
    
    // Получить бин по имени
    public Object getBean(String name) {
        return context.getBean(name);
    }
    
    // Получить бин по имени и типу
    public <T> T getBean(String name, Class<T> requiredType) {
        return context.getBean(name, requiredType);
    }
    
    // Проверить существует ли бин
    public boolean containsBean(String name) {
        return context.containsBean(name);
    }
}

// Использование
@Service
public class MyService {
    @Autowired
    private BeanAccessor beanAccessor;
    
    public void doSomething() {
        // Получить бин по типу
        UserRepository userRepo = beanAccessor.getBean(UserRepository.class);
        
        // Получить бин по имени
        Object serviceBean = beanAccessor.getBean("userService");
        
        // Получить бин по имени и типу
        UserService userService = beanAccessor.getBean("userService", UserService.class);
    }
}

3. StaticApplicationContext (для доступа везде)

Осторожно! Использовать только когда совсем нет другого выхода.

import org.springframework.context.ApplicationContext;
import org.springframework.beans.BeansException;

public class ApplicationContextProvider {
    private static ApplicationContext context;
    
    public static void setApplicationContext(ApplicationContext applicationContext) 
            throws BeansException {
        context = applicationContext;
    }
    
    public static ApplicationContext getApplicationContext() {
        return context;
    }
    
    public static <T> T getBean(Class<T> requiredType) {
        return context.getBean(requiredType);
    }
    
    public static <T> T getBean(String name, Class<T> requiredType) {
        return context.getBean(name, requiredType);
    }
}

@Component
public class ApplicationContextInitializer implements ApplicationContextAware {
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) 
            throws BeansException {
        ApplicationContextProvider.setApplicationContext(applicationContext);
    }
}

// Использование (плохая практика!)
public class LegacyClass { // Не Spring-компонент
    public void someMethod() {
        UserService userService = ApplicationContextProvider.getBean(
            "userService", UserService.class);
        User user = userService.getUserById(1L);
    }
}

4. Получение бина с условиями

import org.springframework.beans.factory.ObjectProvider;

@Service
public class ServiceWithOptionalDependency {
    // ObjectProvider - lazy loading и optional
    private final ObjectProvider<CacheService> cacheServiceProvider;
    
    public ServiceWithOptionalDependency(ObjectProvider<CacheService> cacheServiceProvider) {
        this.cacheServiceProvider = cacheServiceProvider;
    }
    
    public void doSomething() {
        // Получить бин если он существует
        cacheServiceProvider.ifAvailable(cache -> {
            cache.put("key", "value");
        });
        
        // Получить бин с default значением
        CacheService cache = cacheServiceProvider.getIfAvailable(
            () -> new NoOpCacheService());
    }
}

5. Получение нескольких бинов одного типа

import org.springframework.beans.factory.ObjectProvider;
import java.util.List;

@Service
public class MultiStrategyService {
    private final List<PaymentProcessor> processors;
    
    public MultiStrategyService(ObjectProvider<List<PaymentProcessor>> processors) {
        this.processors = processors.getIfAvailable(ArrayList::new);
    }
    
    public void processPayment(String type, Order order) {
        processors.stream()
            .filter(p -> p.supports(type))
            .findFirst()
            .ifPresent(p -> p.process(order));
    }
}

// Или через Map
@Service
public class PaymentServiceWithMap {
    private final Map<String, PaymentProcessor> processors;
    
    public PaymentServiceWithMap(Map<String, PaymentProcessor> processors) {
        this.processors = processors;
    }
    
    public void processPayment(String type, Order order) {
        PaymentProcessor processor = processors.get(type);
        if (processor != null) {
            processor.process(order);
        }
    }
}

// Реализации
@Component("credit-card")
public class CreditCardProcessor implements PaymentProcessor {
    @Override
    public void process(Order order) {
        System.out.println("Processing credit card payment");
    }
}

@Component("paypal")
public class PayPalProcessor implements PaymentProcessor {
    @Override
    public void process(Order order) {
        System.out.println("Processing PayPal payment");
    }
}

6. Условные бины (@Conditional)

import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.context.annotation.Conditional;

@Configuration
public class CacheConfiguration {
    @Bean
    @ConditionalOnProperty(
        name = "cache.enabled",
        havingValue = "true",
        matchIfMissing = false
    )
    public CacheService cacheService() {
        return new RedisCacheService();
    }
    
    @Bean
    @ConditionalOnMissingBean(CacheService.class)
    public CacheService defaultCacheService() {
        return new NoOpCacheService();
    }
}

// application.properties
cache.enabled=true

7. ObjectFactory для lazy initialization

import org.springframework.beans.factory.ObjectFactory;

@Service
public class LazyInitializationService {
    private final ObjectFactory<ExpensiveResource> resourceFactory;
    
    public LazyInitializationService(ObjectFactory<ExpensiveResource> resourceFactory) {
        this.resourceFactory = resourceFactory;
    }
    
    public void useResource() {
        // Бин инициализируется только при вызове getObject()
        ExpensiveResource resource = resourceFactory.getObject();
        resource.doSomething();
    }
}

8. Создание бина программно

import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.GenericBeanDefinition;
import org.springframework.context.ConfigurableApplicationContext;

@Component
public class DynamicBeanCreator {
    @Autowired
    private ConfigurableApplicationContext context;
    
    public void createBeanDynamically() {
        // Получить registry
        BeanDefinitionRegistry registry = 
            (BeanDefinitionRegistry) context.getBeanFactory();
        
        // Создать определение бина
        GenericBeanDefinition definition = new GenericBeanDefinition();
        definition.setBeanClass(MyService.class);
        definition.setScope("singleton");
        
        // Зарегистрировать бин
        registry.registerBeanDefinition("myDynamicService", definition);
        
        // Получить бин
        MyService service = context.getBean("myDynamicService", MyService.class);
    }
}

9. Тестирование с бинами

import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.ActiveProfiles;

@SpringBootTest
@ActiveProfiles("test")
public class UserServiceTest {
    @Autowired
    private UserService userService;
    
    @MockBean
    private UserRepository userRepository; // Mock бин
    
    @Test
    void testGetUser() {
        User user = new User(1L, "John");
        when(userRepository.findById(1L)).thenReturn(Optional.of(user));
        
        User result = userService.getUserById(1L);
        
        assertNotNull(result);
        assertEquals("John", result.getName());
    }
}

10. Область видимости бинов (Scope)

@Service // singleton по умолчанию
public class SingletonService {
    // Создается один раз на всё приложение
}

@Service
@Scope("prototype")
public class PrototypeService {
    // Создается новый экземпляр при каждом запросе
}

@Service
@Scope("request") // Только в веб-приложении
public class RequestScopedService {
    // Создается один раз на HTTP request
}

@Service
@Scope("session") // Только в веб-приложении
public class SessionScopedService {
    // Один экземпляр на HTTP session
}

@Service
@Scope(value = "request", proxyMode = ScopedProxyMode.TARGET_CLASS)
public class ProxiedRequestService {
    // Proxy для внедрения request-scoped бина в singleton
}

Best Practices

1. Используй Constructor Injection - immutable, testable, явные зависимости
2. Избегай @Autowired на полях - используй конструктор
3. Не получай бины через ApplicationContext - используй DI
4. Никогда не используй статические ApplicationContextProvider - антипаттерн
5. Используй ObjectProvider для optional зависимостей - graceful handling
6. Избегай циклических зависимостей - redesign архитектуру
7. Профилируй scopes - singleton по умолчанию, меняй только если нужно
8. Тестируй с @SpringBootTest - реальный контекст
9. Используй @MockBean для тестов - замещай реальные бины
10. Документируй зависимости - явно укажи в конструкторе

Правильный паттерн

@Service
public class UserService {
    private final UserRepository userRepository;
    private final EmailService emailService;
    private final CacheService cacheService;
    
    // Constructor injection - явные, immutable зависимости
    public UserService(UserRepository userRepository,
                      EmailService emailService,
                      CacheService cacheService) {
        this.userRepository = userRepository;
        this.emailService = emailService;
        this.cacheService = cacheService;
    }
    
    public void registerUser(User user) {
        userRepository.save(user);
        emailService.sendWelcomeEmail(user);
        cacheService.invalidate("users");
    }
}