Spring Framework
Concepts
Différents Concepts
La première chose à savoir est que le coeur de Spring Framework 3 est composé d'un ensemble d'une vingtaine de modules qui sont regroupés en plusieurs grandes parties :
- Spring Core Container : regroupe les modules de base pour mettre en oeuvre le conteneur
- AOP and Instrumentation : permet de mettre en oeuvre l'AOP
- Data Acces/Integration : regroupe les modules d'accès aux données
- Web : regroupe les modules pour le développement d'applications web
- Test : propose des fonctionnalités pour les tests automatisés avec Spring
- Ioc
- AOP
- SpEL
Ioc
Le concept de l'Ioc (ou l'inversion de contrôle) :
L'Inversion de contrôle permet de faire de l'injection de dépendance dans un programme et ainsi de gérer le cycle de vie des beans (pour rappel un bean et un objet java contenant des propriétés ainsi que des getters/setters pour ces attributs).Il est possible de le faire de deux manières différentes : par fichier de configuration ou par annotations. Je vais illustrer la manière par fichier de configuration dans les exemples suivants :
Je commence par créer une première classe Personne implémentant l'interface Humain. Cette classe est un bean tout ce qu'il y a de plus classique possédant deux propriétés : Nom & Prénom ainsi que leur getters et setteurs.
Je crée ensuite une deuxième classe que je nomme Voiture et qui possède une marque, un modèle et un conducteur qui est de type Humain. Jusque ici Spring n'intervient en rien.
C'est dans un fichier à part que Spring va agir. Ce fichier se nomme ici bean-conf.xml et indique à Spring comment instancier les classes et comment les injecter.
Une fois tout cela en place, je fini par créer une classe Main dans laquelle on réunit tout cela et que l'on éxécute.
On remarque que l'injection c'est bien déroulée et que nos objets sont donc crées.
Il est donc possible de le faire également en ajoutant des annotations directement dans le code comme :
- @Scope : singleton, prototype, session ou request
- @Autowired : injection automatique par type
- @Required : valide une injection de dépendances
- @Qualifier : donne un nom si plusieurs instances
- @Resource : injection automatique par nom
- @Configurable : injecte les dépendances d'un bean bien que son conteneur ne gère pas son cycle de vie
- @PostConstruct : appelle de méthode à l’instanciation
- @PreDestroy : appelle de méthode à la destruction de l’instance
- …
AOP
Le concept de l'AOP (ou la programmation par aspect) :
La programmation par aspect permet de créer dynamiquement des proxys s’exécutant à des événements choisis dans le programme.Il est possible de le faire des deux mêmes manières que précédemment mais je vais continuer avec la méthode du fichier de configuration. Voici un exemple :
(J'utilise dans cet example les deux mêmes classes Personne et Voiture que dans l'exemple précédent).
Je crée ici une classe Voleur qui ressemble à une classe personne mais qui possède un nom et un prénom fixe.
Voici le fichier de configuration pour cet exemple. On y retrouve les classes de tout à l'heure mais également de nouveaux éléments.
Voici la classe dites "Aspect". Cette classe VoleurAspect regroupe les deux méthodes déclarées dans le fichier de configuration pour s'éxécuter avant et après la méthode survéillée.
Le fichier Main n'a pas bougé et après son éxécution on constate le résultat :
Comme tout à l'heure il est également possible de faire l'opération avec des annotations :
- @Before : le code est exécuté avant l'exécution de la méthode
- @AfterReturning : le code est exécuté après l'exécution de la méthode qui renvoie une valeur de retour (aucune exception n'est levée)
- @AfterThrowing : le code est exécuté lorsqu'une exception est levée suite à l'invocation de la méthode
- @After : le code est exécuté après l'exécution de la méthode, même si une exception est levée.
- @Around : le code de l'aspect permet de lancer l'exécution de la méthode et ainsi de réaliser des traitements avant et des traitements après
SpEL
Le concept du SpEL (ou le Spring Expression Langage) :
Apparu avec la version 3 de Spring, le Spring Expression Langage permet d'écrire du code directement de les fichier de configuration ou dans les annotations :
Cela rajoute encore un peu plus de possibilités à ce framework déjà trés puissant.