Как нужно инжектить по полю интерфейс, у которого есть две реализации в Spring

Как нужно инжектить по полю интерфейс, у которого есть две реализации в Spring

Это одна из наиболее частых проблем при работе со Spring Dependency Injection. Когда у интерфейса есть несколько реализаций, Spring не знает, какую инжектить, и выбрасывает исключение NoUniqueBeanDefinitionException. За 10+ лет я встречал это в десятках проектов, и есть несколько правильных способов решения этой проблемы.

Проблема: Неоднозначность

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

// Две реализации
@Service
public class CreditCardPaymentService implements PaymentService {
    @Override
    public void processPayment(BigDecimal amount) {
        System.out.println("Processing credit card payment: " + amount);
    }
}

@Service
public class PayPalPaymentService implements PaymentService {
    @Override
    public void processPayment(BigDecimal amount) {
        System.out.println("Processing PayPal payment: " + amount);
    }
}

// Попытка инжектить - ERROR!
@Service
public class OrderService {
    @Autowired
    private PaymentService paymentService;  // Какую реализацию выбрать?
    // Exception: No qualifying bean of type 'PaymentService' available
}

Решение 1: @Qualifier (НАИЛУЧШИЙ ВАРИАНТ)

Используй аннотацию @Qualifier для явного указания реализации:

@Service
public class OrderService {
    // Способ 1: Инжектить по имени бина
    @Autowired
    @Qualifier("creditCardPaymentService")  // Имя класса в camelCase
    private PaymentService paymentService;
    
    public void checkout(BigDecimal amount) {
        paymentService.processPayment(amount);
        // Использует CreditCardPaymentService
    }
}

// Или более явно - дать кастомное имя
@Service("creditCard")
public class CreditCardPaymentService implements PaymentService {
    @Override
    public void processPayment(BigDecimal amount) {
        System.out.println("Processing credit card: " + amount);
    }
}

@Service("paypal")
public class PayPalPaymentService implements PaymentService {
    @Override
    public void processPayment(BigDecimal amount) {
        System.out.println("Processing PayPal: " + amount);
    }
}

// Инжектим с кастомными именами
@Service
public class OrderService {
    @Autowired
    @Qualifier("creditCard")
    private PaymentService creditCardPayment;
    
    @Autowired
    @Qualifier("paypal")
    private PaymentService paypalPayment;
    
    public void checkout(String method, BigDecimal amount) {
        if ("creditCard".equals(method)) {
            creditCardPayment.processPayment(amount);
        } else {
            paypalPayment.processPayment(amount);
        }
    }
}

Решение 2: Constructor Injection с @Qualifier

Это современный и рекомендуемый подход:

@Service
public class OrderService {
    private final PaymentService paymentService;
    
    // Constructor Injection с @Qualifier
    public OrderService(@Qualifier("paypal") PaymentService paymentService) {
        this.paymentService = paymentService;
    }
    
    public void checkout(BigDecimal amount) {
        paymentService.processPayment(amount);
    }
}

// Тестирование легче
@Test
public void testCheckout() {
    PaymentService mockService = mock(PaymentService.class);
    OrderService service = new OrderService(mockService);
    service.checkout(BigDecimal.TEN);
    verify(mockService).processPayment(BigDecimal.TEN);
}

Решение 3: Кастомная аннотация (ЭЛЕГАНТНЫЙ ПОДХОД)

Для сложных случаев создай кастомную аннотацию:

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

// Используем на реализации
@Service
@CreditCardPayment
public class CreditCardPaymentService implements PaymentService {
    @Override
    public void processPayment(BigDecimal amount) {
        System.out.println("Processing credit card");
    }
}

// Инжектим с кастомной аннотацией
@Service
public class OrderService {
    private final PaymentService paymentService;
    
    public OrderService(@CreditCardPayment PaymentService paymentService) {
        this.paymentService = paymentService;
    }
}

// Преимущество: можно инжектить несколько реализаций
@Service
public class MultiPaymentService {
    private final PaymentService creditCard;
    private final PaymentService paypal;
    
    public MultiPaymentService(
            @CreditCardPayment PaymentService creditCard,
            @PayPalPayment PaymentService paypal) {
        this.creditCard = creditCard;
        this.paypal = paypal;
    }
}

Решение 4: @Primary (ПРОСТО, НО МЕНЕЕ ГИБКО)

Обозначь одну реализацию как основную:

// Основная реализация
@Service
@Primary  // Эта будет использоваться по умолчанию
public class CreditCardPaymentService implements PaymentService {
    @Override
    public void processPayment(BigDecimal amount) {
        System.out.println("Processing credit card (primary)");
    }
}

