Injecter et Ressource et annotations Autowired
Quelle est la différence entre @Inject et @Resource et @Autowired annotations?
Quand devrions-nous utiliser chacun d'eux?
La différence entre @Inject vs @Autowire vs @Resource?
@ Autowired: annotation de propriété du ressort (par opposition à @Inject et @Resource) qui injecte une ressource par type, c'est-à-dire par la classe de par l'interface du champ annoté ou de l'entrepreneur. Dans le cas où nous avons peu d'implémentation d'une interface ou d'une sous-classe, nous pouvons affiner la sélection en utilisant l'annotation @Qualifier pour éviter toute ambiguïté. Pour une correspondance de secours, le nom du bean est considéré comme une valeur de qualificateur par défaut. Bien que vous puissiez utiliser cette convention pour faire référence à des beans spécifiques par leur nom, @Autowired concerne fondamentalement l'injection pilotée par type avec des qualificatifs sémantiques facultatifs.
@ Inject: L'annotation basée sur JSR-330 (Dependency Injection for Java) identifie les constructeurs, méthodes et champs injectables. Cette annotation remplace presque complètement l'annotation @Autowired de Spring. Ainsi, au lieu d'utiliser l'annotation @Autowired spécifique à Spring, vous pouvez choisir d'utiliser @Inject. Une des différences entre @Autowired et @Inject est que @Inject n'a pas le champ requis, donc au cas où nous ne trouverions pas un objet approprié pour l'injecter échouera tandis que @Autowired peut utiliser required = false et autoriser le champ valide nul (uniquement si nécessaire!). L'avantage de l'annotation @Inject est qu'au lieu d'injecter directement une référence, vous pouvez demander à @Inject d'injecter un fournisseur. L'interface du fournisseur permet, entre autres, l'injection paresseuse des références de bean et l'injection de plusieurs instances d'un bean. Dans le cas où nous avons peu d'implémentation d'une interface ou d'une sous-classe, nous pouvons affiner la sélection en utilisant l'annotation @Named pour éviter toute ambiguïté. L'annotation @Named fonctionne un peu comme @Qualifier de Spring
@ Ressource: annotation basée sur JSR-250. @Resource est assez similaire à @Autowired et @Inject, mais la principale différence réside dans les chemins d'exécution empruntés pour trouver le bean requis à injecter. @Resource affinera la recherche d'abord par nom puis par type et enfin par qualificatifs (ignoré si une correspondance est trouvée par nom). @Autowired et @Inject affineront la recherche d'abord par type puis par qualificatif et enfin par nom.
|------------|---------------|---------------|---------------|-----------------------|
| | Setter/Field | Constructor | Applicable to | Matching order |
| | injection | injection | type | |
|------------|---------------|---------------|---------------|-----------------------|
| @Autowired | X | X | | Type, Qualifier, Name |
|------------|---------------|---------------|---------------|-----------------------|
| @Inject | X | X | | Type, Qualifier, Name |
|------------|---------------|---------------|---------------|-----------------------|
| @Resource | X | | X | Name, Type, Qualifier |
|------------|---------------|---------------|---------------|-----------------------|
Donc, dans l'injection de dépendance Spring @Inject et @Autowired ont exactement le même comportement.
En plus de la réponse @Haim il y a une bonne description de la différence entre Spring et JSR-330 (Dependency Injection for Java) et comment utiliser la dernière avec Spring.