Vous êtes sur la page 1sur 9

Les exemples cités tout au long de cet ouvrage sont téléchargeables

à l'adresse suivante : http://www.editions-eni.fr


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

Chapitre 1
Introduction
1. Quelques lignes d'histoire . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
1.1. La structuration des applications informatiques . . . . . . . . . . . . . . 13
1.1.1. De l'application au framework. . . . . . . . . . . . . . . . . . . 13
1.1.2. De l'isolement à la collaboration. . . . . . . . . . . . . . . . . . 13
1.2. Les challenges d'une application informatique . . . . . . . . . . . . . . . 13
1.3. La structure type d'une application actuelle . . . . . . . . . . . . . . . . 14
2. Inversion de contrôle et injection de dépendances . . . . . . . . . . . . . . . 15
2.1. L'inversion de contrôle . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.1.1. Le modèle classique : écrire des contrôleurs spécifiques . . . . . . 16
2.1.2. Le modèle alternatif : utiliser des contrôleurs génériques . . . . . . 17
2.2. L'injection de dépendances . . . . . . . . . . . . . . . . . . . . . . . 18

Chapitre 2
Présentation de la galaxie Spring
1. Historique rapide . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
1.1. Les origines . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
1.2. Les débuts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
1.3. Les étapes clés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
2. Spring aujourd'hui . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
2.1. Le module de fondation : Spring Framework . . . . . . . . . . . . . . . 23
2.2. Les modules d'architecture applicative . . . . . . . . . . . . . . . . . . 24
2.2.1. Spring Web Flow . . . . . . . . . . . . . . . . . . . . . . . . 24
2.2.2. Spring Security . . . . . . . . . . . . . . . . . . . . . . . . . 24
2.3. Les modules d'intégration applicative. . . . . . . . . . . . . . . . . . . 24
2.3.1. Spring Web Services. . . . . . . . . . . . . . . . . . . . . . . 24
2.3.2. Spring Batch . . . . . . . . . . . . . . . . . . . . . . . . . . 25
2.3.3. Spring Dynamic Modules . . . . . . . . . . . . . . . . . . . . . 25
2.3.4. Spring Integration . . . . . . . . . . . . . . . . . . . . . . . . 25
2.4. Les modules de développement . . . . . . . . . . . . . . . . . . . . . 26
2.4.1. Spring ROO . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
2.4.2. Spring IDE. . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
2.4.3. Spring STS . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
2.4.4. Spring Bean Doc. . . . . . . . . . . . . . . . . . . . . . . . . 27
2.5. Les modules d'ouverture technologique . . . . . . . . . . . . . . . . . . 27
2.5.1. Spring Rich Client . . . . . . . . . . . . . . . . . . . . . . . . 27
2.5.2. Spring .Net . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
2.5.3. Spring Blaze DS . . . . . . . . . . . . . . . . . . . . . . . . . 28
2.6. Autres modules. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
2.6.1. Spring Modules . . . . . . . . . . . . . . . . . . . . . . . . . 28
2.6.2. Spring Extensions . . . . . . . . . . . . . . . . . . . . . . . . 28
2.6.3. Spring Java Config. . . . . . . . . . . . . . . . . . . . . . . . 29
2.6.4. Spring LDAP. . . . . . . . . . . . . . . . . . . . . . . . . . . 29
3. L'avenir . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29

Chapitre 3
Le projet d'application exemple
1. Objectifs de l'application . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
2. Description fonctionnelle de l'application . . . . . . . . . . . . . . . . . . . . 33
2.1. Entités informationnelles utilisées . . . . . . . . . . . . . . . . . . . . 33
2.2. Principales règles de gestion applicables . . . . . . . . . . . . . . . . . 33
2.3. Fonctions attendues . . . . . . . . . . . . . . . . . . . . . . . . . . 34
3. Description technique de l'application . . . . . . . . . . . . . . . . . . . . . 34