// Вторая реализация
@Service
public class PayPalPaymentService implements PaymentService {
    @Override
    public void processPayment(BigDecimal amount) {
        System.out.println("Processing PayPal");
    }
}

// Инжектим просто
@Service
public class OrderService {
    private final PaymentService paymentService;
    
    public OrderService(PaymentService paymentService) {
        // Получит CreditCardPaymentService (помечена @Primary)
        this.paymentService = paymentService;
    }
}

// Если нужна другая - используй @Qualifier
@Service
public class AlternativePaymentService {
    private final PaymentService paypal;
    
    public AlternativePaymentService(
            @Qualifier("payPalPaymentService") PaymentService paypal) {
        this.paypal = paypal;
    }
}

Решение 5: Инжектить все реализации (РЕДКО, но возможно)

@Service
public class PaymentProcessor {
    private final List<PaymentService> paymentServices;
    
    // Spring инжектит все реализации
    public PaymentProcessor(List<PaymentService> paymentServices) {
        this.paymentServices = paymentServices;
    }
    
    public void processWithAll(BigDecimal amount) {
        for (PaymentService service : paymentServices) {
            service.processPayment(amount);
        }
    }
}

// Или через Map с именами
@Service
public class PaymentFactory {
    private final Map<String, PaymentService> paymentServices;
    
    public PaymentFactory(List<PaymentService> services) {
        this.paymentServices = services.stream()
            .collect(Collectors.toMap(
                service -> service.getClass().getSimpleName(),
                Function.identity()
            ));
    }
    
    public PaymentService getPaymentService(String type) {
        return paymentServices.get(type);
    }
}

Решение 6: Java Configuration (для бина из условия)

Если нужна гибкая логика выбора:

@Configuration
public class PaymentConfig {
    @Bean
    @ConditionalOnProperty(name = "payment.type", havingValue = "creditcard")
    public PaymentService paymentService(CreditCardPaymentService creditCard) {
        return creditCard;
    }
    
    @Bean
    @ConditionalOnProperty(name = "payment.type", havingValue = "paypal")
    public PaymentService paypalService(PayPalPaymentService paypal) {
        return paypal;
    }
}

// application.yml
payment:
  type: creditcard  # Или paypal

Полный пример: правильная архитектура

// Интерфейс с doc
public interface PaymentGateway {
    PaymentResult process(Payment payment);
}

// Кастомные аннотации для каждого способа
@Target({ElementType.TYPE, ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
@Qualifier
public @interface CreditCard {}

@Target({ElementType.TYPE, ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
@Qualifier
public @interface PayPal {}

// Реализации
@Service
@CreditCard
public class CreditCardGateway implements PaymentGateway {
    @Override
    public PaymentResult process(Payment payment) {
        // Логика платежа через кредитную карту
        return new PaymentResult("SUCCESS", "CARD");
    }
}

@Service
@PayPal
public class PayPalGateway implements PaymentGateway {
    @Override
    public PaymentResult process(Payment payment) {
        // Логика платежа через PayPal
        return new PaymentResult("SUCCESS", "PAYPAL");
    }
}

// Использование в сервисе
@Service
public class CheckoutService {
    private final PaymentGateway creditCardGateway;
    private final PaymentGateway paypalGateway;
    
    public CheckoutService(
            @CreditCard PaymentGateway creditCardGateway,
            @PayPal PaymentGateway paypalGateway) {
        this.creditCardGateway = creditCardGateway;
        this.paypalGateway = paypalGateway;
    }
    
    public void checkout(Payment payment, String method) {
        PaymentGateway gateway = "creditCard".equals(method) 
            ? creditCardGateway 
            : paypalGateway;
        
        PaymentResult result = gateway.process(payment);
        // Обработать результат
    }
}

// Тестирование
@SpringBootTest
class CheckoutServiceTest {
    @MockBean
    @CreditCard
    PaymentGateway mockCreditCard;
    
    @MockBean
    @PayPal
    PaymentGateway mockPaypal;
    
    @Autowired
    CheckoutService service;
    
    @Test
    void testCheckoutWithCreditCard() {
        Payment payment = new Payment(BigDecimal.TEN);
        service.checkout(payment, "creditCard");
        verify(mockCreditCard).process(payment);
    }
}

Рекомендации

Для простых случаев (2-3 реализации):

• Используй @Qualifier("name")
• Или кастомную аннотацию для читаемости

Для complex логики:

• Java Configuration с условиями
• Factory pattern

Избегай:

• Field injection вообще (используй constructor)
• Хранения множества if-else в коде
• Циклических зависимостей

Заключение

@Qualifier — стандартное решение для неоднозначности бинов в Spring. Лучше всего использовать constructor injection с кастомными аннотациями для максимальной читаемости и тестируемости.