CHAPITRE 4:Spring
Boot et Spring Data
1
I. Spring Boot
Un projet java de Spring pour RAD (Rapid Application Devlopment).
Se base sur Starter templates.
Avantages :
Identifie les dépendances requises avec la bonne version et les
importe. (STARTER POMS)
Facilite la configuration.
Conteneurs intégrés (embedded containers) : Serveur d'application
(tomcat, jetty) ; base de données (in memory database)
Intègre plusieurs plugins pour faciliter le build et le test des
applications : Maven, Gradle
2
I. Spring Boot
Starter templates:
• les modèles contenant une collection de toutes les dépendances transitives
pertinentes nécessaires au démarrage d'une fonctionnalité particulière.
Serveurs intégrés:
• Les applications Spring Boot incluent toujours tomcat en tant que serveur
intégré. Cela signifie que vous pouvez exécuter les applications sans nécessiter
une infrastructure de serveur complexe
In Memory Database
• Une base de données pour accélérer le développement et le test de
l'application avec une BD, sans aucune installation de SGBD.
• La BD in memory est créée dans la VM au lancement de l'application et elle
est supprimée lorsque l'application est fermée
3
I. Spring Boot
Comment fonctionne Spring Boot?
Il se base sur :
1. une classe générée automatiquement et annotée avec @SpringBootApplication.
Elle doit être placée dans le premier package ou directement dans classpath.
2. Fichier [Link]
3. Une squelette générée automatiquement
4. [Link] avec starter parent spring boot.
4
I. Spring Boot
Comment fonctionne Spring Boot?
@SpringBootConfiguration : déclenche la configuration automatique de l’infrastructure
Spring
Au démarrage de l’application, Spring Boot :
- Scanne toutes classes @configuration :
- classes spécifiques à l’application
- classes de Spring Boot suffixées par @AutoConfiguration
- classes des starters et jar dépendants.
5
I. Spring Boot
Comment fonctionne Spring Boot?
Fichier [Link]
● Indiquer le lieu où vous mettez des fichier JSP à Spring Boot (View Resolver)
● Indique la configuration d’accès a la base de données.
● Exemple de contenu :
[Link]=/WEB-INF/jsp/
[Link]=.jsp
[Link]=jdbc:sqlserver://localhost:1433;databaseName=mydb
[Link]=SpringUser
[Link]=PassWord
6
I. Spring Boot
7
II. Spring Data
Spring Data JPA fournit une implémentation de la couche d’accès aux
données pour une application Spring.
C’est une brique très pratique car elle permet de ne pas réinventer
la roue de l’accès aux données à chaque nouvelle application et
donc de se concentrer sur la partie métier
Spring Data Commons contient les classes pour fonctionner, mais aussi les interfaces que
l'utilisateur doit étendre : Repository, CrudRepository et PagingAndSortingRepository.
8
II. Spring Data
e▲
• CrudRepository: Interface contenant des méthodes CRUD usuelle pour la source de
données sous-jacente (save, findOne, findAll, etc.).
• PagingAndSortingRepository étend CrudRepository qui étend Repository, on aura
accès, en plus des méthodes CRUD, à un ensemble de méthodes permettant de faire
de la pagination et du tri.
Ces interfaces prennent deux types paramétrés : le type de l'entité que l'on manipule et
le type de l'identifiant de l'entité.
import [Link];
public interface VoitureCRUD extends CrudRepository<Voiture, Integer> {
}
II. Spring Data
• Spring Data permet donc d'écrire des requêtes à partir des noms de méthode :
• la méthode avec certains mots-clés (And, Or, Containing, StartingWith, etc.,
définis dans les documentations de référence)
• il se charge de traduire ce nom de méthode en requête puis de l'exécuter au
moment voulu comme dans l’exemple suivant :
public interface PersonneRep extends CrudRepository {
Personne findByNom(String nom);
Personne findByNomAndPrenom(String nom, String prenom);
List<Personne> findByNomAndPrenomAllIgnoreCase(String nom, String prenom);
List<Personne> findByNomOrderByPrenomAsc(String nom)
10
TP4: Spring Boot et Spring Data
11
AOP: Aspect Oriented Programming
12
Aspect Oriented Programming
La programmation orientée aspect (Aspect Oriented Programming ou AOP)
est un paradigme de programmation qui permet de traiter séparément :
◦ Les préoccupations transversales (Cross Cutting Concerns), qui relèvent souvent des
aspects technique (Journalisation, Sécurité, Transaction, …)
◦ des préoccupations métiers, qui constituent le cœur d'une application.
Elle permet de Séparer le code métier du code technique
13
Aspect Oriented Programming
Un programme codé en orienté aspect peut être découpé en deux parties disjointes :
◦ Les classes pour la logique métier
◦ Les aspects pour les aspects techniques
Le programme ne doit pas avoir connaissance des aspects, ils ne sont jamais appelés dans
les classes du programme.
14
Aspect Oriented Programming
Exemple (1) d’exigence Technique: la journalisation
• Dans les applications classiques, toutes les méthodes d’une application doivent contenir du
code qui permet de loger des messages au début et la fin de la méthode.
• Répétition du même code à tous les niveaux de l’application.
• Peut engendrer des problèmes au niveau de la maintenance.
• Grace à la programmation orientée aspect, la journalisation sera concentrée dans
Une classe séparée (Aspect)
De même pour ajouter d’autres aspect techniques comme La sécurité, Gestion de transaction,
Gestion des exceptions,…
15
Aspect Oriented Programming
Exemple (2) d’exigence Technique: l’intégrité des données
public void virement(int c1, int c2,
double mt) {/* Création d’une
transaction */
EntityTransaction VS
transaction=[Link]
n();
/* Démarrer la transaction */
public void virement(int c1, int c2, double mt) {
[Link]();
retirer(c1,mt);
try {
verser(c2,mt);
}
/* Code métier */
retirer(c1,mt);e Technique
verser(c2,mt);
/* Valider la transaction */
[Link]();
} catch (Exception e) {
//Annuler la transaction en cas 16
d’exception
[Link]();
Aspect Oriented Programming
• Une application orientée aspect contient des classes et des aspects.
• L'opération qui prends en entrée les classes et les aspects et produit une application qui
intègre les fonctionnalités des classes et des aspects est connu sous le nom de tissage
d'aspect (aspect weaving).
17
Aspect Oriented Programming
La programmation orientée aspect possède plusieurs avantages mais n’est pas exempt
d’inconvénients.
Avantages
- Facilite la maintenance des modules qui nécessitent divers traitements techniques.
- L’AOP permettant d’automatiser ses traitements, les modules ne contiennent plus de code
superflu et il devient plus simple de les comprendre et modifier leur logique.
- Améliorer la réutilisabilité du code et de bien séparer les responsabilités de chaque module.
Inconvénients
- L’apprentissage du concept est complexe et il faut un certain temps avant de bien comprendre
son fonctionnement.
- La lecture du code ne permet pas de déceler immédiatement les aspects qui vont être insérés.
- Il n’existe actuellement aucune norme pour l’implémentation de l’AOP, chaque Framework
proposant ainsi sa propre solution.
18
Aspect Oriented Programming
• La programmation orientée aspect est bien une technique transversale et n’est
pas liée à un langage de programmation particulier
• peut être mise en œuvre aussi bien avec un langage orienté objet comme Java
qu'avec un langage procédural comme le C,
• Le seul pré-requis étant l'existence d'un tisseur d'aspect pour le langage cible.
Exemple de tisseurs d’aspects:
Java : AspectJ , SpringAOP, JbossAOP, JAC (Java Aspect Components)
C++ : AspectC++
C#, VB : AspectDNG
PHP: AspectPHP
C: Aspect-C
19
Aspect Oriented Programming
AspectJ :
• AspectJ est une extension orientée aspect du langage java
• Il a été développé par la même équipe à l'origine de l'AOP.
• Un premier prototype d'AspectJ a été réalisé en 1998.
• En décembre 2002, le projet AspectJ a quitté XEROX PARC et a rejoint la communauté
open-source Eclipse.
• Et depuis, le plugin Eclipse AspectJ Developpement Tools (AJDT) est développé.
• Ce plugin intègre AspectJ et permet d'écrire, de compiler et d'exécuter des
programmes orienté aspects dans l'environnement de développement Eclipse
20
Aspect Oriented Programming
Quelques concepts d’AOP: Terminologies
- Point de jonction (JoinPoint) : Un endroit potentiel de l’application où un aspect
pourra être connecté.
- Point de coupe (PointCuts) : Définit le point de jonction à utiliser pour l’insertion
du greffon.
- Greffon (Advice) : contient les traitements techniques à insérer et exécuter.
- Aspect : Permet d’encapsuler des fonctionnalités techniques. Il comprend plusieurs
points de coupes et plusieurs greffons.
21
Aspect Oriented Programming
Exemple d’implémentation avec AspectJ
22
Aspect Oriented Programming
Quelques concepts d’AOP: Types d’actions d’interception
– Avant (Before) : advice qui s'exécute avant un point de jonction mais qui n’a pas la
capacité d'empêcher le déroulement de l'exécution de la fin de la méthode, à moins qu'il
ne lève une exception.
– Après retour (After returning) : advice à exécuter après un joinpoint pour une méthode
qui se termine sans lever une exception.
– Après une levée d'exception (After throwing) : advice à exécuter si une méthode se
termine en levant une exception.
– Après (After) : advice à exécuter indépendamment du fait qu'il y ait eu ou non une levée
d'exception.
– Autour des advices (Around) : advice qui entoure un point de jonction comme un appel
de méthode. Ceci est le type d'advice le plus puissant.
L'advice Around peut effectuer un comportement personnalisé avant et après l'invocation
de méthode
23
Spring AOP
§ Spring fournit tout un module spécialement dédié à l’AOP.
§ Spring AOP fait le tissage des aspects à l'exécution ce qui est appelé tissage Dynamique
contrairement à AspectJ qui effectue le tissage lors de la compilation (statique).
§ Comme pour la configuration du contexte, il est possible de définir des aspects
sous la forme :
• de fichiers XML
• d’annotations (la plus célébre)
• d’un mix des deux.
24
Spring AOP : Configuration
1. A Ajouter la dépendance suivante dans le fichier [Link]
<dependency>
<groupId>[Link]</groupId>
<artifactId>spring-boot-starter-aop</artifactId>
</dependency>
2. Ajouter l’annotation
@EnableAspectJAutoProxy(proxyTargetClass=true)
Dans la classe de configuration
Dans le cas de de SpringBoot c’est la classe principale contenant le main
25
Spring AOP : Déclaration
• Pour déclarer l’aspect il faut ajouter à la classe l’annotation @Aspect
• Spring AOP détecte automatiquement toutes les classes aspectées (accompagné avec
l’annotation @component aussi).
• Les classes annotées avec @Aspect peuvent avoir des méthodes et des champs comme
toutes les autres classes.
• mais il n’est pas possible d’aspecter un aspect.
26
Spring AOP : Configuration
Exemple des syntaxes les plus utilisées:
• execution(public * *(..)) : toutes les méthodes public ;
• execution(* set*(..)) : toutes les méthodes commençant par 'set' ;
• execution(* [Link].*(..)) : toutes les méthodes de
l'interface 'IaccountService' ;
• execution(* [Link].*.*(..)) : toutes les méthodes du package
'[Link]' ;
• execution(* [Link]..*.*(..)) : toutes les méthodes du packag
'[Link]' et de ses sous-packages.
27
Spring AOP et AspectJ
• Spring AOP se limite à l’exécution de méthodes sur des points de jonction,
• ce qui suffit dans une grande majorité des cas d’utilisation.
• Or, L’interception sur le changement d’état des champs des objets n’est, par
exemple, pas prise en compte dans spring AOP.
• Dans ce cas Spring peut utiliser directement AspectJ pour une utilisation avancée
AspectJ propose d’autres pointcuts qui ne sont pas pris en charge dans
Spring : call, get, set, preinitialization, staticinitialization, initialization, handler,
adviceexecution, withincode, cflow, cflowbelow, if, @this, et @withincode.
Pour les utiliser, il faut basculer vers une utilisation complète de AspectJ
28
Spring AOP: Cas particulier
La gestion des transactions est gérée par Spring via l’annotation @Transactional.
Cette annotation est un aspect particulier gérée directement par Spring.
Exemple (2) d’exigence Technique: l’intégrité des données
29
TP5: Spring AOP-AspectJ
30
TP2 : Hello Word REST
31