- Le socle technique des applications JEE Spring

Java SpringLe socle technique

des applications JEE

Java

Spr

ing

- Le

socl

e te

chni

que

des

appl

icat

ions

JEE

ISSN : 1960-3444ISBN : 978-2-7460-9787-2

54 €

Pour plus d’informations :

Hervé LE MORVAN

Java Spring Le socle technique des applications JEECe livre apporte les éléments clés pour se repérer dans les différentes technologies utilisées dans les projets basés sur Spring. Il prend en compte les différences de configurations liées aux versions de Spring (en version 4.2 au moment de l’écriture) et se base sur des exemples concrets d’utilisation. Il permet au lecteur d’être très rapidement autonome sur un projet d’entreprise qui utilise Spring, que ce soit au début d’un nouveau projet ou pour maintenir un projet existant : compréhension du noyau, accès aux données, maîtrise de la couche web. Des connaissances sur le développement Java et notamment le développement d’applications web sont un prérequis indispensable pour tirer le meilleur parti possible du livre.L’auteur présente tout d’abord les éléments simples et courants de Spring (la configuration, les contextes, les librairies tiers) et explique ensuite certains aspects plus complexes que l’on rencontre souvent dans les projets (Ressources, Bindeurs, Validateurs, Convertisseurs et Tests). La programmation par aspects est expérimentée, les applications web Spring MVC et les Web Services sont présentés en détail avec les tests unitaires associés. L’auteur termine par une présentation de la partie Spring d’un projet généré à partir de jHipster afin d’expli-quer une mise en œuvre très actuelle. Tout au long des chapitres, l’auteur s’appuie sur des exemples fonctionnels afin de permettre l’expérimentation au plus tôt par le lecteur. Dans ce but, des éléments sont en téléchargement sur le site www.editions-eni.fr.

Préambule • Avant-propos • Éléments constitutifs du framework • Spring et les design patterns • Rappels sur les éléments externes à Spring • Le conteneur Spring • Configuration avancée • Les tests et Spring • Partie back de l’application • Spring dans un contexte web JSP • Intégration JSF2 • Spring en profondeur

Les chapitres du livre Hervé LE MORVAN est aujourd’hui consultant DevOps pour de grands comptes de la Banque, de l’Assurance et des Telecoms. Durant ses vingt années d’expérience, il est principalement intervenu en tant que référent technique et for-mateur dans des équipes de Recherche et Déve-loppement ou d’Architectes et en tant que sup-port au développement d’applications sur des missions de migration ou de modernisation de Systèmes d’Informations. À ce titre, il est inter-venu dans de nombreux projets de migrations utilisant le socle Spring et connaît parfaitement les attentes des équipes dans ce domaine. C’est toute cette expérience qu’il partage volontiers tout au long des pages de ce livre.

Téléchargementwww.editions-eni.fr.fr

sur www.editions-eni.fr : b Une quarantaine d’exemples

indépendants et de différents niveaux de complexité.

1Table des matières

Avant-propos1. Préambule . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

2. Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17

3. Organisation du livre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19

4. Public visé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19

5. Pourquoi Spring . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20

6. Prérequis pour aborder sereinement la lecture de ce livre . . . . . . . . . 20

7. Objectifs du livre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

Chapitre 1Éléments constitutifs du framework

1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 231.1 Historique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 231.2 Utilité de Spring dans un projet . . . . . . . . . . . . . . . . . . . . . . . . . 25

2. Vue d'ensemble et sujets abordés dans l'ouvrage . . . . . . . . . . . . . . . . 292.1 Les modules Spring . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 292.2 Sujets abordés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 302.3 Version des briques Spring utilisées dans l'ouvrage . . . . . . . . . . 312.4 Version des ressources externes . . . . . . . . . . . . . . . . . . . . . . . . . . 322.5 Gestion des dépendances Maven . . . . . . . . . . . . . . . . . . . . . . . . . 322.6 Utilisation d'un BOM (Bill of Materials) Maven . . . . . . . . . . . . 34

3. Points clés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34

Les éléments à télécharger sont disponibles à l'adresse suivante :http://www.editions-eni.fr

Saisissez la référence de l'ouvrage EPJASP dans la zone de recherche et validez. Cliquez sur le titre du livre puis sur le bouton de téléchargement.

2Le socle technique des applications JEE

Java Spring

Chapitre 2Spring et les design patterns

1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35

2. Le singleton en Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 372.1 Préoccupation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 372.2 Solution Spring . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 382.3 Exemple. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39

3. L'inversion de contrôle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41

4. Façade . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43

5. Fabrique. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43

6. Active record . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44

7. Proxy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44

8. Modèle Vue Contrôleur (MVC) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46

9. Le contrôleur de partie frontale (Front Controller) . . . . . . . . . . . . . . 47

