Какие знаешь способы решения проблемы, когда в Bean несколько кандидатов для одной зависимости?

Способы решения проблемы с несколькими Bean кандидатами в Spring

Когда в контексте Spring несколько Bean'ов одного типа, при инъекции зависимости возникает ошибка: No qualifying bean of type ... expected single matching bean but found N. Рассмотрим все способы решения.

1. @Primary аннотация

Отмечаем основной Bean, который используется по умолчанию:

// Интерфейс
public interface PaymentService {
    void pay(BigDecimal amount);
}

// Реализация 1
@Service
public class CreditCardPaymentService implements PaymentService {
    @Override
    public void pay(BigDecimal amount) {
        System.out.println("Оплата кредитной картой");
    }
}

// Реализация 2 (основная)
@Service
@Primary  // Этот Bean используется по умолчанию
public class PayPalPaymentService implements PaymentService {
    @Override
    public void pay(BigDecimal amount) {
        System.out.println("Оплата через PayPal");
    }
}

// В контроллере
@RestController
public class OrderController {
    
    @Autowired
    private PaymentService paymentService;  // Будет injected PayPalPaymentService
    
    @PostMapping("/orders")
    public void createOrder(Order order) {
        paymentService.pay(order.getAmount());
    }
}

@Primary работает, когда есть одна основная реализация, остальные используются редко.

2. @Qualifier аннотация

Явно указываем, какой Bean нужен:

@Service("creditCard")
public class CreditCardPaymentService implements PaymentService {
    @Override
    public void pay(BigDecimal amount) {
        System.out.println("Оплата кредитной картой");
    }
}

@Service("paypal")
public class PayPalPaymentService implements PaymentService {
    @Override
    public void pay(BigDecimal amount) {
        System.out.println("Оплата через PayPal");
    }
}

// Использование
@RestController
public class OrderController {
    
    @Autowired
    @Qualifier("paypal")  // Конкретно PayPalPaymentService
    private PaymentService paymentService;
    
    @Autowired
    @Qualifier("creditCard")
    private PaymentService creditCardService;
}

Это явное и понятное решение.

3. Кастомная @Qualifier аннотация

Создаём свою аннотацию для более удобного использования:

