Fondamentalement, le printemps est un cadre pour dépendance-injection ce qui permet de construire des systèmes très découplés.
Le problème
Par exemple, supposons que vous deviez répertorier les utilisateurs du système et déclarer ainsi une interface appelée UserLister:
public interface UserLister {
List<User> getUsers();
}
Et peut-être une implémentation accédant à une base de données pour obtenir tous les utilisateurs:
public class UserListerDB implements UserLister {
public List<User> getUsers() {
// DB access code here
}
}
À votre avis, vous devrez accéder à une instance (juste un exemple, rappelez-vous):
public class SomeView {
private UserLister userLister;
public void render() {
List<User> users = userLister.getUsers();
view.render(users);
}
}
Notez que le code ci-dessus n'a pas initialisé la variable userLister. Que devrions nous faire? Si j'instancie explicitement l'objet comme ceci:
UserLister userLister = new UserListerDB();
... Je couplerais la vue avec mon implémentation de la classe qui accède à la base de données. Que faire si je veux passer de l'implémentation de la base de données à une autre qui obtient la liste des utilisateurs à partir d'un fichier séparé par des virgules (rappelez-vous, c'est un exemple)? Dans ce cas, j'irais à nouveau dans mon code et changerais la ligne ci-dessus en:
UserLister userLister = new UserListerCommaSeparatedFile();
Cela n'a aucun problème avec un petit programme comme celui-ci mais ... Que se passe-t-il dans un programme qui a des centaines de vues et un nombre similaire de classes affaires? L'entretien devient un cauchemar!
Approche Spring (Dependency Injection)
Ce que Spring fait est de câbler les classes en utilisant un fichier XML ou des annotations, de cette façon tous les objets sont instanciés et initialisés par Spring et injectés aux bons endroits (Servlets, Web Frameworks, Business classes, DAO, etc., etc., etc., etc. ...).
Pour revenir à l'exemple de Spring, nous avons juste besoin d'avoir un setter pour le userListerchamp et d'avoir soit un fichier XML comme celui-ci:
<bean id="userLister" class="UserListerDB" />
<bean class="SomeView">
<property name="userLister" ref="userLister" />
</bean>
ou plus simplement annotez le fichier déposé dans notre classe d'affichage avec @Inject:
@Inject
private UserLister userLister;
De cette façon, lorsque la vue est créée, elle aura comme par magie un UserListerprêt à fonctionner.
List<User> users = userLister.getUsers(); // This will actually work
// without adding any line of code
C'est super! N'est-ce pas?
- Et si vous souhaitez utiliser une autre implémentation de votre
UserListerinterface? Modifiez simplement le XML.
- Et si vous n'avez pas d'
UserListerimplémentation prête? Programmer une implémentation temporelle simulée UserListeret faciliter le développement de la vue.
- Et si je ne veux plus utiliser Spring? Ne l'utilisez pas! Votre application n'y est pas associée. L'inversion du contrôle indique: "L'application contrôle le cadre, pas le cadre contrôle l'application".
Il y a d'autres options pour l'injection de dépendance autour de moi, ce qui à mon avis a rendu Spring si célèbre en plus de sa simplicité, de son élégance et de sa stabilité, c'est que les gars de SpringSource ont programmé de nombreux POJO qui aident à intégrer Spring avec de nombreux autres cadres communs sans être intrusif dans votre application. De plus, Spring a plusieurs bons sous-projets comme Spring MVC, Spring WebFlow, Spring Security et encore une longue liste de etceteras.
J'espère que cela t'aides. Quoi qu'il en soit, je vous encourage à lire l'article de Martin Fowler sur l'injection de dépendance et l'inversion de contrôle car il le fait mieux que moi. Après avoir compris les bases, jetez un œil à la documentation Spring , à mon avis, elle est utilisée pour être le meilleur livre Spring jamais.
