Как вызвать нужный Bean если создано несколько с одинаковыми именами

Вызов нужного Bean при наличии нескольких с одинаковыми именами

Эта ситуация возникает когда есть несколько реализаций одного интерфейса. Spring предоставляет несколько способов разрешить эту неоднозначность.

1. Использование @Primary

Маркирует один бин как приоритетный по умолчанию.

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

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

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

// Использование - будет использован PayPalPaymentService
@Service
public class OrderService {
    private final PaymentService paymentService;
    
    public OrderService(PaymentService paymentService) {
        this.paymentService = paymentService;  // Инъецирует PayPalPaymentService
    }
    
    public void checkout(double amount) {
        paymentService.processPayment(amount);
    }
}

2. Использование @Qualifier

Явно указывает какой бин нужно использовать.

// Реализации с именами
@Service
@Qualifier("creditCard")
public class CreditCardPaymentService implements PaymentService {
    @Override
    public void processPayment(double amount) {
        System.out.println("Credit card: " + amount);
    }
}

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

// Использование с @Qualifier
@Service
public class OrderService {
    private final PaymentService creditCardPayment;
    private final PaymentService paypalPayment;
    
    public OrderService(
            @Qualifier("creditCard") PaymentService creditCardPayment,
            @Qualifier("paypal") PaymentService paypalPayment) {
        this.creditCardPayment = creditCardPayment;
        this.paypalPayment = paypalPayment;
    }
    
    public void checkoutWithCreditCard(double amount) {
        creditCardPayment.processPayment(amount);
    }
    
    public void checkoutWithPayPal(double amount) {
        paypalPayment.processPayment(amount);
    }
}

3. Использование @Resource

Альтернатива @Autowired с явным указанием имени.

@Service
public class PaymentProcessingService {
    @Resource(name = "creditCardPaymentService")
    private PaymentService creditCardService;
    
    @Resource(name = "payPalPaymentService")
    private PaymentService paypalService;
    
    public void processPayment(String method, double amount) {
        if ("creditcard".equals(method)) {
            creditCardService.processPayment(amount);
        } else if ("paypal".equals(method)) {
            paypalService.processPayment(amount);
        }
    }
}

4. Получение всех бинов из ApplicationContext

Добавить все реализации в Map или List.

@Service
public class PaymentDispatcher {
    private final Map<String, PaymentService> paymentServices;
    
    // Spring автоматически инъецирует все реализации в Map
    public PaymentDispatcher(Map<String, PaymentService> paymentServices) {
        this.paymentServices = paymentServices;
    }
    
    public void process(String method, double amount) {
        PaymentService service = paymentServices.get(method);
        if (service != null) {
            service.processPayment(amount);
        } else {
            throw new IllegalArgumentException("Unknown payment method: " + method);
        }
    }
    
    public void listAvailableMethods() {
        paymentServices.keySet().forEach(System.out::println);
    }
}

5. Использование List для инъекции

Получить все реализации интерфейса как список.

@Service
public class PaymentChainService {
    private final List<PaymentService> paymentServices;
    
    public PaymentChainService(List<PaymentService> paymentServices) {
        this.paymentServices = paymentServices;  // Все реализации
    }
    
    public void processPaymentSequentially(double amount) {
        for (PaymentService service : paymentServices) {
            System.out.println("Service: " + service.getClass().getSimpleName());
            service.processPayment(amount);
        }
    }
}

6. Кастомные аннотации

Создать свою аннотацию для удобства.

import org.springframework.beans.factory.annotation.Qualifier;
import java.lang.annotation.*;

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

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

// Использование аннотаций
@Service
@CreditCardPaymentQualifier
public class CreditCardPaymentService implements PaymentService {
    @Override
    public void processPayment(double amount) {
        System.out.println("Credit card payment: " + amount);
    }
}

@Service
public class OrderService {
    private final PaymentService paymentService;
    
    public OrderService(@CreditCardPaymentQualifier PaymentService paymentService) {
        this.paymentService = paymentService;
    }
}

7. Использование ObjectProvider

Для ленивого получения и опциональной инъекции.

@Service
public class FlexiblePaymentService {
    private final ObjectProvider<PaymentService> creditCardProvider;
    private final ObjectProvider<PaymentService> paypalProvider;
    
    public FlexiblePaymentService(
            @Qualifier("creditCard") ObjectProvider<PaymentService> creditCardProvider,
            @Qualifier("paypal") ObjectProvider<PaymentService> paypalProvider) {
        this.creditCardProvider = creditCardProvider;
        this.paypalProvider = paypalProvider;
    }
    
    public void processPayment(String method, double amount) {
        if ("creditcard".equals(method)) {
            creditCardProvider.ifAvailable(service -> service.processPayment(amount));
        } else if ("paypal".equals(method)) {
            paypalProvider.ifAvailable(service -> service.processPayment(amount));
        }
    }
}

8. @Bean методы с явными именами

В конфигурационном классе создавать бины с разными именами.

@Configuration
public class PaymentConfiguration {
    
    @Bean("creditCardPayment")
    public PaymentService creditCardPaymentService() {
        return new CreditCardPaymentService();
    }
    
    @Bean("paypalPayment")
    @Primary
    public PaymentService paypalPaymentService() {
        return new PayPalPaymentService();
    }
    
    @Bean("applePayPayment")
    public PaymentService applePaymentService() {
        return new ApplePayPaymentService();
    }
}

// Использование
@Service
public class CheckoutService {
    private final PaymentService defaultPayment;
    private final PaymentService creditCardPayment;
    
    public CheckoutService(
            PaymentService defaultPayment,  // Получит Primary бин
            @Qualifier("creditCardPayment") PaymentService creditCardPayment) {
        this.defaultPayment = defaultPayment;
        this.creditCardPayment = creditCardPayment;
    }
}

9. Обработка исключений при неоднозначности

try {
    @Bean
    public PaymentService paymentService() {
        // Без @Primary или @Qualifier вызовет исключение
        // NoUniqueBeanDefinitionException
    }
} catch (org.springframework.beans.factory.NoUniqueBeanDefinitionException e) {
    System.out.println("Multiple beans found: " + e.getMessage());
}

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

// 1. Предпочитай @Qualifier вместо имён
// 2. Используй @Primary только для одного дефолтного
// 3. Создавай кастомные аннотации для четкости
// 4. Используй типизированные Map для динамического выбора
// 5. Документируй какой бин используется где

@Service
public class BestPracticeService {
    private final PaymentService paymentService;
    
    // Явно указываем нужный бин
    public BestPracticeService(
            @Qualifier("paypalPayment") PaymentService paymentService) {
        this.paymentService = paymentService;
    }
}

Вывод

Для работы с несколькими бинами одного типа:

1. @Primary - для одного дефолтного бина
2. @Qualifier - для явного выбора нужного бина
3. Map<String, T> - для динамического выбора
4. List<T> - когда нужны все реализации
5. ObjectProvider - для ленивой инъекции
6. @Bean в конфигурации - когда контролируете создание

Этот подход основан на Dependency Injection и позволяет гибко управлять выбором реализаций.