Différence entre vs

1. Vue d'ensemble

Dans ce didacticiel, nous allons découvrir les différences entre deux principaux éléments de configuration XML de Spring: et .

2. Définitions des haricots

Comme nous le savons tous, Spring nous offre deux façons de définir nos beans et nos dépendances: la configuration XML et les annotations Java. Nous pouvons également classer les annotations de Spring sous deux groupes: les annotations d'injection de dépendances et les annotations de bean.

Avant les annotations, nous devions définir manuellement tous nos beans et dépendances dans des fichiers de configuration XML. Désormais, grâce aux annotations de Spring, il peut découvrir et câbler automatiquement tous nos beans et dépendances pour nous . Ainsi, nous pouvons au moins éliminer le XML nécessaire pour les beans et les dépendances.

Cependant, nous devons nous rappeler que les annotations sont inutiles si nous ne les activons pas . Afin de les activer, nous pouvons ajouter soit ou en plus de notre fichier XML.

Dans cette section, nous verrons comment et diffèrent les uns des autres par leur manière d'activer les annotations.

3. Activation d'annotation par < context: annotation-config>

le l'annotation est principalement utilisée pour activer les annotations d'injection de dépendances. @Autowired , @Qualifier , @PostConstruct , @PreDestroy et @Resource sont parmi ceux quipeut résoudre.

Faisons un exemple simple pour voir comment peut simplifier la configuration XML pour nous.

Tout d'abord, créons une classe avec un champ de dépendance:

public class UserService { @Autowired private AccountService accountService; }
public class AccountService {}

Maintenant, définissons nos beans.

Avant d'aller plus loin, soulignons que nous devons encore déclarer des beans dans le XML. C'est parce queactive les annotations uniquement pour les beans déjà enregistrés dans le contexte de l'application .

Comme on peut le voir ici, nous annotés le AccountService champ à l' aide @Autowired . @Autowired indique à Spring que ce champ est une dépendance qui doit être automatiquement câblée par un bean correspondant.

Si nous n'utilisions pas @Autowired , nous aurions besoin de définir manuellement la dépendance accountService :

Maintenant, nous pouvons nous référer à nos beans et dépendances dans un test unitaire:

@Test public void givenContextAnnotationConfig_whenDependenciesAnnotated_thenNoXMLNeeded() { ApplicationContext context = new ClassPathXmlApplicationContext("classpath:annotationconfigvscomponentscan-beans.xml"); UserService userService = context.getBean(UserService.class); AccountService accountService = context.getBean(AccountService.class); Assert.assertNotNull(userService); Assert.assertNotNull(accountService); Assert.assertNotNull(userService.getAccountService()); }

Hmm, quelque chose ne va pas ici. Il semble que Spring ne connecte pas le accountService même si nous l'avons annoté par @Autowired . Il semble que @Autowired n'est pas actif. Afin de résoudre ce problème, nous allons simplement ajouter la ligne suivante en haut de notre fichier XML:

4. Activation d'annotation par < context: component-scan>

Comme similaire à , peut également reconnaître et traiter les annotations d'injection de dépendances. De plus, reconnaît les annotations de bean qui ne détecte pas .

Fondamentalement, détecte les annotations en analysant les packages . Pour le dire différemment, il indique à Spring quels packages doivent être analysés pour rechercher les beans ou composants annotés.

@Component , @Repository , @Service , @Controller , @RestController et @Configuration sont plusieurspeut détecter .

Voyons maintenant comment nous pouvons simplifier notre exemple précédent:

@Component public class UserService { @Autowired private AccountService accountService; } 
@Component public class AccountService {}

Ici, l' annotation @Component marque nos classes comme des beans . Maintenant, nous pouvons nettoyer toutes les définitions de bean de notre fichier XML. Et bien sûr, nous devons garder le en plus:

Enfin, notons que Spring recherchera les beans annotés et les dépendances sous le package indiqué par l' attribut base-package .

5. Conclusion

Dans ce didacticiel, nous avons examiné les différences entre et .

Les exemples de code, comme toujours, sont terminés sur GitHub.