Chapitre 4
Le tiers métier : Spring Framework
1. Le tiers métier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
1.1. Définition. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
1.2. Rôles et responsabilités . . . . . . . . . . . . . . . . . . . . . . . . . 37
1.3. Un ou plusieurs tiers métier ? . . . . . . . . . . . . . . . . . . . . . . 38
2. Le conteneur léger Spring . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
2.1. Notion de conteneur applicatif . . . . . . . . . . . . . . . . . . . . . . 38
2.2. Un conteneur léger . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
2.3. Architecture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
3. Installation de l'environnement de travail . . . . . . . . . . . . . . . . . . . . 43
3.1. Remarque préliminaire . . . . . . . . . . . . . . . . . . . . . . . . . 43
3.2. Environnement Java . . . . . . . . . . . . . . . . . . . . . . . . . . 43
3.3. Environnement de développement . . . . . . . . . . . . . . . . . . . . 44
3.3.1. Atelier de développement Eclipse . . . . . . . . . . . . . . . . . 44
3.3.2. Extensions linguistiques . . . . . . . . . . . . . . . . . . . . . 45
3.3.3. Sélection de l'environnement Java . . . . . . . . . . . . . . . . 47
3.4. Composants Spring . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
3.4.1. Librairies . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
3.4.2. Extensions Spring pour l'atelier de développement . . . . . . . . . 52
3.5. Librairies complémentaires . . . . . . . . . . . . . . . . . . . . . . . 58
4. Mise en œuvre du conteneur léger Spring . . . . . . . . . . . . . . . . . . . 59
4.1. Description du cas d'illustration . . . . . . . . . . . . . . . . . . . . . 59
4.2. Scénario classique : pas de conteneur . . . . . . . . . . . . . . . . . . 60
4.2.1. Mise en place de l'infrastructure de développement . . . . . . . . 61
4.2.2. Développement de cette application . . . . . . . . . . . . . . . . 65
4.3. Scénario alternatif : avec le conteneur léger Spring . . . . . . . . . . . . 67
4.3.1. Compléments sur l'espace de travail . . . . . . . . . . . . . . . 68
4.3.2. Mise en place du projet de développement . . . . . . . . . . . . 69
4.3.3. Définition du fichier de configuration du conteneur . . . . . . . . . 70
4.3.4. Accès au conteneur léger dans le code applicatif. . . . . . . . . . 74
4.4. Structure d'un composant géré par le container . . . . . . . . . . . . . . 76
5. Instanciation des composants par le conteneur . . . . . . . . . . . . . . . . . 77
5.1. Principes d'instanciation des composants. . . . . . . . . . . . . . . . . 77
5.1.1. Instanciation des composants dans une application Java/J2EE . . . 77
5.1.2. Instanciation des composants par le conteneur Spring . . . . . . . 77
5.2. Méthodes d'instanciation des composants . . . . . . . . . . . . . . . . 78
5.2.1. Instanciation par constructeur . . . . . . . . . . . . . . . . . . 80
5.2.2. Instanciation par une méthode statique . . . . . . . . . . . . . . 81
5.2.3. Instanciation par une classe de fabrique . . . . . . . . . . . . . . 83
5.2.4. Choix de la méthode d'instanciation des composants . . . . . . . . 85
5.3. Cycle de vie des composants . . . . . . . . . . . . . . . . . . . . . . 85
5.3.1. Singleton ou prototype . . . . . . . . . . . . . . . . . . . . . . 85
5.3.2. Initialisation précoce ou tardive . . . . . . . . . . . . . . . . . . 87
5.4. Interception d'événements dans la vie du composant . . . . . . . . . . . 90
5.4.1. Interception post-création . . . . . . . . . . . . . . . . . . . . 90
5.4.2. Interception pré-destruction. . . . . . . . . . . . . . . . . . . . 90
5.4.3. Interception par configuration ou par implémentation ? . . . . . . . 90
5.4.4. Illustration. . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
6. Injection des dépendances . . . . . . . . . . . . . . . . . . . . . . . . . . 94
6.1. Principe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
6.2. Les modes d'injection des dépendances . . . . . . . . . . . . . . . . . 95
6.2.1. Injection par les constructeurs . . . . . . . . . . . . . . . . . . 95
6.2.2. Injection par les accesseurs . . . . . . . . . . . . . . . . . . . 96
6.2.3. Règles de choix entre les modes d'injection . . . . . . . . . . . . 97
6.3. Gestion des collections . . . . . . . . . . . . . . . . . . . . . . . . . 98
6.4. Gestion des propriétés complexes . . . . . . . . . . . . . . . . . . . . 99
6.4.1. Principe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
6.4.2. Alternatives aux éditeurs de propriétés . . . . . . . . . . . . . . 99
7. Configuration du conteneur Spring . . . . . . . . . . . . . . . . . . . . . . 100
7.1. Modes de configuration du conteneur . . . . . . . . . . . . . . . . . . 100
7.1.1. Fichier XML . . . . . . . . . . . . . . . . . . . . . . . . . . 100
7.1.2. Annotations Java . . . . . . . . . . . . . . . . . . . . . . . . 101
7.1.3. Règles de choix entre les deux modes . . . . . . . . . . . . . . 101
7.1.4. Utilisation conjointe des deux modes. . . . . . . . . . . . . . . 101
7.2. Modularisation de la configuration . . . . . . . . . . . . . . . . . . . 104
7.2.1. Consolidation verticale des configurations . . . . . . . . . . . . 104
7.2.2. Consolidation horizontale des configurations . . . . . . . . . . . 104

