Можно ли заинжектить список из Bean в Spring?

Инъекция списков Bean в Spring

Короткий ответ

Да, полностью можно! Spring автоматически собирает все Bean'ы нужного типа в List и инжектит их. Это очень удобная фишка для создания плагинов, обработчиков и расширений.

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

When you declare a dependency of type List<T>, Spring automatically injects all beans of type T that exist in the application context.

@Component
public class PaymentProcessor {
    private final List<PaymentGateway> gateways;
    
    // Spring найдёт все Bean'ы типа PaymentGateway и заинжектит их
    public PaymentProcessor(List<PaymentGateway> gateways) {
        this.gateways = gateways;
    }
    
    public void processPayment(String provider, double amount) {
        PaymentGateway gateway = gateways.stream()
            .filter(g -> g.supports(provider))
            .findFirst()
            .orElseThrow(() -> new IllegalArgumentException("Provider not found"));
        
        gateway.process(amount);
    }
}

Определение Bean'ов

// Интерфейс
public interface PaymentGateway {
    boolean supports(String provider);
    void process(double amount);
}

// Реализации
@Component
public class StripeGateway implements PaymentGateway {
    @Override
    public boolean supports(String provider) {
        return "stripe".equals(provider);
    }
    
    @Override
    public void process(double amount) {
        System.out.println("Processing via Stripe: " + amount);
    }
}

@Component
public class PayPalGateway implements PaymentGateway {
    @Override
    public boolean supports(String provider) {
        return "paypal".equals(provider);
    }
    
    @Override
    public void process(double amount) {
        System.out.println("Processing via PayPal: " + amount);
    }
}

@Component
public class ApplePayGateway implements PaymentGateway {
    @Override
    public boolean supports(String provider) {
        return "applepay".equals(provider);
    }
    
    @Override
    public void process(double amount) {
        System.out.println("Processing via Apple Pay: " + amount);
    }
}

Порядок инъекции

@Component
public class OrderService {
    private final List<PaymentGateway> gateways;
    
    public OrderService(List<PaymentGateway> gateways) {
        // gateways содержит все 3 реализации
        // Порядок: зависит от порядка загрузки Bean'ов
        System.out.println("Инжектено гейтвеев: " + gateways.size());
    }
}

Управление порядком: @Order и @Priority

import org.springframework.core.annotation.Order;

@Component
@Order(1)  // Будет первым в списке
public class StripeGateway implements PaymentGateway {
    // ...
}

@Component
@Order(2)
public class PayPalGateway implements PaymentGateway {
    // ...
}

@Component
@Order(3)
public class ApplePayGateway implements PaymentGateway {
    // ...
}

Теперь при инъекции список будет в порядке: Stripe → PayPal → ApplePay.

Альтернатива: Map<String, T>

@Component
public class PaymentFactory {
    private final Map<String, PaymentGateway> gateways;
    
    public PaymentFactory(Map<String, PaymentGateway> gateways) {
        // Ключ = имя Bean'а, значение = инстанс
        this.gateways = gateways;
    }
    
    public PaymentGateway getGateway(String provider) {
        return gateways.get(provider);
    }
}

Для этого Bean'ы должны быть названы как provider:

@Component("stripe")
public class StripeGateway implements PaymentGateway { }

@Component("paypal")
public class PayPalGateway implements PaymentGateway { }

@Component("applepay")
public class ApplePayGateway implements PaymentGateway { }

Тогда использование:

paymentFactory.getGateway("stripe").process(100);

Инъекция в методе (Optional элементы)

@Component
public class NotificationService {
    
    public void notify(String message) {
        // Инжектить можно и в методы
    }
}

@Component
public class UserService {
    private final List<NotificationService> notifiers;
    
    public UserService(List<NotificationService> notifiers) {
        // Если нет ни одного Bean'а - пустой список, не ошибка
        this.notifiers = notifiers;
    }
}

Практический пример: Обработчики событий

// Событие
public record UserCreatedEvent(String userId, String email) {}

// Обработчик
public interface EventHandler<T> {
    void handle(T event);
}