// Создаём кастомную аннотацию
@Target({ElementType.FIELD, ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
@Qualifier
public @interface PaymentMethod {
    String value();
}

// Реализации
@Service
@PaymentMethod("creditCard")
public class CreditCardPaymentService implements PaymentService {
    @Override
    public void pay(BigDecimal amount) {
        System.out.println("Оплата кредитной картой");
    }
}

@Service
@PaymentMethod("paypal")
public class PayPalPaymentService implements PaymentService {
    @Override
    public void pay(BigDecimal amount) {
        System.out.println("Оплата через PayPal");
    }
}

// Использование
@RestController
public class OrderController {
    
    @Autowired
    @PaymentMethod("paypal")
    private PaymentService paymentService;
}

Это более семантичное и типобезопасное решение.

4. ObjectFactory / ObjectProvider (ленивая инъекция)

Получаем Bean'ы лениво (когда нужны), а не при инициализации контекста:

@Service
public class PaymentProcessor {
    
    @Autowired
    private ObjectProvider<PaymentService> paymentServices;
    
    public void processPayment(String method, BigDecimal amount) {
        // Получаем конкретный Bean
        PaymentService service = paymentServices
            .getIfAvailable(() -> new DefaultPaymentService());
        
        service.pay(amount);
    }
    
    // Или получаем все Bean'ы определённого типа
    public void processAllPayments(BigDecimal amount) {
        paymentServices.forEach(service -> {
            service.pay(amount);
        });
    }
}

5. List/Set/Map инъекция (получаем все Bean'ы)

Если нужны все реализации:

// Получаем все Bean'ы PaymentService
@Service
public class PaymentFactory {
    
    private final Map<String, PaymentService> paymentServices;
    
    // Spring автоматически заполняет Map со всеми Bean'ами
    @Autowired
    public PaymentFactory(Map<String, PaymentService> paymentServices) {
        this.paymentServices = paymentServices;
    }
    
    public PaymentService getPaymentService(String name) {
        return paymentServices.get(name);  // Может быть null
    }
    
    public List<PaymentService> getAllServices() {
        return new ArrayList<>(paymentServices.values());
    }
}

// Использование
@RestController
public class OrderController {
    
    @Autowired
    private PaymentFactory paymentFactory;
    
    @PostMapping("/orders")
    public void createOrder(@RequestBody Order order) {
        PaymentService service = paymentFactory.getPaymentService(order.getPaymentMethod());
        service.pay(order.getAmount());
    }
}

6. Spring Profiles (условная регистрация)

Берём разные Bean'ы для разных окружений:

public interface PaymentService {
    void pay(BigDecimal amount);
}

// Для production
@Service
@Profile("prod")
public class RealPaymentService implements PaymentService {
    @Override
    public void pay(BigDecimal amount) {
        System.out.println("Реальная оплата");
    }
}

// Для разработки и тестов
@Service
@Profile({"dev", "test"})
public class MockPaymentService implements PaymentService {
    @Override
    public void pay(BigDecimal amount) {
        System.out.println("Mock оплата (разработка)");
    }
}

// application.yml
spring:
  profiles:
    active: dev  # или prod для production

7. Conditional (@Conditional)

Условная регистрация Bean'ов:

// Условие
public class PayPalAvailableCondition implements Condition {
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        String paypalKey = context.getEnvironment().getProperty("paypal.api.key");
        return paypalKey != null && !paypalKey.isEmpty();
    }
}

// Использование условия
@Service
@Conditional(PayPalAvailableCondition.class)
public class PayPalPaymentService implements PaymentService {
    @Override
    public void pay(BigDecimal amount) {
        System.out.println("Оплата через PayPal");
    }
}

// Fallback
@Service
public class DefaultPaymentService implements PaymentService {
    @Override
    public void pay(BigDecimal amount) {
        System.out.println("Стандартная оплата");
    }
}

8. Java @Configuration класс

Программная регистрация Bean'ов:

@Configuration
public class PaymentConfig {
    
    @Bean
    @ConditionalOnProperty(name = "payment.provider", havingValue = "paypal")
    public PaymentService paypalPaymentService() {
        return new PayPalPaymentService();
    }
    
    @Bean
    @ConditionalOnProperty(name = "payment.provider", havingValue = "stripe")
    public PaymentService stripePaymentService() {
        return new StripePaymentService();
    }
    
    @Bean
    @ConditionalOnMissingBean(PaymentService.class)  // Если ничего не подошло
    public PaymentService defaultPaymentService() {
        return new DefaultPaymentService();
    }
    
    // Именованные Bean'ы
    @Bean("paypal")
    public PaymentService paypal() {
        return new PayPalPaymentService();
    }
    
    @Bean("stripe")
    public PaymentService stripe() {
        return new StripePaymentService();
    }
}

9. Strategy Pattern + Factory

Проектный паттерн для выбора реализации:

// Enum со стратегиями
public enum PaymentStrategy {
    CREDIT_CARD,
    PAYPAL,
    STRIPE
}

// Factory
@Component
public class PaymentServiceFactory {
    
    private final CreditCardPaymentService creditCard;
    private final PayPalPaymentService paypal;
    private final StripePaymentService stripe;
    
    @Autowired
    public PaymentServiceFactory(
            CreditCardPaymentService creditCard,
            PayPalPaymentService paypal,
            StripePaymentService stripe) {
        this.creditCard = creditCard;
        this.paypal = paypal;
        this.stripe = stripe;
    }
    
    public PaymentService getService(PaymentStrategy strategy) {
        switch (strategy) {
            case CREDIT_CARD:
                return creditCard;
            case PAYPAL:
                return paypal;
            case STRIPE:
                return stripe;
            default:
                throw new IllegalArgumentException("Unknown strategy: " + strategy);
        }
    }
}

// Использование
@RestController
public class OrderController {
    
    @Autowired
    private PaymentServiceFactory factory;
    
    @PostMapping("/orders")
    public void createOrder(@RequestBody Order order) {
        PaymentService service = factory.getService(order.getPaymentStrategy());
        service.pay(order.getAmount());
    }
}

10. Lookup Method Injection (редко)

Для специфичных случаев когда нужна прототипная область:

public abstract class PaymentServiceBase {
    // Абстрактный метод для injection
    protected abstract PaymentService getPaymentService();
    
    public void process(BigDecimal amount) {
        getPaymentService().pay(amount);
    }
}

@Service
public class PaymentProcessor extends PaymentServiceBase {
    
    @Override
    @Lookup  // Spring генерирует реализацию
    protected PaymentService getPaymentService() {
        return null;  // Spring переопределит метод
    }
}

Сравнение подходов

Best Practices

// ❌ Плохо: конфликт Bean'ов без явного выбора
@Service
public class OrderService {
    @Autowired
    private PaymentService paymentService;  // Ошибка, 2 кандидата!
}

// ✅ Хорошо: явное указание
@Service
public class OrderService {
    @Autowired
    @Qualifier("paypal")
    private PaymentService paymentService;
}

// ✅ Или с кастомной аннотацией
@Service
public class OrderService {
    @Autowired
    @PaymentMethod("paypal")
    private PaymentService paymentService;
}

// ✅ Или через Factory
@Service
public class OrderService {
    @Autowired
    private PaymentServiceFactory factory;
    
    public void createOrder(Order order) {
        PaymentService service = factory.getService(order.getPaymentMethod());
    }
}

Рекомендуемый подход

Для большинства случаев рекомендуется:

1. Простой выбор → @Qualifier или @Primary
2. Много реализаций → Map инъекция + Factory
3. Условная регистрация → @Profiles или @Conditional
4. Сложная логика → Strategy Pattern + Factory