Spring @Primary Annotation

1. Panoramica

In questo breve tutorial, discuteremo dell'annotazione @Primary di Spring introdotta con la versione 3.0 del framework.

In poche parole, usiamo @Primary per dare maggiore preferenza a un bean quando ci sono più bean dello stesso tipo.

Descriviamo il problema in dettaglio.

2. Perché è necessario @Primary ?

In alcuni casi, è necessario registrare più di un bean dello stesso tipo .

In questo esempio abbiamo i bean JohnEmployee () e TonyEmployee () del tipo Employee :

@Configuration public class Config { @Bean public Employee JohnEmployee() { return new Employee("John"); } @Bean public Employee TonyEmployee() { return new Employee("Tony"); } }

Spring genera NoUniqueBeanDefinitionException se proviamo a eseguire l'applicazione .

Per accedere a bean con lo stesso tipo usiamo solitamente l' annotazione @Qualifier ("beanName") .

Lo applichiamo nel punto di iniezione insieme a @Autowired . Nel nostro caso, selezioniamo i bean in fase di configurazione in modo che @Qualifier non possa essere applicato qui. Possiamo saperne di più sull'annotazione @Qualifier seguendo il link.

Per risolvere questo problema, Spring offre l' annotazione @Primary .

3. Utilizzare @Primary Con @Bean

Diamo un'occhiata alla classe di configurazione:

@Configuration public class Config { @Bean public Employee JohnEmployee() { return new Employee("John"); } @Bean @Primary public Employee TonyEmployee() { return new Employee("Tony"); } }

Contrassegniamo il bean TonyEmployee () con @Primary . La primavera inietterà il bean TonyEmployee () preferenzialmente su JohnEmployee () .

Ora, iniziamo il contesto dell'applicazione e otteniamo il bean Employee da esso:

AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Config.class); Employee employee = context.getBean(Employee.class); System.out.println(employee);

Dopo aver eseguito l'applicazione:

Employee{name='Tony'}

Dall'output , possiamo vedere che l' istanza TonyEmployee () ha una preferenza durante l'autowiring .

4. Utilizzare @Primary con @Component

Possiamo usare @Primary direttamente sui fagioli . Diamo uno sguardo al seguente scenario:

public interface Manager { String getManagerName(); }

Abbiamo un'interfaccia Manager e due bean di sottoclasse, DepartmentManager :

@Component public class DepartmentManager implements Manager { @Override public String getManagerName() { return "Department manager"; } }

E il fagiolo GeneralManager :

@Component @Primary public class GeneralManager implements Manager { @Override public String getManagerName() { return "General manager"; } }

Entrambi sostituiscono il getManagerName () del gestore dell'interfaccia. Si noti inoltre che vi segnalo il general manager di fagioli con @Primary .

Questa volta, @Primary ha senso solo quando abilitiamo la scansione dei componenti :

@Configuration @ComponentScan(basePackages="org.baeldung.primary") public class Config { }

Creiamo un servizio per utilizzare l'inserimento delle dipendenze mentre troviamo il bean giusto:

@Service public class ManagerService { @Autowired private Manager manager; public Manager getManager() { return manager; } }

Qui, entrambi i bean DepartmentManager e GeneralManager sono idonei per il cablaggio automatico.

Come abbiamo segnato general manager di fagioli con @Primary , verrà selezionato per l'iniezione di dipendenza :

ManagerService service = context.getBean(ManagerService.class); Manager manager = service.getManager(); System.out.println(manager.getManagerName());

L'output è " Direttore generale".

5. conclusione

In questo articolo, abbiamo appreso dell'annotazione @Primary di Spring . Con gli esempi di codice, abbiamo dimostrato la necessità e i casi d'uso di @Primary.

Come al solito, il codice completo per questo articolo è disponibile sul progetto GitHub.