Chapitre 5
Le tiers d'accès et persistance : Hibernate
1. Le tiers d'accès aux informations . . . . . . . . . . . . . . . . . . . . . . . 109
1.1. Définition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
1.2. Rôles et responsabilités . . . . . . . . . . . . . . . . . . . . . . . . 109
1.2.1. Abstraction des accès aux informations . . . . . . . . . . . . . 109
1.2.2. Support d'une logique de transformation . . . . . . . . . . . . . 110
1.2.3. Gestion des transactions . . . . . . . . . . . . . . . . . . . . 110
1.3. Architecture. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110
1.3.1. Les composants DTO . . . . . . . . . . . . . . . . . . . . . . 110
1.3.2. Les composants DAO . . . . . . . . . . . . . . . . . . . . . . 111
2. Stratégie d'accès aux données . . . . . . . . . . . . . . . . . . . . . . . . 112
2.1. Accès direct ou ORM ? . . . . . . . . . . . . . . . . . . . . . . . . 112
2.2. Quelle solution ORM ? . . . . . . . . . . . . . . . . . . . . . . . . . 113
3. Mise en place de l'environnement . . . . . . . . . . . . . . . . . . . . . . 114
3.1. Installation de la base de données MySQL. . . . . . . . . . . . . . . . 114
3.2. Installation des composants Hibernate . . . . . . . . . . . . . . . . . 114
3.2.1. Composants d'exécution Hibernate. . . . . . . . . . . . . . . . 114
3.2.2. Composants Hibernate pour le développement . . . . . . . . . . 115
4. Mise en place de l'accès aux données . . . . . . . . . . . . . . . . . . . . 117
4.1. Présentation de l'exemple . . . . . . . . . . . . . . . . . . . . . . . 117
4.2. Mise en place de l'environnement. . . . . . . . . . . . . . . . . . . . 118
4.2.1. Espace de travail Eclipse . . . . . . . . . . . . . . . . . . . . 118
4.2.2. Création de la base de données . . . . . . . . . . . . . . . . . 120
4.3. Accès aux données via Hibernate. . . . . . . . . . . . . . . . . . . . 122
4.3.1. Principe . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122
4.3.2. Initialisation du projet de développement . . . . . . . . . . . . . 123
4.3.3. Développement des composants métier . . . . . . . . . . . . . 123
4.3.4. Définition des mappages de données. . . . . . . . . . . . . . . 126
4.3.5. Configuration de l'accès aux données . . . . . . . . . . . . . . 128
4.3.6. Développements complémentaires . . . . . . . . . . . . . . . . 133
4.4. Intégration des accès avec Spring . . . . . . . . . . . . . . . . . . . 136
4.4.1. Principe de l'intégration Spring. . . . . . . . . . . . . . . . . . 136
4.4.2. Mise à jour de l'environnement . . . . . . . . . . . . . . . . . 137
4.4.3. Adaptation des composants . . . . . . . . . . . . . . . . . . . 137
4.4.4. Configuration de l'application . . . . . . . . . . . . . . . . . . 139
4.4.5. Test de l'application. . . . . . . . . . . . . . . . . . . . . . . 141
5. Gestion des transactions. . . . . . . . . . . . . . . . . . . . . . . . . . . 143
5.1. Quelques rappels à propos des transactions . . . . . . . . . . . . . . . 143
5.1.1. Pourquoi des transactions . . . . . . . . . . . . . . . . . . . . 143
5.1.2. Propriétés des transactions . . . . . . . . . . . . . . . . . . . 144
5.1.3. Typologies de transactions . . . . . . . . . . . . . . . . . . . 144
5.2. Principe des transactions avec Spring . . . . . . . . . . . . . . . . . . 145
5.2.1. Gestion par programmation . . . . . . . . . . . . . . . . . . . 145
5.2.2. Gestion par déclaration . . . . . . . . . . . . . . . . . . . . . 145
5.3. Illustration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147
5.3.1. Description de l'exemple . . . . . . . . . . . . . . . . . . . . 147
5.3.2. Environnement . . . . . . . . . . . . . . . . . . . . . . . . . 147
5.3.3. Développement des composants. . . . . . . . . . . . . . . . . 147
5.3.4. Configuration . . . . . . . . . . . . . . . . . . . . . . . . . . 149
5.3.5. Tests et constats . . . . . . . . . . . . . . . . . . . . . . . . 152
5.4. Au-delà . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153