10. Les assistants de vue (View Helper) . . . . . . . . . . . . . . . . . . . . . . . . . . 48

11. Les templates . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49

12. Stratégie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50

13. Points clés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50

Chapitre 3Rappels sur les éléments externes à Spring

1. Codage equals et hashCode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 511.1 Description de la problématique . . . . . . . . . . . . . . . . . . . . . . . . . 541.2 Mise en œuvre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55

2. Projet Lombok. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56

3. Les systèmes de log. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59


4. Bases de données H2. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 614.1 Description de la problématique . . . . . . . . . . . . . . . . . . . . . . . . . 614.2 Mise en œuvre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61

4.2.1 Installation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 614.2.2 Configuration du POM. . . . . . . . . . . . . . . . . . . . . . . . . . . 624.2.3 Connexion à la base de données en utilisant JDBC . . . . 624.2.4 Utiliser un listener de servlet pour démarrer

et arrêter la base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63

5. Projets Maven . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 645.1 Description de la problématique . . . . . . . . . . . . . . . . . . . . . . . . . 645.2 Mise en œuvre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 655.3 Installation de Maven sous Windows. . . . . . . . . . . . . . . . . . . . . 665.4 Utilisation d'un archétype Maven . . . . . . . . . . . . . . . . . . . . . . . . 665.5 Contenu du fichier pom.xml dans les cas simples utilisés

dans ce livre. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67

6. Points clés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69

Chapitre 4Le conteneur Spring

1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71

2. Les contextes de Spring . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72

3. Configuration des beans. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 723.1 Fichier XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 743.2 Annotations pour configurer l'application . . . . . . . . . . . . . . . . . 753.3 Configurer les beans applicatifs implicitement . . . . . . . . . . . . . 76

4. Utilisation des beans : injection par setters et constructeurs . . . . . . 774.1 Mapping via le constructeur en XML . . . . . . . . . . . . . . . . . . . . . 784.2 Comparaison des méthodes d'instanciation . . . . . . . . . . . . . . . . 79

5. Contrôle du cycle de vie : construction et destruction . . . . . . . . . . . 80


Java Spring

6. Exemple illustrant les mappings standards. . . . . . . . . . . . . . . . . . . . . 816.1 Le projet Maven . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 816.2 Fichier de configuration de Spring. . . . . . . . . . . . . . . . . . . . . . . . 816.3 Dépendance Spring Core et système de log . . . . . . . . . . . . . . . . 826.4 Dépendance vers les librairies de tests unitaires. . . . . . . . . . . . . 836.5 Exemple illustrant l'utilisation des logs . . . . . . . . . . . . . . . . . . . 846.6 Fichier de configuration spécifique pour les tests. . . . . . . . . . . . 84

7. Points clés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86

Chapitre 5Configuration avancée

1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87

2. Fichier XML et fichiers properties . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87

3. Les fichiers de ressources . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 883.1 Les fichiers de ressources standards. . . . . . . . . . . . . . . . . . . . . . . 883.2 Les fichiers de ressources chargés via le contexte . . . . . . . . . . . . 903.3 Les fichiers de ressources chargés via

un service ResourceLoaderAware . . . . . . . . . . . . . . . . . . . . . . . . 913.3.1 Le programme principal . . . . . . . . . . . . . . . . . . . . . . . . . . 913.3.2 Le service ResourceLoaderAware . . . . . . . . . . . . . . . . . . . 92

4. Convertisseurs et formateurs. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 924.1 Built-in converters . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93

4.1.1 Pour les types standards . . . . . . . . . . . . . . . . . . . . . . . . . . 934.1.2 Pour les tableaux et les listes . . . . . . . . . . . . . . . . . . . . . . 944.1.3 Pour les énumérations. . . . . . . . . . . . . . . . . . . . . . . . . . . . 944.1.4 Pour les objets en général . . . . . . . . . . . . . . . . . . . . . . . . . 95

4.2 Convertir un Array en Collection et String . . . . . . . . . . . . . . . . 964.3 Converter Factory. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97

4.3.1 Classe StringToUtilisateurConverterFactory . . . . . . . . . 974.3.2 Classe UtilisateurToStringConverterFactory . . . . . . . . . 984.3.3 Classe LesConversions5 . . . . . . . . . . . . . . . . . . . . . . . . . . 98


4.4 Les convertisseurs et les formateurs par défaut . . . . . . . . . . . . . 994.4.1 Classe LesConversions6 . . . . . . . . . . . . . . . . . . . . . . . . . . 99

