Как Spring различает два эквивалентных объекта

Ответ: Как Spring различает два эквивалентных объекта?

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

1. По типу и имени бина (основной способ):

public interface PaymentService {
    void process();
}

// Две реализации одного интерфейса
@Service("creditCardPayment")
public class CreditCardPaymentService implements PaymentService {
    @Override
    public void process() {
        System.out.println("Processing credit card");
    }
}

@Service("paypalPayment")
public class PayPalPaymentService implements PaymentService {
    @Override
    public void process() {
        System.out.println("Processing PayPal");
    }
}

// Spring различает их по имени
@RestController
public class PaymentController {
    @Autowired
    @Qualifier("creditCardPayment")  // явное указание какой бин использовать
    private PaymentService creditCard;
    
    @Autowired
    @Qualifier("paypalPayment")
    private PaymentService paypal;
}

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

// Способ 1: через @Qualifier
@Component
public class OrderService {
    private PaymentService paymentService;
    
    @Autowired
    public OrderService(@Qualifier("creditCardPayment") PaymentService service) {
        this.paymentService = service;
    }
}

// Способ 2: на уровне свойств
@Component
public class OrderService {
    @Autowired
    @Qualifier("paypalPayment")
    private PaymentService paymentService;
}

3. По именам параметров (Primary Constructor)

Java 17+ и Spring 6.0+ автоматически используют имена параметров:

@Service("creditCardPayment")
public class CreditCardPayment implements PaymentService { }

@Service("paypalPayment")
public class PayPalPayment implements PaymentService { }

@Component
public class OrderProcessor {
    private final PaymentService creditCardPayment;  // Spring найдёт бин с этим именем!
    private final PaymentService paypalPayment;      // И этот!
    
    @Autowired
    public OrderProcessor(
        PaymentService creditCardPayment,    // имя соответствует имени бина
        PaymentService paypalPayment
    ) {
        this.creditCardPayment = creditCardPayment;
        this.paypalPayment = paypalPayment;
    }
}

4. Использование @Primary аннотации:

Если один бин должен быть "основным":

@Service
@Primary  // этот бин будет использоваться по умолчанию
public class CreditCardPayment implements PaymentService {
    @Override
    public void process() {
        System.out.println("Primary payment method");
    }
}

@Service
public class PayPalPayment implements PaymentService {
    @Override
    public void process() {
        System.out.println("Alternative payment method");
    }
}

// Использование
@Component
public class OrderService {
    @Autowired
    private PaymentService service;  // будет CreditCardPayment
}

5. Кастомные аннотации для различия:

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

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

// Применяем к реализациям
@Service
@FastPayment
public class FastPaymentImpl implements PaymentService { }

@Service
@SecurePayment
public class SecurePaymentImpl implements PaymentService { }

// Используем
@Component
public class PaymentFactory {
    @Autowired
    @FastPayment
    private PaymentService fast;
    
    @Autowired
    @SecurePayment
    private PaymentService secure;
}

6. ObjectProvider для выбора бина при runtime:

import org.springframework.beans.factory.ObjectProvider;

@Component
public class PaymentSelector {
    private final ObjectProvider<PaymentService> paymentServices;
    
    @Autowired
    public PaymentSelector(ObjectProvider<PaymentService> paymentServices) {
        this.paymentServices = paymentServices;
    }
    
    public void processPayment(String method) {
        if ("creditCard".equals(method)) {
            // Найти бин с квалификатором
            PaymentService service = paymentServices.getObject("creditCardPayment");
            service.process();
        }
    }
}

7. По значению @Bean имени в @Configuration:

@Configuration
public class PaymentConfig {
    
    @Bean(name = "creditCardService")
    public PaymentService creditCardPayment() {
        return new CreditCardPaymentService();
    }
    
    @Bean(name = "paypalService")
    public PaymentService paypalPayment() {
        return new PayPalPaymentService();
    }
}

// Использование
@Component
public class OrderService {
    @Autowired
    @Qualifier("creditCardService")
    private PaymentService payment;
}

8. Использование List или Map для получения всех бинов:

@Component
public class PaymentOrchestrator {
    
    // Получить все реализации PaymentService
    @Autowired
    private List<PaymentService> allPayments;
    
    // Или как Map
    @Autowired
    private Map<String, PaymentService> paymentServices;
    
    public void processAll() {
        // Итерируем по всем бинам
        allPayments.forEach(PaymentService::process);
    }
    
    public void processSpecific(String type) {
        PaymentService service = paymentServices.get(type);
        if (service != null) {
            service.process();
        }
    }
}

9. Внутренне: как Spring идентифицирует объекты

Spring использует несколько механизмов:

// 1. По классу (типу)
ApplicationContext context = new AnnotationConfigApplicationContext();
PaymentService service = context.getBean(PaymentService.class); // ошибка если > 1

// 2. По имени бина
PaymentService service = context.getBean("creditCardPayment", PaymentService.class);

// 3. По BeanDefinition
BeanFactory factory = context;
BeanDefinition def = factory.getBeanDefinition("creditCardPayment");
String className = def.getBeanClassName();  // полное имя класса

10. Порядок выбора бина (резолюция):

Spring следует этому порядку при выборе бина:

1. @Qualifier (если указан) → точное совпадение имени
2. Имя параметра конструктора/метода → совпадение с именем бина
3. @Primary → если один помечен как @Primary
4. По типу → если только один бин этого типа
5. Error → если несколько подходящих и нет выше правил

Пример всей системы вместе:

// Интерфейс
public interface Database {
    String connect();
}

// Реализации
@Service("mysqlDB")
public class MySQLDatabase implements Database {
    @Override
    public String connect() { return "MySQL connected"; }
}

@Service("postgresDB")
public class PostgresDatabase implements Database {
    @Override
    public String connect() { return "PostgreSQL connected"; }
}

@Service
@Primary
public class PrimaryDatabase implements Database {
    @Override
    public String connect() { return "Primary DB connected"; }
}

// Использование
@RestController
public class DataController {
    
    @Autowired
    private Database defaultDB;  // PrimaryDatabase (из @Primary)
    
    @Autowired
    @Qualifier("mysqlDB")
    private Database mysql;  // MySQLDatabase
    
    @Autowired
    @Qualifier("postgresDB")
    private Database postgres;  // PostgresDatabase
    
    @GetMapping("/connect")
    public Map<String, String> connect() {
        return Map.of(
            "default", defaultDB.connect(),
            "mysql", mysql.connect(),
            "postgres", postgres.connect()
        );
    }
}

Заключение:

Spring различает эквивалентные объекты используя:

1. @Qualifier — явное указание имени бина
2. @Primary — выделение основного бина
3. Имена параметров — автоматический выбор по имени
4. Кастомные аннотации — для большей гибкости
5. ObjectProvider — для выбора при runtime
6. List/Map — для работы со всеми бинами

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