Chapitre 6
Le tiers de présentation : Spring MVC
1. Le tiers de présentation des informations . . . . . . . . . . . . . . . . . . . 157
1.1. Définition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157
1.2. Rôles et responsabilités . . . . . . . . . . . . . . . . . . . . . . . . 157
1.2.1. Les rôles du tiers de présentation . . . . . . . . . . . . . . . . 157
1.2.2. Architecture technique du tiers de présentation . . . . . . . . . . 158
1.2.3. Spring MVC et Spring Web Flow . . . . . . . . . . . . . . . . 158
2. Le modèle MVC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158
2.1. Le contrôleur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159
2.2. La vue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160
2.3. Le modèle. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160
2.4. MVC de type 1 et MVC de type 2. . . . . . . . . . . . . . . . . . . . 160
3. Spring MVC : présentation . . . . . . . . . . . . . . . . . . . . . . . . . . 161
3.1. Description et organisation . . . . . . . . . . . . . . . . . . . . . . . 161
3.1.1. Le contrôleur façade . . . . . . . . . . . . . . . . . . . . . . 161
3.1.2. L'aiguilleur de requêtes . . . . . . . . . . . . . . . . . . . . . 162
3.1.3. Le contrôleur de traitement . . . . . . . . . . . . . . . . . . . 162
3.1.4. Le sélecteur de vue . . . . . . . . . . . . . . . . . . . . . . . 163
3.1.5. Les vues . . . . . . . . . . . . . . . . . . . . . . . . . . . . 164
3.1.6. Les intercepteurs de traitement . . . . . . . . . . . . . . . . . 164
3.1.7. Les intercepteurs d'exceptions. . . . . . . . . . . . . . . . . . 164
3.2. Principe de traitement . . . . . . . . . . . . . . . . . . . . . . . . . 165
3.3. Configuration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 166
4. Spring MVC : mise en pratique . . . . . . . . . . . . . . . . . . . . . . . . 167
4.1. Description du cas exemple . . . . . . . . . . . . . . . . . . . . . . 167
4.1.1. Objectif . . . . . . . . . . . . . . . . . . . . . . . . . . . . 167
4.1.2. Cahier des charges . . . . . . . . . . . . . . . . . . . . . . . 167
4.2. Installation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 168
4.2.1. Installation du conteneur de servlets . . . . . . . . . . . . . . . 168
4.2.2. Initialisation de l'espace de travail Eclipse . . . . . . . . . . . . 173
4.2.3. Complément de l'atelier de développement . . . . . . . . . . . . 173
4.2.4. Ajout des librairies Spring MVC . . . . . . . . . . . . . . . . . 180
4.3. Réalisation : mise en place de la première transaction . . . . . . . . . . 181
4.3.1. Initialisation de l'application support . . . . . . . . . . . . . . . 181
4.3.2. Ajout des librairies applicatives nécessaires au projet . . . . . . . 182
4.3.3. Mise en place du contrôleur façade . . . . . . . . . . . . . . . 185
4.3.4. Développement de la page du menu principal . . . . . . . . . . . 192
4.3.5. Développement du contrôleur de traitement. . . . . . . . . . . . 193
4.3.6. Configuration de l'aiguillage des requêtes . . . . . . . . . . . . . 195
4.3.7. Configuration du sélecteur de vue . . . . . . . . . . . . . . . . 196
4.3.8. Développement des autres pages de l'application . . . . . . . . . 198
4.3.9. Test de l'application. . . . . . . . . . . . . . . . . . . . . . . 198
5. Traitement des formulaires avec Spring MVC . . . . . . . . . . . . . . . . . 200
5.1. Illustration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 201
5.2. Réalisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 201
5.2.1. Environnement . . . . . . . . . . . . . . . . . . . . . . . . . 201
5.2.2. Développement du contrôleur . . . . . . . . . . . . . . . . . . 204
5.2.3. Autres développements dans le projet . . . . . . . . . . . . . . 206
5.2.4. Tests . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 206
6. Utilisations avancées de Spring MVC . . . . . . . . . . . . . . . . . . . . . 207
6.1. Illustration et environnement . . . . . . . . . . . . . . . . . . . . . . 208
6.2. Intercepteurs sur le cycle de vie des requêtes . . . . . . . . . . . . . . 208
6.2.1. Principe des intercepteurs sur le cycle de traitement . . . . . . . 208
6.2.2. Description technique des intercepteurs . . . . . . . . . . . . . 209
6.2.3. Exemples d'utilisation des intercepteurs . . . . . . . . . . . . . 209
6.2.4. Illustration . . . . . . . . . . . . . . . . . . . . . . . . . . . 210
6.2.5. Points d'attention . . . . . . . . . . . . . . . . . . . . . . . . 214
6.3. La gestion des exceptions . . . . . . . . . . . . . . . . . . . . . . . 215
6.3.1. Traitement standard des exceptions Spring MVC . . . . . . . . . 215
6.3.2. Principe d'interception des exceptions Spring MVC . . . . . . . . 215
6.3.3. Limites à l'interception des exceptions Spring MVC . . . . . . . . 216
6.3.4. Mise en place d'une interception des exceptions . . . . . . . . . 216
6.3.5. Recommandations pour l'interception des exceptions . . . . . . . 217
6.3.6. Illustration du mécanisme d'interception des exceptions . . . . . . 217
6.3.7. Cohabitation des intercepteurs de traitement et d'exceptions. . . . 218