4.5 Les formateurs personnalisés . . . . . . . . . . . . . . . . . . . . . . . . . . . 1004.5.1 Classe CarteDeCredit . . . . . . . . . . . . . . . . . . . . . . . . . . . 1004.5.2 Classe CarteDeCreditParser . . . . . . . . . . . . . . . . . . . . . . 1004.5.3 Classe CarteDeCreditPrinter . . . . . . . . . . . . . . . . . . . . . 1014.5.4 Classe CarteDeCreditFormatter . . . . . . . . . . . . . . . . . . 1014.5.5 Classe LesConversions7 . . . . . . . . . . . . . . . . . . . . . . . . . 102

5. Les BeanWrappers, le binding et les validateurs . . . . . . . . . . . . . . . . 1035.1 Classe LesBeanWrappers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1035.2 Classe UtilisateurValidator . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104

6. Points clés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104

Chapitre 6Programmation orientée aspect avec Spring

1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105

2. Les concepts d’AOP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106

3. Limites de Spring AOP et utilisation d’AspectJ . . . . . . . . . . . . . . . . 107

4. Le support @AspectJ dans Spring . . . . . . . . . . . . . . . . . . . . . . . . . . . 1084.1 Activation du support . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1084.2 Activation de @AspectJ avec configuration XML . . . . . . . . . . 1084.3 Déclaration d'un aspect . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1094.4 Déclaration d'un pointcut . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1104.5 Déclaration des greffons simples . . . . . . . . . . . . . . . . . . . . . . . . 1124.6 Les types génériques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1144.7 Détermination de noms d'arguments . . . . . . . . . . . . . . . . . . . . 1154.8 Ordre d’appel des greffons interceptant le point de jonction . 1154.9 Injection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1164.10 Le mécanisme des proxies . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1164.11 La face cachée des proxies en AOP . . . . . . . . . . . . . . . . . . . . . . 117


Java Spring

5. Les API bas niveau pour Spring AOP. . . . . . . . . . . . . . . . . . . . . . . . . 1205.1 L’interface PointCut . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1205.2 L’interface ClassFilter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1215.3 L’interface MethodMatcher. . . . . . . . . . . . . . . . . . . . . . . . . . . . 121

6. Points clés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121

Chapitre 7Les tests et Spring

1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123

2. Les Mock Objects . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1242.1 Mocks spécialisés pour "environnement" . . . . . . . . . . . . . . . . . 1242.2 Support . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125

2.2.1 Utilités générales. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1252.2.2 Spring MVC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126

2.3 Tests d'intégration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1262.3.1 Vue d'ensemble . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1262.3.2 Mise en cache du contexte de test . . . . . . . . . . . . . . . . . 1272.3.3 Tests back et front . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128

2.4 Annotations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1292.4.1 @ContextConfiguration . . . . . . . . . . . . . . . . . . . . . . . . 1292.4.2 @WebAppConfiguration . . . . . . . . . . . . . . . . . . . . . . . . 1292.4.3 @ContextHierarchy . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1302.4.4 @ActiveProfiles. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1312.4.5 @TestPropertySource. . . . . . . . . . . . . . . . . . . . . . . . . . . 1312.4.6 @DirtiesContext . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1322.4.7 @TestExecutionListeners. . . . . . . . . . . . . . . . . . . . . . . . 1322.4.8 @TransactionConfiguration . . . . . . . . . . . . . . . . . . . . . 1332.4.9 @Transactional. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1332.4.10 @Rollback . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1342.4.11 @BeforeTransaction . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1342.4.12 @AfterTransaction. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1342.4.13 @Sql, @SqlConfig et @SqlGroup . . . . . . . . . . . . . . . . . 134


2.5 Annotations standards . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135

3. Les frameworks de test JUnit et testNG . . . . . . . . . . . . . . . . . . . . . . 1363.1 Utilisation avec JUnit. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136

3.1.1 Spring JUnit Runner . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1363.1.2 @IfProfileValue. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1373.1.3 @ProfileValueSourceConfiguration . . . . . . . . . . . . . . . 1373.1.4 @Timed. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1373.1.5 @Repeat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1383.1.6 Méta-annotations de support pour les tests . . . . . . . . . 138

3.2 Les arcanes du framework Spring TestContext . . . . . . . . . . . . 1403.2.1 Classes et interfaces du framework de tests . . . . . . . . . 1403.2.2 Configuration du TestExecutionListener

par les annotations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1423.2.3 Les TestExecutionListeners . . . . . . . . . . . . . . . . . . . . . . 1423.2.4 Mélange XML et classes annotées . . . . . . . . . . . . . . . . . 147

3.3 Configuration des contextes de tests . . . . . . . . . . . . . . . . . . . . 1473.3.1 Configuration de contexte avec des initialiseurs

de contexte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1473.3.2 L’héritage dans la configuration des contextes . . . . . . . 1483.3.3 Prise en compte des profils d'environnement . . . . . . . . 1493.3.4 Configuration de contexte avec des fichiers

