Что будет при инъекции бина через интерфейс, если интерфейс имеет две реализации?

Spring выбросит исключение NoUniqueBeanDefinitionException

Проблема неоднозначности

Когда вы пытаетесь инжектить интерфейс, у которого есть несколько реализаций в контексте Spring, контейнер не знает, какую именно реализацию выбрать. Spring выбросит исключение на этапе инициализации приложения:

org.springframework.beans.factory.NoUniqueBeanDefinitionException: 
No qualifying bean of type 'com.example.PaymentService' available: 
expected single matching bean but found 2: paymentServiceImpl, stripePaymentService

Пример, вызывающий ошибку

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

// Первая реализация
@Service
public class PaymentServiceImpl implements PaymentService {
    @Override
    public void processPayment(double amount) {
        System.out.println("Processing with default payment service: " + amount);
    }
}

// Вторая реализация
@Service
public class StripePaymentService implements PaymentService {
    @Override
    public void processPayment(double amount) {
        System.out.println("Processing with Stripe: " + amount);
    }
}

// Использование - ОШИБКАException!
@Service
public class OrderService {
    @Autowired
    private PaymentService paymentService;  // Какую реализацию выбрать?
}

При запуске приложения вы получите NoUniqueBeanDefinitionException.

Решение 1: @Qualifier - явное указание бина

@Service
public class OrderService {
    
    // Явно указываем какую реализацию использовать
    @Autowired
    @Qualifier("stripePaymentService")
    private PaymentService paymentService;
    
    public void createOrder(double amount) {
        paymentService.processPayment(amount);  // Используется StripePaymentService
    }
}

Важно: Имя параметра @Qualifier должно совпадать с именем бина (по умолчанию - имя класса с lowercase первой буквой).

Решение 2: @Primary - выбор по умолчанию

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

// Основная реализация
@Service
@Primary  // Эта реализация используется по умолчанию
public class StripePaymentService implements PaymentService {
    @Override
    public void processPayment(double amount) {
        System.out.println("Processing with Stripe: " + amount);
    }
}

// Альтернативная реализация
@Service
public class PayPalPaymentService implements PaymentService {
    @Override
    public void processPayment(double amount) {
        System.out.println("Processing with PayPal: " + amount);
    }
}

// Теперь работает - используется StripePaymentService
@Service
public class OrderService {
    @Autowired
    private PaymentService paymentService;  // Выбирается Primary бин
}

Решение 3: Комбинация @Qualifier и @Primary

@Service("stripePayment")
@Primary
public class StripePaymentService implements PaymentService {
    @Override
    public void processPayment(double amount) {
        System.out.println("Processing with Stripe: " + amount);
    }
}

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

// Использование
@Service
public class OrderService {
    @Autowired
    @Qualifier("paypalPayment")  // Может переопределить Primary
    private PaymentService paymentService;
}

Решение 4: Инжекция всех реализаций

@Service
public class MultiPaymentService {
    
    // Инжектируем ВСЕ реализации PaymentService
    @Autowired
    private List<PaymentService> paymentServices;
    
    public void processAllPayments(double amount) {
        for (PaymentService service : paymentServices) {
            service.processPayment(amount);
        }
    }
    
    // Или через Map с названиями
    @Autowired
    private Map<String, PaymentService> paymentServiceMap;
    
    public void processWithSpecific(String paymentType, double amount) {
        PaymentService service = paymentServiceMap.get(paymentType);
        if (service != null) {
            service.processPayment(amount);
        }
    }
}

Решение 5: ObjectFactory для ленивой инжекции

@Service
public class OrderService {
    
    @Autowired
    private ObjectFactory<PaymentService> paymentServiceFactory;
    
    public void processOrder(String paymentType, double amount) {
        // Ленивое получение нужного бина
        PaymentService service = paymentServiceFactory.getObject();
        service.processPayment(amount);
    }
}

Решение 6: Java конфигурация с @Bean

@Configuration
public class PaymentConfig {
    
    // Явно определяем какой бин является primary
    @Bean
    @Primary
    public PaymentService primaryPaymentService() {
        return new StripePaymentService();
    }
    
    @Bean
    @Qualifier("secondary")
    public PaymentService secondaryPaymentService() {
        return new PayPalPaymentService();
    }
}

// Использование
@Service
public class OrderService {
    @Autowired
    private PaymentService paymentService;  // Используется StripePaymentService
    
    @Autowired
    @Qualifier("secondary")
    private PaymentService alternativePayment;
}

Решение 7: Инжекция по типу поля (название совпадает с именем бина)

// По имени можно инжектировать автоматически
@Service("paymentService")
public class PaymentServiceImpl implements PaymentService {
    @Override
    public void processPayment(double amount) {
        // implementation
    }
}

@Service
public class OrderService {
    
    // Spring будет искать бин с именем paymentService
    @Autowired
    private PaymentService paymentService;  // Работает благодаря совпадению имени
}

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

// Интерфейс
public interface PaymentProcessor {
    boolean supports(PaymentType type);
    void process(Payment payment);
}

// Реализация 1
@Component
public class CreditCardProcessor implements PaymentProcessor {
    @Override
    public boolean supports(PaymentType type) {
        return PaymentType.CREDIT_CARD == type;
    }
    
    @Override
    public void process(Payment payment) {
        System.out.println("Processing credit card payment");
    }
}

// Реализация 2
@Component
public class CryptoProcessor implements PaymentProcessor {
    @Override
    public boolean supports(PaymentType type) {
        return PaymentType.CRYPTO == type;
    }
    
    @Override
    public void process(Payment payment) {
        System.out.println("Processing crypto payment");
    }
}

// Сервис выбирает нужный процессор
@Service
public class PaymentOrchestrator {
    
    @Autowired
    private List<PaymentProcessor> processors;
    
    public void pay(Payment payment) {
        PaymentProcessor processor = processors.stream()
            .filter(p -> p.supports(payment.getType()))
            .findFirst()
            .orElseThrow(() -> new UnsupportedPaymentTypeException());
        
        processor.process(payment);
    }
}

Когда Spring выбирает бин автоматически

Spring пытается разрешить неоднозначность в таком порядке:

1. @Primary - если есть бин помеченный как primary
2. Имя поля/параметра - если совпадает с именем бина
3. @Qualifier - если явно указан
4. Exception - если ничего не помогло

Лучшие практики

1. Предпочитай @Qualifier - это явно и понятно
2. Используй @Primary умеренно - только для очевидного дефолта
3. Инжектируй List<Interface> - когда нужны несколько реализаций
4. Создавай конфигурационный класс - для сложной логики выбора
5. Документируй выбор - почему используется именно эта реализация

В целом, Spring очень логичен: если неоднозначно - выбросить исключение, чтобы разработчик явно указал, что он хочет.