Annotation Spring @Primary

1. Vue d'ensemble

Dans ce tutoriel rapide, nous discuterons de l' annotation @Primary de Spring qui a été introduite avec la version 3.0 du framework.

En termes simples, nous utilisons @Primary pour donner une préférence plus élevée à un bean quand il y a plusieurs beans du même type.

Décrivons le problème en détail.

2. Pourquoi @Primary est- il nécessaire?

Dans certains cas, nous devons enregistrer plus d'un bean du même type .

Dans cet exemple, nous avons les beans JohnEmployee () et TonyEmployee () du type Employee :

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

Spring lève NoUniqueBeanDefinitionException si nous essayons d'exécuter l'application .

Pour accéder aux beans du même type, nous utilisons généralement l' annotation @Qualifier («beanName») .

Nous l'appliquons au point d'injection avec @Autowired . Dans notre cas, nous sélectionnons les beans lors de la phase de configuration afin que @Qualifier ne puisse pas être appliqué ici. Nous pouvons en savoir plus sur l' annotation @Qualifier en suivant le lien.

Pour résoudre ce problème, Spring propose l' annotation @Primary .

3. Utilisez @Primary avec @Bean

Jetons un coup d'œil à la classe de configuration:

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

Nous marquons le bean TonyEmployee () avec @Primary . Spring injectera le bean TonyEmployee () de préférence sur JohnEmployee () .

Maintenant, commençons le contexte de l'application et récupérons le bean Employee :

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

Après avoir exécuté l'application:

Employee{name='Tony'}

À partir de la sortie, nous pouvons voir que l' instance TonyEmployee () a une préférence lors du câblage automatique .

4. Utilisez @Primary avec @Component

Nous pouvons utiliser @Primary directement sur les beans . Jetons un coup d'œil au scénario suivant:

public interface Manager { String getManagerName(); }

Nous avons une interface Manager et deux beans de sous-classe, DepartmentManager :

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

Et le bean GeneralManager :

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

Ils remplacent tous les deux le getManagerName () de l' interface du gestionnaire . Notez également que nous marquons le bean GeneralManager avec @Primary .

Cette fois, @Primary n'a de sens que lorsque nous activons l'analyse des composants :

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

Créons un service pour utiliser l'injection de dépendances tout en trouvant le bon bean:

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

Ici, les beans DepartmentManager et GeneralManager sont éligibles pour l'autowiring.

Comme nous avons marqué le bean GeneralManager avec @Primary , il sera sélectionné pour l'injection de dépendances :

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

Le résultat est « Directeur général».

5. Conclusion

Dans cet article, nous avons découvert l' annotation @Primary de Spring . Avec les exemples de code, nous avons démontré la nécessité et les cas d'utilisation de @Primary.

Comme d'habitude, le code complet de cet article est disponible sur le projet GitHub.