de propriétés de test . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1543.3.5 Déclarer un fichier de propriétés pour les tests . . . . . . . 1553.3.6 Détection du fichier de propriétés par défaut . . . . . . . . 156

3.4 Hiérarchie des contextes de tests. . . . . . . . . . . . . . . . . . . . . . . . 1563.4.1 Héritage et surcharge des propriétés de test . . . . . . . . . 1563.4.2 Chargement d'un WebApplicationContext . . . . . . . . . 1573.4.3 Conventions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1583.4.4 La sémantique de ressources explicite . . . . . . . . . . . . . . 1583.4.5 Injecter des objets mockés . . . . . . . . . . . . . . . . . . . . . . . 1593.4.6 Cachabilité du contexte de test . . . . . . . . . . . . . . . . . . . 1603.4.7 Les hiérarchies des contextes . . . . . . . . . . . . . . . . . . . . . 1613.4.8 L'injection de dépendance dans les tests . . . . . . . . . . . . 164


Java Spring

3.5 Le scope session lors d’un test de requête . . . . . . . . . . . . . . . . . 1663.5.1 Le scope session lors d’un test de requête . . . . . . . . . . . 1663.5.2 Test de beans de scope request . . . . . . . . . . . . . . . . . . . 1673.5.3 Configuration d’un bean de scope session . . . . . . . . . . 168

3.6 Les transactions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1693.6.1 La gestion des transactions. . . . . . . . . . . . . . . . . . . . . . . 1693.6.2 Les transactions managées par le test . . . . . . . . . . . . . . 1693.6.3 Activation et désactivation des transactions . . . . . . . . 1703.6.4 Comportement du commit et du rollback

d’une transaction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1713.6.5 Exécution de code en dehors d'une transaction . . . . . . 1723.6.6 Configuration d'un gestionnaire de transactions . . . . . 1723.6.7 Démonstration de toutes les annotations

liées à la transaction . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1733.7 Les scripts SQL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174

3.7.1 Exécuter des scripts SQL . . . . . . . . . . . . . . . . . . . . . . . . 1743.7.2 La sémantique du path des ressources . . . . . . . . . . . . . . 1763.7.3 La détection de script par défaut . . . . . . . . . . . . . . . . . . 1773.7.4 Déclaration de plusieurs @Sql . . . . . . . . . . . . . . . . . . . . 1773.7.5 Phases d'exécution pour les scripts . . . . . . . . . . . . . . . . 1783.7.6 Script de configuration avec SqlConfig . . . . . . . . . . . . . 1783.7.7 La gestion des transactions pour @Sql . . . . . . . . . . . . . 179

3.8 Classes de support cadres TestContext . . . . . . . . . . . . . . . . . . 1813.8.1 Classes de support de JUnit . . . . . . . . . . . . . . . . . . . . . . 1813.8.2 Spring JUnit Runner . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1823.8.3 Classes de support TestNG . . . . . . . . . . . . . . . . . . . . . . 182

3.9 Framework Spring MVC Test . . . . . . . . . . . . . . . . . . . . . . . . . . 1833.9.1 Projet autonome . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1833.9.2 Tests côté serveur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1843.9.3 Définir les attentes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1903.9.4 Filtrer les inscriptions . . . . . . . . . . . . . . . . . . . . . . . . . . . 1923.9.5 Tests REST côté client . . . . . . . . . . . . . . . . . . . . . . . . . . 192

3.10 Autres ressources . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193


4. Points clés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193

Chapitre 8Partie back de l’application

1. Description de la problématique . . . . . . . . . . . . . . . . . . . . . . . . . . . . 195

2. Mise en œuvre. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1972.1 Configuration d’une entité de la couche domaine . . . . . . . . . . 1972.2 Accès à l'objet du domaine . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1992.3 Requêtes typées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2012.4 Cache de niveaux 1 et 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2012.5 Bean Validation (JSR-303) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2022.6 L'API Criteria. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2042.7 Accès à la base de données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2042.8 Le fichier persistence.xml . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2042.9 Tests JPA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 205

3. Points clés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 207

Chapitre 9Spring dans un contexte web JSP

1. Spring MVC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2091.1 Fonctionnement global . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 209

1.1.1 Configuration simple XML . . . . . . . . . . . . . . . . . . . . . . 2091.1.2 Configuration par annotation . . . . . . . . . . . . . . . . . . . . 213

1.2 Éléments complexes du contrôleur . . . . . . . . . . . . . . . . . . . . . . 2141.2.1 Fonctionnement global du contrôleur . . . . . . . . . . . . . . 2141.2.2 Exemple de la classe Simple . . . . . . . . . . . . . . . . . . . . . . 2151.2.3 Simple revisité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2161.2.4 Par le path . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2161.2.5 Par un motif sur le path . . . . . . . . . . . . . . . . . . . . . . . . . 2171.2.6 Par le path et une méthode. . . . . . . . . . . . . . . . . . . . . . . 218