Chapitre 7
La navigation dans l'application : Spring Web Flow
1. Les flux de navigation . . . . . . . . . . . . . . . . . . . . . . . . . . . . 221
1.1. La navigation dans l'application . . . . . . . . . . . . . . . . . . . . . 221
1.2. Introduction aux flux de navigation . . . . . . . . . . . . . . . . . . . 221
1.2.1. Des automates à états finis . . . . . . . . . . . . . . . . . . . 221
1.2.2. Les challenges pour les flux de navigation . . . . . . . . . . . . 222
1.2.3. Panorama des solutions . . . . . . . . . . . . . . . . . . . . . 222
2. Spring Web Flow : présentation . . . . . . . . . . . . . . . . . . . . . . . 223
2.1. Positionnement dans la galaxie Spring . . . . . . . . . . . . . . . . . 223
2.2. Les composants . . . . . . . . . . . . . . . . . . . . . . . . . . . . 223
2.2.1. Le moteur d'enchaînement . . . . . . . . . . . . . . . . . . . 223
2.2.2. La description des flux de navigation . . . . . . . . . . . . . . . 224
3. Spring Web Flow : mise à jour de l'environnement. . . . . . . . . . . . . . . 224
3.1. Ajout de la distribution Spring Web Flow . . . . . . . . . . . . . . . . 224
3.2. Nouvel espace de travail Eclipse . . . . . . . . . . . . . . . . . . . . 224
3.2.1. Création du nouvel espace de travail . . . . . . . . . . . . . . . 224
3.2.2. Import des librairies nécessaires . . . . . . . . . . . . . . . . . 225
4. Exemple 1 : flux de navigation simple. . . . . . . . . . . . . . . . . . . . . 226
4.1. Description du cas exemple . . . . . . . . . . . . . . . . . . . . . . 226
4.2. Environnement . . . . . . . . . . . . . . . . . . . . . . . . . . . . 226
4.3. Réalisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 226
4.3.1. Mise en place du moteur d'enchaînement . . . . . . . . . . . . 226
4.3.2. Connexion entre Spring MVC et Spring Web Flow. . . . . . . . . 228
4.3.3. Définition du flux de navigation . . . . . . . . . . . . . . . . . 231
4.3.4. Adaptation des pages JSP de l'application . . . . . . . . . . . . 234
5. Exemple 2 : actions et décisions dans le flux . . . . . . . . . . . . . . . . . 235
5.1. Description de l'exemple . . . . . . . . . . . . . . . . . . . . . . . . 235
5.2. Environnement . . . . . . . . . . . . . . . . . . . . . . . . . . . . 235
5.3. Réalisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 236
5.3.1. Développement des actions de traitement . . . . . . . . . . . . 236
5.3.2. Déclaration des classes d'action dans le conteneur léger . . . . . 239
5.3.3. Définition du flux de navigation . . . . . . . . . . . . . . . . . 240
5.3.4. Adaptation des pages JSP de l'application . . . . . . . . . . . . 243
6. Exemple 3 : flux de navigation imbriqués . . . . . . . . . . . . . . . . . . . 243
6.1. Description de l'exemple . . . . . . . . . . . . . . . . . . . . . . . . 243
6.2. Environnement . . . . . . . . . . . . . . . . . . . . . . . . . . . . 244
6.3. Réalisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 245
6.3.1. Construction des flux de navigation sur les modules. . . . . . . . 245
6.3.2. Gestion des formulaires dans le flux de navigation . . . . . . . . 247
6.3.3. Quelques points d'attention . . . . . . . . . . . . . . . . . . . 249
6.3.4. Assemblage des flux de navigation . . . . . . . . . . . . . . . 249
7. Au-delà : utilisations avancées . . . . . . . . . . . . . . . . . . . . . . . . 251

