Différence entre les annotations de spring

Des questions:

1) Différence entre @Component et @Configuration ?

J’ai lu que tous deux suppriment la nécessité du code de câblage à mettre en XML, mais n’ont pas obtenu la différence entre ceux-ci.

2) Quelles sont les différences entre @Autowired , @Inject et @Resource ?
– Lequel utiliser quand?
– Quels sont les avantages / inconvénients de chacun?

    @Component et @Configuration sont en effet des types d’annotations très différents.

    @Component et des annotations similaires ( @Service , @Repository , etc.) et son homologue JSR-330 @Named vous permettent de déclarer les beans à récupérer par balayage automatique avec ou @ComponentScan qu’ils enregistrent la définition du bean pour les classes, elles sont donc à peu près équivalentes à la déclaration des beans spécifiés avec la en XML. Ce type de bean sera conforme aux règles de création de proxy standard.

    @Configuration annotation @Configuration été conçue pour remplacer le fichier de configuration XML. Pour créer des haricots annotés @Configuration , Spring utilisera toujours CGLIB pour sous- @Configuration classe annotée @Configuration , en @Bean sa méthode annotée @Bean par la méthode de recherche de bean pour créer des haricots singleton une seule fois. (Spring n’utilise pas CGLIB pour intercepter les appels de méthodes internes aux beans Spring normaux , il crée une instance de proxy distincte (comme le fait le proxy JDK). Cela permet d’utiliser des proxys pour éviter une incompatibilité de cardinalité. récupère le bean session actuel, ce qui n’est pas possible avec l’inheritance de classe uniquement.) Malgré cela, les classes annotées de @Configuration peuvent toujours utiliser les champs et propriétés annotés ( @Autowired , @Inject etc.) pour demander des beans (et même d’autres @Configuration annotés @Configuration ) à partir du conteneur.

    Exemple de la section 4.12.5 de la documentation

     @Configuration public class AppConfig { @Bean public ClientService clientService1() { ClientServiceImpl clientService = new ClientServiceImpl(); clientService.setClientDao(clientDao()); return clientService; } @Bean public ClientService clientService2() { ClientServiceImpl clientService = new ClientServiceImpl(); clientService.setClientDao(clientDao()); return clientService; } @Bean public ClientDao clientDao() { return new ClientDaoImpl(); } } 

    Dans l’exemple ci-dessus, une ClientDao instance ClientDao sera créée.

    @Autowired est l’annotation Spring, tandis que @Inject est une annotation JSR-330. @Inject est équivalent à @Autowired ou @Autowired(required=true) , mais vous ne pouvez pas obtenir le @Autowired(required=false) avec l’annotation JSR-330 @Inject . Cette annotation utilise toujours le lancement automatique par type.

    Spring implémente de manière assez particulière les annotations JSR-250 @Resource . @Resource a été conçu à l’origine pour localiser les ressources JNDI dans Java EE, mais Spring élargit son applicabilité en permettant de connecter n’importe quel bean du conteneur (les ressources JNDI sont disponibles sous forme de beans à l’aide de SimpleJndiBeanFactory ). Le nom du bean correspondant peut être spécifié en tant qu’atsortingbut @Resource annotation @Resource . Si aucun nom n’a été spécifié, le nom du champ ou de la propriété annoté sera utilisé. Une autre caractéristique étrange est que si aucun bean avec le nom de la propriété n’a été trouvé, le spring sera remplacé par un câblage de type secondaire.

    Exemple Imaginez que nous ayons un bean AlphaClass nommé beanAlpha et un BetaClass BetaClass dans le conteneur.

     @Resource BetaClass something; // Wires to beanBeta - by-type @Resource BetaClass beanAlpha; // Will throw exception, because "beanAlpha" is not BetaClass -> it's a bad idea to use @Resource as a replacement of @Autowired @Resource Object beanAlpha; //Wires to beanAlpha - by-name 

    Il est donc @Resource de toujours spécifier explicitement le nom de la ressource lors de l’utilisation de l’annotation @Resource .

    Documentation

    Annotations du spring

    Annotations Bean standard

    mise à jour fixe les références JSR comme Shevchik l’ a souligné. Les annotations spécifiques à la DI sont fournies par JSR-330, qui a été développé par les ingénieurs Google (Guice Framework) et SpringSource (Spring Framework). @Resource est basé sur JNDI et fourni par JSR-250 .

    @Component est équivalent à ,
    @Configuration est équivalent à .

    Dans la plupart des réponses ci-dessus, les utilisateurs suggèrent de dire que @Component et @ Configuration servent des objectives différents. Mais je ne le vois pas se produire dans la réalité.

    Mais j’ai une simple application Spring MVC.

     @Configuration public class SpringConfiguration { @Bean public InternalResourceViewResolver initViewResolver(){ InternalResourceViewResolver x = new InternalResourceViewResolver(); x.setPrefix("/WEB-INF/jsp/"); x.setSuffix(".jsp"); return x; } } 

    Cette classe principale fonctionne correctement même si elle est annotée comme @Component au lieu de @Configuration.

    De même, dans une classe annotée comme @Component si vous avez des méthodes annotées avec @Bean, ces beans sont créés lorsque le contexte est verrouillé.

    Donc, je pense que c’est juste pour la lisibilité du code que nous devrions marquer la classe de configuration principale comme @Configuration et d’autres classes avec @Component. L’exécution réelle semble sage, il ne semble pas y avoir de différence.

    Sur la différence entre @Autowired , @Inject et @Resource vous pouvez regarder ici . Ici, vous pouvez approfondir la description et la comparaison.

    Ce qui concerne la première différence: @Configuration est utilisé en remplacement de la configuration basée sur XML , c.-à-d. il marque les classes comme celles utilisées pour Java configuration basée sur Java , voir ici . À son tour, @Component est effectivement utilisé pour marquer les classes comme celles qui doivent être instanciées par Spring et que @Configuration est méta-annotée par l’annotation @Component .

    @Component et @Configuration des objectives différents, il est donc @Configuration de les comparer.

    1) Si vous souhaitez une configuration XML, ignorez @Configuration, car cela n’est utile que pour la configuration Java. La configuration XML est probablement la meilleure pour quelqu’un qui ne connaît pas Spring, car il y a plus d’exemples disponibles.

    Les classes annotées @Component sont captées lors de l’parsing des composants. Utilisez-les pour étiqueter les classes que vous souhaitez exposer en tant que beans Spring. Encore une fois, vous pouvez simplement déclarer tous vos beans dans la configuration XML et ignorer @Component.

    2) Si vous êtes heureux de lier votre application à Spring, utilisez @Autowire plutôt que l’équivalent javax @Inject. Je suggère que le fait d’accepter une dépendance au spring est la meilleure façon de commencer.