Java Spring

1.2.7 Mappé par path + méthode + présence de paramètres de query . . . . . . . . . . . . . . . . . . 218

1.2.8 Mappé par path + méthode + présence d’un header. . 2191.2.9 Par l'absence d'un header . . . . . . . . . . . . . . . . . . . . . . . . 2191.2.10 Par consommation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2201.2.11 Par production via Accept=application/json . . . . . . . . 2201.2.12 Par production via Accept=application/xml . . . . . . . . 2211.2.13 Paramètres de query . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2221.2.14 Groupes de paramètres de query . . . . . . . . . . . . . . . . . . 2231.2.15 Variable du path . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2231.2.16 Variable Matrix . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2241.2.17 Variables Matrix multiples. . . . . . . . . . . . . . . . . . . . . . . 2251.2.18 Header . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2251.2.19 Obtention du cookie . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2261.2.20 Corps de la requête . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2261.2.21 En-tête et corps de la requête . . . . . . . . . . . . . . . . . . . . . 2271.2.22 Arguments de la requête. . . . . . . . . . . . . . . . . . . . . . . . . 2281.2.23 Reader sur la requête. . . . . . . . . . . . . . . . . . . . . . . . . . . . 2291.2.24 InputStream de la requête . . . . . . . . . . . . . . . . . . . . . . . 2291.2.25 Arguments de la réponse . . . . . . . . . . . . . . . . . . . . . . . . 2301.2.26 Writer de la réponse . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2311.2.27 OutputStream de la réponse . . . . . . . . . . . . . . . . . . . . . 2311.2.28 Session . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2321.2.29 Handler personnalisé . . . . . . . . . . . . . . . . . . . . . . . . . . . 2321.2.30 Utiliser l’annotation @ResponseBody seule . . . . . . . . . 2341.2.31 Utiliser l’annotation @ResponseBody

avec UTF-8 requis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2341.2.32 Utiliser l’annotation @ResponseBody

avec UTF-8 produit. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2351.2.33 Réponse avec un statut personnalisé . . . . . . . . . . . . . . . 2361.2.34 Réponse avec un en-tête personnalisé . . . . . . . . . . . . . . 2361.2.35 Lire une chaîne de caractères . . . . . . . . . . . . . . . . . . . . . 2371.2.36 Écrire une chaîne de caractères. . . . . . . . . . . . . . . . . . . . 238


1.2.37 Lire les données encodées dans l’URL . . . . . . . . . . . . . . 2381.2.38 Retourner une MultiValueMap . . . . . . . . . . . . . . . . . . . 2391.2.39 Lire une structure XML . . . . . . . . . . . . . . . . . . . . . . . . . 2401.2.40 Écrire dans une structure XML

via Accept=application/xml . . . . . . . . . . . . . . . . . . . . . 2401.2.41 Lire une structure JSON . . . . . . . . . . . . . . . . . . . . . . . . . 2411.2.42 Écrire dans une structure JSON

via Accept=application/json . . . . . . . . . . . . . . . . . . . . . 2421.2.43 Lire un Atom . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2431.2.44 Écrire un Atom . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2441.2.45 Lire un flux RSS. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2441.2.46 Écrire un flux RSS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2451.2.47 HTML généré par un template JSP . . . . . . . . . . . . . . . . 2461.2.48 Mapping à partir d’un modèle . . . . . . . . . . . . . . . . . . . . 2471.2.49 Utiliser des variables dans un template de vue . . . . . . . 2471.2.50 Data binding avec des variables d'URI. . . . . . . . . . . . . . 2481.2.51 Types primitifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2481.2.52 Date . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2531.2.53 Conversion des collections . . . . . . . . . . . . . . . . . . . . . . . 2531.2.54 Utiliser des collections formatées. . . . . . . . . . . . . . . . . . 2541.2.55 Utiliser des objets personnalisés. . . . . . . . . . . . . . . . . . . 2551.2.56 Utiliser un convertisseur personnalisé . . . . . . . . . . . . . . 2551.2.57 Validation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2591.2.58 @ExceptionHandler dans un contrôleur. . . . . . . . . . . . 2601.2.59 @ExceptionHandler global. . . . . . . . . . . . . . . . . . . . . . . 2601.2.60 Templates de String pour les URI . . . . . . . . . . . . . . . . . 2611.2.61 UriComponentsBuilder . . . . . . . . . . . . . . . . . . . . . . . . . 2621.2.62 GET /async/callable/response-body . . . . . . . . . . . . . . . 2621.2.63 GET /async/callable/view . . . . . . . . . . . . . . . . . . . . . . . 2641.2.64 GET /async/callable/exception . . . . . . . . . . . . . . . . . . . 2651.2.65 GET /async/callable/custom-timeout-handling . . . . . . 2661.2.66 GET /async/deferred-result/response-body . . . . . . . . . 2671.2.67 GET /async/deferred-result/model-and-view . . . . . . . . 268