Chapitre 8
Le tiers sécurité : Spring Security
1. La sécurité dans une application informatique . . . . . . . . . . . . . . . . . 255
1.1. Les fonctions clés de la sécurité . . . . . . . . . . . . . . . . . . . . 255
1.2. Le tiers sécurité . . . . . . . . . . . . . . . . . . . . . . . . . . . . 255
1.3. La sécurité : conteneur ou application ? . . . . . . . . . . . . . . . . . 256
1.3.1. Sécurité prise en charge par le conteneur applicatif . . . . . . . . 256
1.3.2. Sécurité embarquée dans l'application . . . . . . . . . . . . . . 257
1.3.3. Solution hybride . . . . . . . . . . . . . . . . . . . . . . . . 257
2. Spring Security : présentation . . . . . . . . . . . . . . . . . . . . . . . . 258
2.1. Historique du module . . . . . . . . . . . . . . . . . . . . . . . . . 258
2.2. Fonctionnalités . . . . . . . . . . . . . . . . . . . . . . . . . . . . 258
2.2.1. Identification et authentification . . . . . . . . . . . . . . . . . 258
2.2.2. Habilitations . . . . . . . . . . . . . . . . . . . . . . . . . . 259
2.2.3. Définition des règles dans la sécurité. . . . . . . . . . . . . . . 259
2.3. Principes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 259
3. Spring Security : mise en œuvre . . . . . . . . . . . . . . . . . . . . . . . 260
3.1. Installation de la distribution . . . . . . . . . . . . . . . . . . . . . . 260
3.2. Initialisation de l'espace de travail . . . . . . . . . . . . . . . . . . . 260
4. Exemple 1 : authentification simple des utilisateurs . . . . . . . . . . . . . . 261
4.1. Présentation de l'exemple . . . . . . . . . . . . . . . . . . . . . . . 261
4.2. Environnement . . . . . . . . . . . . . . . . . . . . . . . . . . . . 262
4.3. Réalisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 262
4.3.1. Configuration de l'interception des requêtes. . . . . . . . . . . . 262
4.3.2. Configuration des composants de sécurité . . . . . . . . . . . . 264
4.3.3. Premiers tests . . . . . . . . . . . . . . . . . . . . . . . . . 266
4.3.4. Activation de l'authentification en mode basic . . . . . . . . . . 267
5. Exemple 2 : formulaire et base de données . . . . . . . . . . . . . . . . . . 271
5.1. Description du cas exemple . . . . . . . . . . . . . . . . . . . . . . 271
5.2. Environnement . . . . . . . . . . . . . . . . . . . . . . . . . . . . 272
5.3. Réalisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 272
5.3.1. Configuration de l'authentification par formulaire . . . . . . . . . 272
5.3.2. Utilisation d'une base de données pour authentification . . . . . . 274
6. Exemple 3 : habilitations des utilisateurs . . . . . . . . . . . . . . . . . . . 278
6.1. Description du cas exemple . . . . . . . . . . . . . . . . . . . . . . 278
6.2. Environnement . . . . . . . . . . . . . . . . . . . . . . . . . . . . 278
6.3. Réalisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 278
6.3.1. Mise en œuvre des habilitations . . . . . . . . . . . . . . . . . 278
6.3.2. Gestion de la session utilisateur . . . . . . . . . . . . . . . . . 279

Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 281