Injection basée sur XML au printemps

1. Introduction

Dans ce didacticiel de base, nous allons apprendre à effectuer une configuration de bean basée sur XML simple avec Spring Framework.

2. Aperçu

Commençons par ajouter la dépendance de bibliothèque de Spring dans le pom.xml :

 org.springframework spring-context 5.1.4.RELEASE  

La dernière version de la dépendance Spring peut être trouvée ici.

3. Injection de dépendances - un aperçu

L'injection de dépendances est une technique par laquelle les dépendances d'un objet sont fournies par des conteneurs externes.

Disons que nous avons une classe d'application qui dépend d'un service qui gère réellement la logique métier:

public class IndexApp { private IService service; // standard constructors/getters/setters } 

Maintenant, disons qu'IService est une interface:

public interface IService { public String serve(); } 

Cette interface peut avoir plusieurs implémentations.

Jetons un coup d'œil à une implémentation potentielle:

public class IndexService implements IService { @Override public String serve() { return "Hello World"; } } 

Ici, IndexApp est un composant de haut niveau qui dépend du composant de bas niveau appelé IService .

Essentiellement, nous découplons IndexApp d'une implémentation particulière de l' IService qui peut varier en fonction des différents facteurs.

4. Injection de dépendances - en action

Voyons comment nous pouvons injecter une dépendance.

4.1. Utilisation des propriétés

Voyons comment nous pouvons câbler les dépendances ensemble à l'aide d'une configuration basée sur XML:

Comme on peut le voir, nous créons une instance d' IndexService et lui attribuons un identifiant. Par défaut, le bean est un singleton. Nous créons également une instance d' IndexApp .

Dans ce bean, nous injectons l'autre bean en utilisant la méthode setter.

4.2. Utilisation du constructeur

Au lieu d'injecter un bean via la méthode setter, nous pouvons injecter la dépendance en utilisant le constructeur:

4.3. Utilisation de Static Factory

On peut également injecter un bean retourné par une usine. Créons une usine simple qui retourne une instance de IService en fonction du nombre fourni:

public class StaticServiceFactory { public static IService getNumber(int number) { // ... } } 

Voyons maintenant comment nous pourrions utiliser l'implémentation ci-dessus pour injecter un bean dans IndexApp en utilisant une configuration XML:

Dans l'exemple ci-dessus, nous appelons la méthode statique getService à l' aide de la méthode factory pour créer un bean avec l'id messageService que nous injectons dans IndexApp.

4.4. Utilisation de la méthode d'usine

Considérons une fabrique d'instances qui renvoie une instance de IService en fonction du nombre fourni. Cette fois, la méthode n'est pas statique:

public class InstanceServiceFactory { public IService getNumber(int number) { // ... } } 

Voyons maintenant comment nous pourrions utiliser l'implémentation ci-dessus pour injecter un bean dans IndexApp en utilisant la configuration XML:

Dans l'exemple ci-dessus, nous appelons la méthode getService sur une instance de InstanceServiceFactory à l' aide de la méthode factory pour créer un bean avec l'id messageService que nous injectons dans IndexApp .

5. Test

Voici comment accéder aux beans configurés:

@Test public void whenGetBeans_returnsBean() { ApplicationContext applicationContext = new ClassPathXmlApplicationContext("..."); IndexApp indexApp = applicationContext.getBean("indexApp", IndexApp.class); assertNotNull(indexApp); } 

6. Conclusion

Dans ce tutoriel rapide, nous avons illustré des exemples de la façon dont nous pouvons injecter une dépendance à l'aide de la configuration XML à l'aide de Spring Framework.

L'implémentation de ces exemples peut être trouvée dans le projet GitHub - il s'agit d'un projet basé sur Maven, il devrait donc être facile à importer et à exécuter tel quel.