Java Spring

1.2.68 GET /async/deferred-result/exception . . . . . . . . . . . . . 2681.2.69 GET /async/deferred-result/timeout-value. . . . . . . . . . 269

2. Client REST . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2702.1 Utilisation du RestTemplate . . . . . . . . . . . . . . . . . . . . . . . . . . . 2702.2 Le bean de domaine avec l'annotation REST

pour les champs manquants . . . . . . . . . . . . . . . . . . . . . . . . . . . 271

3. Spring Security . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2713.1 Introduction à Spring Security . . . . . . . . . . . . . . . . . . . . . . . . . 2713.2 Spring Security dans un environnement web . . . . . . . . . . . . . 273

3.2.1 Authentification par Spring . . . . . . . . . . . . . . . . . . . . . . 2743.2.2 Authentification par page de login personnalisée. . . . . 2743.2.3 Authentification par base de données . . . . . . . . . . . . . . 274

4. Points clés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 276

Chapitre 10Intégration JSF2

1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 277

2. Majorra . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 277

3. Architecture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 278

4. Cycle de vie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2804.1 Requête . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2804.2 Restore View ou Reconstruct Component Tree . . . . . . . . . . . 2804.3 Apply Request Value . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2814.4 Perform Validation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2814.5 Synchronize Model ou Update Model Values . . . . . . . . . . . . . 2814.6 Invoke Application Logic . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2824.7 Render Response. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2824.8 Réponse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2824.9 Fichier web.xml . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2824.10 Dépendances . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2834.11 Fichier faces-config.xml . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 283


4.12 Bean managé sans Spring . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2854.13 Exemple de vue JSF. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2854.14 Apercu d’un composant JSF. . . . . . . . . . . . . . . . . . . . . . . . . . . . 286

5. Intégration Spring . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2875.1 Architecture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2885.2 Dépendances . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2885.3 Fichier web.xml . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2885.4 Fichier faces-config.xml . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2895.5 Couches basses (back) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 290

6. Points clés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 290

Chapitre 11Spring en profondeur

1. Étude de cas : les applications générées avec JHipster . . . . . . . . . . . 291

2. Structure du projet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2922.1 La partie front . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2922.2 Les grandes lignes de la partie back . . . . . . . . . . . . . . . . . . . . . . 292

2.2.1 Spring Boot . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2922.2.2 Système de gestion des dépendances . . . . . . . . . . . . . . . 2932.2.3 Utilisation de Spring Security . . . . . . . . . . . . . . . . . . . . 2932.2.4 Spring MVC REST + Jackson . . . . . . . . . . . . . . . . . . . . 2932.2.5 Support optionnel de WebSocket

avec Spring WebSocket. . . . . . . . . . . . . . . . . . . . . . . . . . 2932.2.6 Spring Data JPA + Bean Validation . . . . . . . . . . . . . . . 2932.2.7 Évolution des bases de données avec Liquibase. . . . . . . 2932.2.8 Support Elasticsearch . . . . . . . . . . . . . . . . . . . . . . . . . . . 2942.2.9 Bases SQL et NoSQL. . . . . . . . . . . . . . . . . . . . . . . . . . . . 2942.2.10 Packaging multiplateforme. . . . . . . . . . . . . . . . . . . . . . . 2942.2.11 Monitoring et métriques . . . . . . . . . . . . . . . . . . . . . . . . 2942.2.12 Autres avantages non abordés . . . . . . . . . . . . . . . . . . . . 294


Java Spring

3. Spring Boot . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2953.1 Dépendances Maven . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2953.2 Configuration de l’application. . . . . . . . . . . . . . . . . . . . . . . . . . 296

3.2.1 La classe Application qui contient le main . . . . . . . . . . 2963.2.2 La classe serveur http/servlet . . . . . . . . . . . . . . . . . . . . . 2973.2.3 La classe de configuration de la sécurité des URL. . . . . 3023.2.4 La classe de configuration de la sécurité SecurityUtils . 308

4. Spring Data JPA + Bean Validation . . . . . . . . . . . . . . . . . . . . . . . . . 3094.1 La couche domaine . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 310

4.1.1 La classe Book . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3104.1.2 La classe User. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 311

5. Spring MVC REST + Jackson . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3125.1 La classe BookRepository . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3125.2 La classe UserRepository . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3125.3 La classe CustomAuditEventRepository. . . . . . . . . . . . . . . . . . 3135.4 La couche Service . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3135.5 La couche Resource. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 314