// Реализации
@Component
public class SendWelcomeEmailHandler implements EventHandler<UserCreatedEvent> {
    @Override
    public void handle(UserCreatedEvent event) {
        System.out.println("Отправка приветственного письма на " + event.email());
    }
}

@Component
public class CreateUserProfileHandler implements EventHandler<UserCreatedEvent> {
    @Override
    public void handle(UserCreatedEvent event) {
        System.out.println("Создание профиля для " + event.userId());
    }
}

@Component
public class LogUserCreationHandler implements EventHandler<UserCreatedEvent> {
    @Override
    public void handle(UserCreatedEvent event) {
        System.out.println("Логирование создания пользователя");
    }
}

// Публикатор
@Component
public class EventPublisher {
    private final List<EventHandler<UserCreatedEvent>> handlers;
    
    public EventPublisher(List<EventHandler<UserCreatedEvent>> handlers) {
        this.handlers = handlers;
    }
    
    public void publish(UserCreatedEvent event) {
        handlers.forEach(handler -> handler.handle(event));
    }
}

// Использование
@Service
public class UserServiceImpl {
    private final EventPublisher eventPublisher;
    
    public UserServiceImpl(EventPublisher eventPublisher) {
        this.eventPublisher = eventPublisher;
    }
    
    public void createUser(String email) {
        // Создание пользователя...
        eventPublisher.publish(new UserCreatedEvent("123", email));
        // Все 3 handler'а автоматически вызовутся
    }
}

С использованием ObjectProvider (Spring 5.1+)

import org.springframework.beans.factory.ObjectProvider;

@Component
public class RobustPaymentProcessor {
    private final ObjectProvider<PaymentGateway> gatewayProvider;
    
    public RobustPaymentProcessor(ObjectProvider<PaymentGateway> gatewayProvider) {
        this.gatewayProvider = gatewayProvider;
    }
    
    public void process(String provider, double amount) {
        // Более гибкая работа с Bean'ами
        gatewayProvider.stream()
            .filter(g -> g.supports(provider))
            .findFirst()
            .ifPresentOrElse(
                g -> g.process(amount),
                () -> System.out.println("Provider not found")
            );
    }
}

Инъекция с использованием конструктора vs @Autowired

// ✅ Лучше: конструктор (явная зависимость)
@Component
public class MyService {
    private final List<Handler> handlers;
    
    public MyService(List<Handler> handlers) {
        this.handlers = handlers;
    }
}

// ⚠️ Можно, но менее рекомендуемо: поле
@Component
public class MyService {
    @Autowired
    private List<Handler> handlers;
}

// ⚠️ Можно: setter
@Component
public class MyService {
    private List<Handler> handlers;
    
    @Autowired
    public void setHandlers(List<Handler> handlers) {
        this.handlers = handlers;
    }
}

Тестирование с List Bean'ами

@SpringBootTest
class PaymentProcessorTest {
    
    @Test
    void testMultipleGateways(@Autowired List<PaymentGateway> gateways) {
        assertEquals(3, gateways.size());
    }
    
    @Test
    void testWithMockList() {
        List<PaymentGateway> mockGateways = Arrays.asList(
            mock(PaymentGateway.class),
            mock(PaymentGateway.class)
        );
        
        PaymentProcessor processor = new PaymentProcessor(mockGateways);
        // ...
    }
}

Важные моменты

1. Пустой список OK — если нет Bean'ов нужного типа, инжектится пустой список
2. Порядок важен — используй @Order если нужен конкретный порядок
3. Не забывай @Component — Bean'ы должны быть в контексте Spring
4. Generics работают — List<T> автоматически определяется по типу
5. Одиночные Bean'ы тоже инжектятся — List из одного элемента работает нормально

Когда использовать

• Паттерн Strategy (несколько реализаций одного интерфейса)
• Обработчики событий (Event Handlers)
• Плагины и расширения
• Фабрики (Factory Pattern)
• Цепочки обработки (Chain of Responsibility)

Вывод

Инъекция List<Bean> в Spring — это мощный инструмент для создания гибких и расширяемых приложений. Это позволяет легко добавлять новые реализации без изменения существующего кода.