5.5.1 Contrôleur REST. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3145.5.2 Création ou mise à jour d’un livre . . . . . . . . . . . . . . . . . 3145.5.3 Obtenir la liste de livres . . . . . . . . . . . . . . . . . . . . . . . . . 3155.5.4 Obtenir le détail d’un livre . . . . . . . . . . . . . . . . . . . . . . . 3165.5.5 Supprimer un livre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 316

6. Configuration de Logback . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 317

7. La classe PaginationUtil . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 318

8. Points clés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 320

Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 321

Chapitre 6Programmation orientée aspect

avec SpringProgrammation orientée aspect avec Spring1. Introduction

L’AOP (programmation orientée aspect) ajoute des notions de transversalitésqui ne sont pas disponibles dans la programmation orientée objet (POO).Cette transversalité est centrée sur les aspects, qui permettent d’ajouter untraitement spécifique quand un type d’évènement s’exécute sur un ensembled’objets. Il est alors possible d’ajouter des préoccupations telles que la gestiondes transactions qui est transverse à un ensemble d’objets. L’AOP est indépen-dante du noyau Spring. On ne l’ajoute que si elle est nécessaire.

Comme pour la configuration du contexte, il est possible de définir des aspectssous la forme de fichiers XML ou d’annotations ou d’un mix des deux. Lagestion des transactions est gérée par Spring via les @Transactional, cetteannotation est un aspect particulier géré directement par Spring.

Les aspects sont généralement mis dans le socle technique et répondent à despréoccupations techniques comme par exemple l’instrumentation du code. Ilsne sont que très rarement exploités pour des préoccupations métiers car cetype de programmation est complexe au niveau de la maintenance. Le codedes traitements AOP doit donc être soigné et très bien commenté.

© E

diti

ons

ENI -

All

righ

ts r

eser

ved


Java Spring

2. Les concepts d’AOPSpring utilise la terminologie standard pour nommer ses éléments relatifs àl’AOP même si elle n’est pas très intuitive.

– Aspect : modularisation d'une préoccupation qui concerne un ensembleclasses de façon transverse.

– Point de jonction (Joinpoint) : une étape au cours de l'exécution d'un pro-gramme, comme l'exécution d'une méthode ou le traitement d'une excep-tion. Dans Spring AOP, un point de jonction représente toujours uneexécution de méthode.

– Greffon (Advice) : les actions d’interception prises par un aspect particulierà un point de jonction. Les différents types d’actions sont « autour »,« avant » et « après ». Il est possible de chaîner ces intercepteurs.

– Coupe (Pointcut) : un prédicat qui permet de sélectionner des points dejonction à travers une expression qui indique par exemple le nom d’uneméthode. Spring utilise le langage de AspectJ par défaut.

– Introduction : permet d’injecter dynamiquement des champs et desméthodes supplémentaires dans un objet. Spring AOP vous permet aussid'introduire dynamiquement de nouvelles interfaces avec leurs implémen-tations. Une injection est connue comme une déclaration « inter-types »dans la communauté AspectJ.

– Objet ciblé (Target object) : objet ciblé par un ou plusieurs aspects. On parleaussi d’objet aspecté. Spring utilise toujours des proxies pour les objets as-pectés.

– AOP proxy : un objet créé par le cadre AOP afin de mettre en œuvre lescontrats d'aspect, un proxy AOP sera un proxy dynamique JDK ou un proxyCGLIB.

– Tissage d'aspect (Weaving) : lie les aspects avec d'autres types ou d'objetsapplication pour créer un objet aspecté. Cela peut être fait au moment de lacompilation avec AspectJ, au chargement, ou à l'exécution. Spring AOP faitle tissage à l'exécution.

107Programmation orientée aspect avec SpringChapitre 6

Types d’actions d’interception :

– Avant (Before) : advice qui s'exécute avant un point de jonction mais qui n'apas la capacité d'empêcher le déroulement de l'exécution de la fin de laméthode, à moins qu'il ne lève une exception.

– Après retour (After returning) : advice à exécuter après un joinpoint pourune méthode qui se termine sans lever une exception.

– Après une levée d'exception (After throwing) : advice à exécuter si uneméthode se termine en levant une exception.

– Après (After) : advice à exécuter indépendamment du fait qu'il y ait eu ounon une levée d'exception.

– Autour des advices (Around) : advice qui entoure un point de jonctioncomme un appel de méthode. Ceci est le type d'advice le plus puissant.L'advice Around peut effectuer un comportement personnalisé avant etaprès l'invocation de méthode.

Il permet de faire une action avant la méthode interceptée, il permet deremplacer le code de la méthode interceptée si on le souhaite, il permet ausside faire une action après l'appel de la méthode interceptée (ou remplacée) etpeut même intercepter les exceptions et ne pas les transmettre à l'appelant.

Remarque

Il faut utiliser le type d’interception le plus simple par rapport à la fonctionnalitévoulue. Les valeurs de retours des méthodes des aspects doivent être simples.

Remarque

Les objets aspectés doivent garder leur indépendance et ne doivent pas parconséquent voir les aspects pour rester dans l’esprit non invasif de Spring.

3. Limites de Spring AOP et utilisation d’AspectJSpring AOP se limite à l’exécution de méthodes sur des points de jonction, cequi suffit dans une grande majorité des cas d’utilisation. L’interception sur lechangement d’état des champs des objets n’est, par exemple, pas prise encompte. On utilisera plutôt directement AspectJ pour une utilisation avancée.

© E

diti

ons

ENI -

All

righ

ts r

eser

ved


Java Spring

4. Le support @AspectJ dans SpringOn utilise ce support pour réutiliser l’interprétation des annotations deAspectJ pour la recherche et la détection des méthodes candidates pour unaspect. Seul le support des annotations est utilisé. Spring n’utilise pas letisseur d’aspect d’AspectJ.

Il est tout à fait possible d'utiliser AspecJ en entier en conjonction de Springpour des cas complexes pour lesquels Spring ne suffirait pas.

4.1 Activation du support

La librairie AspectJ aspectjweaver.jar doit être dans le classpath.

<dependency> <groupId>aopalliance</groupId> <artifactId>aopalliance</artifactId> <version>1.0</version></dependency><dependency> <groupId>org.aspectj</groupId> <artifactId>aspectjweaver</artifactId> <version>1.6.8</version></dependency>

4.2 Activation de @AspectJ avec configuration XML

Pour activer AspectJ support avec une configuration basée sur XML, il faututiliser l'élément AOP aspectj-autoproxy.

Ajoutez cet élément dans la configuration et vérifiez qu’il y a bien la définitionde l’AOP :

<beans default-lazy-init="true" xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xmlns:jdbc="http://www.springframework.org/schema/jdbc" xmlns:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation="

109Programmation orientée aspect avec SpringChapitre 6

http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.1.xsd http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-4.1.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.1.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd"> <aop:aspectj-autoproxy/> <import resource="classpath*:spring/applicationContext.xml" /> <context:component-scan base-package="fr.eni.editions" /></beans>

4.3 Déclaration d'un aspect

Une fois @AspectJ activé, Spring AOP détecte automatiquement toutes lesclasses aspectées. Il est possible de déclarer l’aspect pour une classe par uneannotation @Aspect (org.aspectj.lang.annotation.Aspect) oudans le fichier XML.

La déclaration des aspects dans le fichier de configuration XML n’est pas abor-dée car elle est massivement remplacée par les annotations. Le bean correspon-dant à la classe aspectée est par défaut un singleton. L’objet peut contenir desméthodes et des variables ainsi que des pointcuts, des advices et des déclara-tions inter-types.

Remarque

L’annotation @Aspect ne suffit pas toujours pour trouver le bean dans le class-path. Il faut parfois ajouter un complément avec l’annotation @Component.

Les classes annotées avec @Aspect peuvent avoir des méthodes et deschamps comme toutes les autres classes, mais il n’est pas possible d’aspecterun aspect.

© E

diti

ons

ENI -

All

righ

ts r

eser

ved


Java Spring

4.4 Déclaration d'un pointcut

Spring permet l’interception d’un ensemble de méthodes à partir de leur nomen détectant des points communs dans la typologie de leurs signatures.

@Pointcut("execution(* voir*(..))")public void aspectjLoadTimeWeavingExamples() {

Le pointcut est appelé avant la méthode interceptée et peut modifier puisretourner l’objet retourné par la méthode interceptée.

Remarque

AspectJ propose d’autres pointcuts qui ne sont pas pris en charge dansSpring : 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.

Les verbes suivants indiquent le type de coupe :

Il est également possible de limiter les candidats avec des critères :

On ne peut intercepter que des méthodes publiques. Les méthodes privateet protected ne sont pas prises en compte pour les aspects.

execute se base sur le nom de la méthode.

within se base sur le type de la méthode.

this se base sur la référence du proxy de l’objet.

target se base sur le type de l’objet référencé par le proxy.

args se base sur le type des arguments de la méthode.

@target filtre sur la présence d’une annotation de ce type sur l’objet.

@args filtre sur la présence d’une annotation de ce type sur les paramètres de la méthode.

@within filtre sur la présence d’une annotation de ce type sur la méthode.

@annotation filtre sur le type de la méthode ciblée par l’annotation.

Documents

- Le socle technique des applications JEE Spring