Programmation

Java
Programmation Java Back End
Copyright 2021 - Tous droits réservés.
Le contenu de ce livre ne peut être reproduit, dupliqué ou transmis sans l'autorisation écrite de
l'auteur.
En aucun cas, l'éditeur ne pourra être tenu pour responsable de toute réparation, dommage ou perte
monétaire résultant directement ou indirectement des informations contenues dans le présent
document.
Avis juridique :
Vous ne pouvez pas modifier, distribuer, vendre, utiliser, citer ou paraphraser une partie du contenu
de ce livre sans l'accord de l'auteur.
Avis de non-responsabilité :
Veuillez noter que les informations contenues dans ce document sont uniquement destinées à des fins
éducatives et de divertissement. Aucune garantie de quelque nature que ce soit n'est exprimée ou
sous-entendue. Les lecteurs reconnaissent que l'auteur ne donne pas de conseils juridiques, financiers,
médicaux ou professionnels. Veuillez consulter un professionnel agréé avant d'essayer les techniques
décrites dans ce livre.
En lisant ce document, le lecteur accepte qu'en aucun cas l'auteur ne soit responsable des pertes,
directes ou indirectes, résultant de l'utilisation des informations contenues dans ce document, y
compris, mais sans s'y limiter, les erreurs, les omissions ou les inexactitudes.
Table des matières
Introduction

Chapitre 1 : Développeurs Frontend, Backend et Full-Stack

Développement frontal
Développement backend
Développement complet

Chapitre 2 : Configuration de votre environnement Java

Installation du JDK sous Windows
Premiers pas avec Java sous Windows
Installation du JDK sur macOS
Débuter avec Java sur macOS
Installation du JDK sur Ubuntu
Démarrer avec Java sur Ubuntu
Nouvelle fonctionnalité
Erreurs courantes d'installation du JDK

Chapitre 3 : Java avec Spring

Programmer le backend
Travailler avec des données
Structurer l'application
Construire l'application

Chapitre 4 : Java avec Maven

Chapitre 5 : Java avec Gradle

Chapitre 6 : Java avec Hibernate

Chapitre 7 : Java avec Apache Struts

Hello World avec Struts 2
Utilisation des étiquettes
Actions de codage
Traitement des formulaires
Validation du formulaire
Fichiers de ressources de messages
Propriétés au niveau du paquet
 Traitement des exceptions
Débogage de Struts
Étiquettes du formulaire
Validation des formulaires à l'aide de XML
Tags de contrôle
Sélection de la méthode Wildcard
Spring et Struts 2
Annotations
Présentation des intercepteurs

Chapitre 8 : Comment apprendre le développement web backend

Principes de programmation

Conclusion

Références
Introduction
Lorsque vous commencez à développer un nouveau projet logiciel, vous
vous posez toujours une question : quel langage de programmation dois-je
utiliser ? Avec le grand nombre de cadres et de langages disponibles sur le
marché, le choix est difficile : dois-je utiliser .Net ou Java ? Python ? PHP ?
Ruby on Rails ? Ce que nous n'allons pas faire dans ce livre, c'est comparer
ces langages, car ce n'est pas de cela qu'il s'agit. Nous allons plutôt parler de
l'utilisation de Java pour le développement d'applications dorsales.
Lorsque vous choisissez votre langage de programmation, vous devez tenir
compte de nombreux paramètres : les capacités du langage, la facilité de
codage dans ce langage, les plateformes prises en charge par le langage,
qu'il s'agisse d'ordinateurs de bureau ou de téléphones portables, la taille de
votre projet, les spécificités du domaine, etc.
Java est l'un des langages de programmation les plus utilisés dans le monde,
par certaines des plus grandes entreprises mondiales - Amazon, Airbnb,
Netflix, Facebook, Spotify, Google, et bien d'autres encore - pour le
développement des applications dorsales.
Avantages
Java offre plusieurs avantages par rapport à d'autres langages de
programmation pour le développement d'applications dorsales, dont les
principaux sont les suivants :

Simplicité
Les développeurs utilisent Java depuis plus de 20 ans, principalement parce
que c'est l'un des langages de programmation les plus simples à apprendre.
Sa syntaxe est dérivée du C++, ce qui nous permet de disposer d'une
terminologie sans ambiguïté, facilement compréhensible par tous. Si vous
comprenez les principes de la programmation, Java est l'un des langages les
plus rapides et les plus faciles à apprendre.

Soutien à la plate-forme
Java étant un langage compilé et orienté objet, vous pouvez écrire votre
code une seule fois et l'exécuter sur toutes les plateformes, y compris
Windows, Linus et macOS, sans oublier les plateformes mobiles. Cela en
fait l'un des meilleurs choix pour le développement web, le développement
d'applications mobiles, la mise en réseau, la connectivité des bases de
données et bien d'autres choses encore.

Le multithreading
Java fonctionne sur un serveur multithread, chaque demande étant traitée
dans son propre thread. Ainsi, plusieurs tâches peuvent être effectuées
simultanément, sans qu'il soit nécessaire d'interroger chaque événement. Le
multithreading fait de Java l'un des meilleurs outils pour l'édition d'images,
la diffusion de vidéos en continu et d'autres applications gourmandes en
ressources processeur.

Sécurité
Java est l'un des langages de programmation les plus sûrs. La sécurité
découle de nombreux outils et API, sans parler des implémentations de
protocoles, de mécanismes et d'algorithmes de sécurité couramment
utilisés. Les API comprennent la communication sécurisée, l'infrastructure
à clé publique, la cryptographie, le contrôle d'accès et l'authentification.
Lorsque le kit de développement Java (JDK) a été initialement développé, il
mettait l'accent sur une sécurité forte, permettant aux développeurs de créer
des applications sécurisées dès le départ.

Bibliothèques libres
Java contient un nombre important de bibliothèques, couvrant toutes sortes
d'objectifs. Il s'agit notamment de la parson JSON, de la journalisation, des
tests unitaires, de l'analyse HTML et XML, de la messagerie, des
bibliothèques, de la cryptographie, de la lecture d'Excel et des bibliothèques
PDF, et bien d'autres choses encore. La plupart de ces bibliothèques sont
libres, avec le soutien de développeurs expérimentés, et leur utilisation peut
accélérer de manière significative le développement d'applications web.

Un écosystème riche
Java comprend également un grand nombre d'outils et de cadres qui
facilitent le développement des applications dorsales. Les plus utilisés sont
Apache Struts, Spring, Hibernate, Maven, Gradle, et bien d'autres encore,
dont certains seront abordés en profondeur dans ce guide.

Évolutif et robuste
Java possède deux caractéristiques qui le rendent incroyablement évolutif et
contribuent à accélérer le développement d'applications web : le ramassage
des ordures et la gestion automatique de la mémoire. Ces deux fonctions
permettent également aux développeurs d'écrire un code propre et optimisé.
Une autre caractéristique, un solide mécanisme de vérification des types,
rend Java incroyablement robuste. La machine virtuelle Java (JVM) fournit
un environnement sûr et une liaison dynamique, ce qui permet à Java de
fonctionner n'importe où sur n'importe quelle plateforme.
Cas d'utilisation de Java
Java est un langage universel, idéal pour les applications mobiles et web
côté serveur et côté client. Il est principalement utilisé pour développer des
crypto-monnaies et des applications d'entreprise, car il est très évolutif et
sécurisé. Il fonctionne également très bien pour le développement du
commerce électronique, les solutions IoT et les applications Big Data. C'est
également le principal langage utilisé pour développer des applications
Android.
Java est le meilleur parce qu'il fonctionne, et tout au long de ce livre, vous
apprendrez à l'utiliser avec plusieurs frameworks différents. Sans perdre
plus de temps, plongeons dans le développement de backend avec Java.
Chapitre 1 : Développeurs Frontend, Backend et
Full-Stack
Avant de nous plonger dans le développement backend, il convient de
comprendre la différence entre les trois types de développeurs impliqués
dans le développement web - backend, frontend et full-stack.
À l'heure actuelle, il existe plus de 1,5 milliard de sites web sur l'internet,
et ce chiffre ne cesse d'augmenter. Les personnes chargées de coder et de
construire ces sites web, sans oublier de les analyser et de les maintenir,
sont les développeurs web.
Les sites web sont essentiels à la compétitivité de toute entreprise sur un
marché difficile. Cela signifie que le nombre d'emplois pour les
développeurs web est également en augmentation. Mais comment
déterminer le type de travail de développement web que vous souhaitez
effectuer ? Nous présentons ici les trois principaux types de développeurs
d'applications web.
Développement frontal
La partie frontale d'un site web est celle que les utilisateurs voient et avec
laquelle ils interagissent. Tout ce que vous voyez lorsque vous naviguez
sur l'internet, y compris les couleurs, les polices, les curseurs, les menus
déroulants et autres, est contrôlé par votre navigateur.
Outils et compétences
Un développeur frontal est responsable du code orienté vers l'utilisateur et
de l'infrastructure immersive d'un site web. Pour atteindre ses objectifs, il
doit maîtriser le CSS, le HTML et le JavaScript. Il doit également être
familiarisé avec certains frameworks, tels que Backbone, Foundation,
Bootstrap, EmberJS et AngularJS. Tous ces outils sont utilisés pour
garantir la qualité du contenu, quelle que soit la plateforme ou l'appareil.
Les développeurs frontaux doivent également connaître les bibliothèques
qui regroupent le code sous une forme utile pour gagner du temps, comme
LESS et jquery.
De nombreuses descriptions d'emploi pour les développeurs frontaux
demandent également une certaine expérience de l'Ajax, une technique qui
télécharge les données du serveur en arrière-plan afin que les pages
puissent se charger de manière dynamique.
Ces outils permettent aux développeurs frontaux de travailler avec des
analystes de l'expérience utilisateur ou des concepteurs pour faire passer
un wireframe ou une maquette du stade du développement à celui de la
livraison. Un bon développeur frontal est capable d'identifier avec
précision les problèmes liés à l'expérience utilisateur, de fournir des
solutions de code et des recommandations le cas échéant. Il doit
également être capable de travailler de manière fluide avec d'autres
équipes commerciales afin de comprendre les opportunités, les objectifs et
les besoins, et d'exécuter les bonnes solutions au bon moment.
Bien que le développeur frontal ait des responsabilités importantes, son
travail est gratifiant. Une façon de décrire l'implication d'un développeur
frontend est de dire que son travail consiste à concevoir l'intérieur d'une
maison construite par un développeur backend, et que c'est le propriétaire
qui dicte le décor. En réalité, les développeurs frontaux sont souvent plus
enthousiastes dans leur travail parce qu'ils peuvent laisser libre cours à
leur créativité.
Ouvrez n'importe quel site web sur votre ordinateur. Tout ce que vous
voyez est le résultat du travail acharné d'un développeur frontal. Un
concepteur a peut-être réalisé les graphiques et le logo. Un photographe
ou un site web de photos d'archives a fourni les images, et un rédacteur a
écrit le texte. Mais tout cela a été rassemblé par un développeur frontal,
traduit en quelque chose de compatible avec le web et présenté dans un
format interactif que vous pouvez comprendre.
Développement backend
Tout ce qui concerne le front-end est bien beau, mais qu'est-ce qui fait que
tout cela se produit ? Où toutes les données sont-elles stockées ? C'est là
qu'intervient le backend. Le backend d'un site web comprend trois éléments
: le serveur, l'application et la base de données. Le développeur est chargé
de mettre au point la technologie qui alimente ces trois composants et de la
maintenir pour que le frontend du site puisse exister, c'est-à-dire la partie
que l'utilisateur voit.
Outils et compétences
Pour que ces trois composants communiquent entre eux, un développeur
backend utilise un langage côté serveur pour construire l'application. Il
utilise ensuite des outils pour trouver les données, les sauvegarder, les
modifier, les coder et les restituer à l'utilisateur. Les langages côté serveur
comprennent Java, PHP, .Net, Python et Ruby, tandis que les outils de
données comprennent Oracle, MySQL et SQL Server.
Les descriptions d'emploi pour les développeurs backend demandent
souvent une expérience préalable dans l'utilisation des éléments suivants :

Cadres PHP, tels que CakePHP, Symfony et Zend

VCS (logiciel de contrôle de version) tel que CVS, SVN et Git
Linux pour développer et déployer des applications.
Les développeurs backend utilisent des outils de ce type pour créer des
applications web ou contribuer à des applications existantes, en écrivant un
code portable, propre et documenté. Avant de pouvoir écrire ce code, ils
doivent se réunir avec les parties prenantes de l'entreprise pour s'assurer
qu'ils connaissent leurs besoins. Ces besoins doivent ensuite être traduits en
exigences techniques et la solution la plus efficace doit être élaborée pour
mettre en place la technologie requise.
Le développement du backend consiste à manipuler des données, à
échanger des données entre des systèmes, des sites web et des appareils
connectés, et à créer des API utiles que le public peut utiliser.
Retournez sur le site web que vous avez ouvert dans la section sur le
développement frontal. Lorsque vous l'ouvrez, un serveur envoie des
informations à votre appareil mobile ou de bureau. Ces informations
deviennent la page que vous consultez. Si vous fournissez à un site web
des informations personnelles, telles que des données de connexion, elles
sont stockées et automatiquement appelées lorsque vous revenez sur le
site - c'est également le fait d'un développeur de backend.
Développement complet
Souvent, la distinction entre le développement frontal et le développement
dorsal n'est pas tout à fait claire. Les développeurs frontaux doivent parfois
acquérir des compétences dans le domaine des applications dorsales, tandis
que les développeurs dorsaux doivent souvent savoir comment effectuer
certains travaux frontaux. Tous les développeurs ont besoin d'une certaine
dose de transversalité et doivent, dans de nombreux cas, être des
généralistes.
C'est là qu'intervient le développeur full0stack. Véritable touche-à-tout, le
rôle de développeur full-stack est devenu populaire il y a plusieurs années,
grâce au département d'ingénierie de Facebook. L'idée derrière ce rôle est
de travailler sur l'ensemble de la pile technologique - le front et le backend.
Lorsque vous pouvez travailler professionnellement du côté client et du
côté serveur, davantage de portes s'ouvrent à vous, mais ce n'est en aucun
cas un travail facile. Pour utiliser l'analogie de la cuisine, on peut être un
bon boulanger ou un bon cuisinier, mais faire les deux aussi bien demande
de l'expérience et du temps. Il ne s'agit pas de suivre une recette qui vous
est présentée, mais d'avoir les bons ingrédients pour créer quelque chose de
vraiment merveilleux.
Outils et compétences
Comme un développeur backend, un développeur full-stack travaille
principalement sur le côté serveur mais maîtrise également le langage
frontend. Cela signifie qu'il peut contrôler l'aspect du contenu d'un site web
pour l'utilisateur.
Un développeur full-stack doit connaître les outils qu'il peut utiliser, en
fonction de son client ou de son projet. Il doit également savoir comment
fonctionne le web à tous les niveaux. Cela inclut la mise en place des
serveurs Linux et leur configuration, l'écriture des API côté serveur, la
compréhension et l'écriture de JavaScript côté client pour faire fonctionner
les applications, et l'utilisation de CSS pour faire le travail de conception.
Ces outils permettent à un développeur complet d'identifier les
responsabilités de la solution côté serveur et côté client et d'exposer les
avantages et les inconvénients des différentes solutions disponibles.
Pour en revenir au site web que vous avez ouvert, un développeur full-stack
est responsable de l'expérience utilisateur et de la fluidité du site web, y
compris du temps de chargement, de la mise en page, des fondements
structurels et de l'interactivité du site.
Le développement web est un métier aux multiples facettes mais, quel que
soit le domaine dans lequel vous souhaitez vous engager, vous devez
posséder certaines compétences générales :

Bonne attention aux détails

Être capable d'apprendre rapidement
Résolution efficace et efficiente des problèmes
Forte communication
Tous ces éléments vous seront d'une aide précieuse, au même titre que les
compétences requises pour chaque emploi.
Maintenant que vous comprenez la différence entre ces trois éléments, nous
pouvons nous plonger dans le développement de backend à l'aide de Java.
Dans le prochain chapitre, nous verrons comment configurer votre
environnement.
Chapitre 2 : Configuration de votre
environnement Java
Selon le type d'application Java que vous souhaitez développer, vous avez
le choix entre trois SDK - Software Development Kits :

Java SE (Standard Edition) - ce SDK est principalement

utilisé pour développer des applications de bureau et est
également connu sous le nom de JDK (Java Development
Kit).
Java ME (Mobile Edition) - ce SDK est principalement
utilisé pour développer des applications mobiles et des
applications pour les appareils orientés vers la télévision. Vous
devez installer le JDK avant de pouvoir l'utiliser.
Java EE (Enterprise Edition) - ce SDK est principalement
utilisé pour développer des applications d'entreprise basées sur
des composants, par exemple, Java servlet, Enterprise
JavaBean et JSP. Il nécessite également l'installation préalable
du JDK.
Nous allons nous concentrer sur le premier, Java SE ou JDK.
Installation du JDK sous Windows
Première étape
La première étape consiste à désinstaller les anciennes versions du JDK
présentes sur votre machine. Bien que vous puissiez utiliser plus d'une
version, cela devient compliqué.

Ouvrez votre panneau de configuration et cliquez sur

Programmes>Programmes et fonctionnalités
Cliquez sur Ajout/Suppression de programmes
Désinstallez maintenant tout ce qui commence par Java - Java
SE Runtime, Java X Update, etc.
Deuxième étape
Nous pouvons maintenant télécharger une nouvelle installation du JDK
 Ouvrir [Link]
[Link]
Cliquez sur Oracle JDK
Cliquez sur JDK Download
Téléchargez la dernière version du programme d'installation de
Windows x64 - assurez-vous d'accepter l'accord de licence,
sinon vous ne pourrez pas aller plus loin.
Troisième étape
Nous devons maintenant installer le JDK

Trouvez le programme d'installation et double-cliquez dessus

pour le lancer.
Si l'on vous demande d'autoriser le système, cliquez sur Oui.
Cela permettra au programme d'installation de s'exécuter
automatiquement et l'écran de bienvenue du programme
d'installation s'affichera à l'écran.
Cliquez sur Suivant, et le processus d'installation peut
commencer
L'écran suivant vous propose de modifier le chemin
d'installation. Conservez le chemin par défaut ou changez-le si
vous le souhaitez - dans tous les cas, notez l'endroit où le JDK
est installé.
Cliquez sur Suivant, et l'installation commencera - un écran de
progression s'affichera.
Quatrième étape
Vous devez maintenant vérifier que l'installation s'est déroulée correctement
:

Ouvrez l'invite de commande - cliquez avec le bouton droit de

la souris sur le menu Démarrer et cliquez sur Invite de
commande. Vous pouvez également taper Invite de commande
dans la barre de recherche et cliquer sur le résultat.
Lorsque la fenêtre de commande s'ouvre, tapez la commande
suivante à l'invite :
java -version
Vous devriez voir apparaître quelque chose comme l'image ci-dessous sur
votre écran :

Si vous voyez un message disant "- java n'est pas reconnu", ou si une
version plus ancienne est affichée - une version antérieure que vous avez
installée - nous devons prendre une mesure supplémentaire. Pour utiliser la
version du JDK que vous avez installée, vous devrez peut-être définir une
variable d'environnement (voir l'étape suivante).
Cinquième étape
Ces étapes sont nécessaires UNIQUEMENT SI vous voyez à l'écran autre
chose que la version correcte du JDK.
Procédez comme suit pour définir la variable d'environnement :

Cliquez avec le bouton droit de la souris sur la barre de

démarrage
Cliquez sur Mon ordinateur (This PC)
Cliquez sur Propriétés
Cliquez sur Paramètres système avancés
Ces étapes permettent d'ouvrir le panneau des paramètres de Windows,
comme vous le voyez ci-dessous :
Cliquez sur le bouton en bas qui indique Variables
d'environnement
Cliquez sur l'option Variables système, puis sur Chemin
d'accès.
Cliquez sur Modifier
Nous pouvons maintenant entrer le chemin de la version installée du JDK
dans le chemin du système.
Tout d'abord, si le programme d'installation ajoute le chemin d'accès au
chemin d'accès du système, supprimez-le comme vous le voyez dans
l'image ci-dessous :

Supprimer le chemin relatif à la version précédente du JDK

Si JAVA_HOME est défini, mettez-le à jour
Cliquez sur le bouton Nouveau
Ajoutez le chemin d'accès au répertoire bin du JDK - il devrait
ressembler à C:\Java\Oracle\jdk-16\bin.
 Cliquez trois fois sur le bouton OK, et toutes les fenêtres se
fermeront.
Le JDK 16 est maintenant défini dans les variables d'environnement du
système, ce qui vous permet d'y accéder à partir de la console de
commande.
Sixième étape
Ouvrez la console de commande et vérifiez la version de Java comme vous
l'avez fait précédemment :
java -version
Septième étape
Vous devez maintenant télécharger un environnement de développement
intégré (IDE). Nous utiliserons Eclipse :

Ouvrir [Link]
Cliquez sur Get Eclipse IDE et choisissez Download Packages.
Cliquez sur Eclipse IDE pour les développeurs Java et
Windows x86_64
Huitième étape
Installer l'IDE :

Recherchez et décompressez le fichier téléchargé

Enregistrez-le dans un répertoire - n'importe où, notez
simplement l'endroit où il se trouve.
La version zip est la meilleure car vous n'avez pas besoin d'exécuter un
programme d'installation. Et lorsque vous n'en avez plus besoin, vous
pouvez simplement supprimer tout le répertoire. Renommez ou déplacez le
répertoire comme vous le souhaitez, tant que vous savez où il se trouve et
comment il s'appelle.
Premiers pas avec Java sous Windows
Pour vous habituer à travailler avec Java, nous allons commencer par
l'exemple Hello World. Nous allons écrire le code, le compiler et l'exécuter.

Ouvrez l'IDE et tapez le code suivant. Enregistrez-le sous

[Link] et fermez l'éditeur :

class HelloWorld {
public static void main(String[] args ) {
[Link]("Hello World !!\n" ) ;
}
}

Ouvrez votre invite de commande et allez dans le chemin où

votre programme Java est sauvegardé. Les commandes ci-
dessous peuvent être utilisées pour compiler le programme et
l'exécuter :
# Compiler - Spécifier le nom de fichier correctme et l'extension
javac [Link]
# Exécuter - Spécifier le nom de fichier correct
java HelloWorld
 # Sortie
Hello World ! !!
C'est ainsi qu'il est facile d'installer Java sur Windows et de l'utiliser pour
écrire, compiler et exécuter un programme.
Installation du JDK sur macOS
Première étape
Tout d'abord, vous devez vérifier si le JDK est déjà installé sur votre
système - sur certains ordinateurs macOS, il est préinstallé en standard :

Ouvrez un terminal sur votre ordinateur - tapez "terminal" dans

la barre de recherche ou ouvrez Finder>Utilitaires>Terminal.
Une fois que votre terminal est ouvert, tapez la commande
suivante :

javac -version

Si un numéro de version du JDK apparaît à l'écran, c'est que le JDK est déjà
installé. Si le numéro de version du JDK est inférieur à 16, vous devez
passer à la dernière version, ce que vous pouvez faire à l'étape suivante.
Vous devrez également installer la dernière version si vous voyez
"Command not found" sur votre écran.
Si le message suivant s'affiche à l'écran : "Pour ouvrir javac, vous avez
besoin d'un programme d'exécution Java", choisissez Installer et suivez les
instructions pour installer le JDK.
Deuxième étape
Si votre version doit être mise à jour ou si Java n'est pas installé sur votre
machine, vous devez suivre les étapes suivantes :

Ouvrir [Link]
[Link]
Cliquez sur Oracle JDK
Cliquez sur JDK Download
 Cliquez sur le fichier d'installation DMG de macOS - il
ressemblera à ceci - jdk-16.0.{x}_osx-x64_bin.dmg
Troisième étape
Vous pouvez maintenant installer le fichier :

Recherchez et double-cliquez sur le fichier DMG que vous

avez téléchargé.
Suivez les instructions qui s'affichent à l'écran pour l'installer
Ejecter le fichier DMG
Quatrième étape
Pour vérifier l'installation, ouvrez un terminal et tapez les commandes
suivantes :

// Afficher la version du JDK

javac -version
javac 16.0.{x}

// Afficher la version du JRE

java -version
version java "16.0.{x}"
......

// Afficher l'emplacement du compilateur Java

quel javac
/usr/bin/javac

// Afficher l'emplacement du moteur d'exécution Java

quel java
/usr/bin/java
Débuter avec Java sur macOS
Comme expliqué dans le tutoriel Windows, nous pouvons nous habituer à
travailler avec Java en écrivant le programme HelloWorld. Vous devrez
installer un éditeur de texte, tel qu'Atom ou Sublime Text, alors allez-y et
faites-le maintenant - toutes les instructions d'installation se trouvent sur le
site web correspondant.
Ensuite, vous devez créer un nouveau répertoire :

Ouvrez le Finder>Aller et cliquez sur Accueil

Cliquez sur Fichier>Nouveau dossier et nommez-le monProjet
Dans macOS, le répertoire personnel de l'utilisateur peut être référencé
comme ~, vous pouvez donc référencer le nouveau projet comme
~/monProjet.
Ouvrez votre éditeur de texte et saisissez le code ci-dessous. Nommez-le
[Link] et enregistrez-le sous ~/monProjet.
Note
Si vous choisissez d'utiliser l'éditeur de texte par défaut de macOS, TextEdit
- ce qui n'est pas recommandé - vous devrez procéder comme suit :

Ouvrir un nouveau fichier

Cliquez sur Format>Faire du texte brut
Cliquez sur Enter the Source Code, saisissez le code ci-dessous
et enregistrez-le sous [Link].
/*
* Mon premier programme Java, juste pour dire bonjour
*/
public class Hello { // Enregistrer sous "[Link]" dans
"~/monProjet"
public static void main(String[] args) {
[Link]("Hello, world from macOS !") ;
 }
}

Vous pouvez maintenant compiler votre programme et l'exécuter.

Ouvrir un autre terminal

Tapez les commandes suivantes :

Une explication de ces derniers :

// Changez de répertoire (cd) jusqu'à l'endroit où vous avez
sauvegardé "[Link]"
cd ~/monProjet

// Utiliser la commande list (ls) pour voir si "[Link]" existe en

utilisant

ls
[Link] ......

// Compiler "[Link]" avec le compilateur JDK "javac"

javac [Link]
// Si vous obtenez un message d'erreur, apportez les modifications
nécessaires au code source et recompilez.
 // Rechercher la sortie compilée "[Link]"
ls
[Link] [Link] ......

Vous pouvez maintenant exécuter Hello-World. Pour ce faire, appelez le

Java Runtime, comme ceci :
java Bonjour
Bonjour au monde de macOS !
Installation du JDK sur Ubuntu
Première étape
La première étape consiste à vérifier si Java est déjà installé sur votre
système Ubuntu

Ouvrez un terminal en appuyant sur CTRL+ALT+T

Saisissez la commande suivante
$ javac -version
Si vous voyez un numéro de version, vous savez que Java est installé. Si ce
n'est pas le cas, passez à l'étape suivante. Vous devez également suivre
l'étape suivante si vous utilisez OpenJDK.
Deuxième étape
Si Java n'est pas installé sur votre ordinateur, c'est le moment de l'installer.
Tout d'abord, si vous avez OpenJDK sur votre ordinateur, vous devez le
supprimer, donc entrez la commande suivante dans le Terminal :
sudo apt-get purge openjdk-\* $ sudo apt-get purge openjdk-\*
Nous pouvons maintenant télécharger Oracle JDK :

Ouvrir [Link]
[Link]

Cliquez sur Oracle JDK et choisissez JDK Download.

 Cliquez sur Linux x64 Compressed Archive Package - il
ressemblera à jdk-16.0.{x}-linux-x64_bin.[Link]. Par défaut, il
sera téléchargé dans le répertoire appelé ~/Downloads.
Troisième étape
Il est temps de l'installer. Le JDK doit être installé dans /usr/local/java, ou
dans le répertoire JDK par défaut d'Ubuntu, qui est /usr/lib/jvm, ou
/opt/java.

Créez un nouveau répertoire dans /usr/local et appelez-le java

Ouvrez un terminal et entrez les commandes suivantes

$ cd /usr/local
sudo mkdir java

Extraire le paquet :

$ cd /usr/local/java
$ sudo tar xzvf ~/Downloads/jdk-16.0.{x}-linux-x64_bin.[Link]
// x : extraire, z : pour décompresser gz, v : verbeux, f : nom
de fichier

Le JDK est extrait dans un dossier nommé / usr/local/java/jdk-15.0.{x} - x

indique le numéro de la mise à jour.

Ensuite, indiquez à Ubuntu qu'il doit utiliser ce JDK :

// Définir l'emplacement de java, javac et jshell en utilisant le
système "alternatives".
sudo update-alternatives --install "/usr/bin/java" "java"
"/usr/local/java/jdk-16.0.{x}/bin/java" 1
// --installation nom du lien symbolique chemin priorité
 $ sudo update-alternatives --install "/usr/bin/javac" "javac"
"/usr/local/java/jdk-16.0.{x}/bin/javac" 1
sudo update-alternatives --install "/usr/bin/jshell"
"java/usr/local/java/jdk-16.0.{x}/bin/jshell" 1

// Utiliser ce JDK Oracle par défaut

sudo update-alternatives --set java /usr/local/java/jdk-16.0.
{x}/bin/java
// --set name path
sudo update-alternatives --set javac /usr/local/java/jdk-16.0.
{x}/bin/javac
sudo update-alternatives --set jshell /usr/local/java/jdk-16.0.
{x}/bin/jshell

Cela crée les liens symboliques java, javac et jshell dans /usr/bin - ils seront
dans le PATH, qui renvoie à /etc/alternatives et au répertoire bin du JDK.
Le système appelé "alternatives" tente de résoudre les situations où
plusieurs programmes font la même chose, par exemple, plusieurs versions
différentes du JDK. Il définit également les liens symboliques via
/etc/alternatives pour faire référence aux programmes utilisés.
Il est également possible d'ajouter directement le fichier bin du JDK au
PATH :
$ ls -ld /usr/bin/java*
1 root root xx xxx xx xx:xx /usr/bin/java -> /etc/alternatives/java
......

$ ls -ld /etc/alternatives/java*
lrwxrwxrwx 1 root root xx xxx xx xx:xx /etc/alternatives/java ->
/usr/local/java/jdk-16.0.{x}/bin/java
 ......

// Le résultat est
java -> /usr/bin/java (par le PATH) -> /etc/alternatives/java ->
/usr/local/java/jdk-16.0.{x}/bin/java (programme actuel)
Quatrième étape
Nous devons maintenant vérifier l'installation. Saisissez les commandes
suivantes dans le terminal :
// Afficher la version du compilateur Java (javac)
$ javac -version
javac 16.0.{x}

// Afficher la version de Java Runtime (java)

java -version
version java "16.0.{x}"
......

// Afficher l'emplacement de javac et de java

qui javac
/usr/bin/javac

Quel java ?
/usr/bin/java
Cinquième étape
Vous n'avez PAS besoin de suivre cette étape comme cela a été fait à l'étape
trois. Il s'agit simplement de vous montrer comment le PATH est défini.
 Ajoutez le JDK bin (répertoire binaire) à PATH. Nous le
faisons en éditant le fichier /etc/profile :

$ cd /etc
sudo nano profile
Les lignes suivantes doivent être ajoutées à la fin du fichier /etc/profile, en
veillant à ce que {x} soit remplacé par le numéro approprié :

export JAVA_HOME=/usr/local/java/jdk-16.0.{x}
export PATH=$JAVA_HOME/bin:$PATH

Nous pouvons maintenant exécuter le profil de configuration comme suit :

// Rafraîchir
$ source /etc/profile

// Vérifier les nouveaux paramètres pour JAVA_HOME et PATH

$ echo $JAVA_HOME
/usr/local/java/jdk-16.0.{x}

$ echo $PATH
/usr/local/java/jdk-16.0.{x}/bin :......
Démarrer avec Java sur Ubuntu
Comme pour les deux premiers, nous allons écrire, compiler et exécuter le
programme Hello World. Ubuntu possède son propre éditeur de texte par
défaut, appelé gedit, qui peut parfaitement être utilisé.

Tout d'abord, créez un dossier en ouvrant l'Explorateur de

fichiers et en cliquant sur Accueil>Créer un nouveau dossier.
Nommez-le monProjet et enregistrez-le
 Ouvrez gedit - tapez le nom dans l'explorateur de fichiers et
cliquez sur le résultat.
Saisissez le code ci-dessous et enregistrez-le dans le répertoire
~/monProjet sous le nom [Link]
public class Hello { // Enregistrer sous "[Link]" dans
"~/monProjet"
public static void main(String[] args) {
[Link]("Hello, world from Ubuntu !") ;
}
}
Nous pouvons maintenant compiler le programme. Ouvrez un Terminal et
entrez les commandes suivantes :
// Modifier le répertoire dans lequel le code source est sauvegardé
$ cd ~/monProjet

// Lister le contenu du répertoire actuel. rechercher "[Link]"

$ ls
...... [Link] ......

// Compilez "[Link]" en "[Link]"

javac [Link]

// Vérifier la présence de "[Link]"

$ ls
...... [Link] ......
Exécutez le programme Java Hello-world :
// Exécutez "[Link]"
 java Hello
Bonjour au monde d'Ubuntu !
Note - A partir du JDK 11, le programme peut être compilé et exécuté en
une seule étape :
// Compiler et exécuter "[Link]" en une seule étape sans créer
la ".class"
$ java [Link]
Bonjour au monde d'Ubuntu !
Nouvelle fonctionnalité
Comme indiqué précédemment, le JDK 11 a lancé une nouvelle
fonctionnalité qui vous permet de compiler un programme composé d'un
seul fichier et de l'exécuter en une seule étape sans avoir besoin de le
compiler explicitement :

Écrivez votre programme à fichier unique, comme nous l'avons

fait dans la section précédente - écrivez [Link]
Si [Link] existe, le supprimer
Utilisez la commande suivante pour compiler et exécuter le
fichier :
// Changer le répertoire pour celui qui contient [Link]
// Compilation et exécution en une seule commande
java [Link]
Bonjour à tous !
Être conscient :

Cela ne fonctionnera que pour les fichiers à source unique

La compilation du programme ne nécessite pas l'utilisation de
javac
Le fichier est compilé en mémoire et exécuté. Aucun fichier
.class n'est produit
 Cette fonction a été introduite dans un double but : aider les
débutants à apprendre le langage Java et aider les
professionnels à tester les fonctionnalités.
Il n'est pas nécessaire de donner le même nom au fichier et à la
classe
Erreurs courantes d'installation du JDK
Il peut arriver que vous rencontriez une erreur d'installation. Voici les plus
courantes.
Problème
Vous ne pouvez pas compiler le programme Java à partir de l'interpréteur de
commandes CMD. Par exemple, javac [Link] ne fonctionnera pas.
Message d'erreur
'javac' n'est pas reconnu comme une commande interne ou externe, un
programme opérationnel ou un fichier batch.
Causes potentielles
La cause probable est que le répertoire bin du JDK n'est pas inclus dans la
variable d'environnement PATH, chargée de maintenir une liste des chemins
de recherche des programmes exécutables, qui inclut [Link].
Solutions possibles
Ouvrez un shell CMD en cliquant sur le bouton Démarrer et en cliquant sur
Exécuter>CMD.
Entrez la commande PATH suivante :
prompt> chemin
PATH=.......
Ensuite, vérifiez si le répertoire bin du JDK est inclus. Par exemple, disons
que vous avez installé votre JDK à c:\Nprogram files\Njava\Njdk-16.0.1.
Dans ce cas, vous devriez voir c:\Nprogram files \Njava \Njdk-15.0.1 \Nbin
inclus dans PATH.
Si ce n'est pas le cas, le répertoire bin doit être inclus dans la variable
d'environnement PATH - voir les étapes dans le tutoriel correspondant.
Problème
Votre programme peut être compilé mais ne s'exécutera pas à partir de
l'interpréteur de commandes CMD.
Message d'erreur :
Erreur : Impossible de trouver ou de charger la classe principale Xxx
Causes potentielles

1. La classe Java n'a pas été incluse dans le répertoire actuel

2. La variable d'environnement CLASSPATH a été correctement
définie, mais le répertoire actuel n'est pas inclus.
Solutions possibles

1. Une commande dir doit être émise pour dresser la liste du

contenu du répertoire actuel. Elle doit indiquer la classe Java
que vous souhaitez exécuter. Le programme source doit être
compilé pour obtenir le fichier de classe.
2. Si le répertoire actuel contient la classe Java, une commande
set class path doit être émise pour vérifier les paramètres de la
classe :
prompt> set classpath
CLASSPATH=.......
Tant que le CLASSPATH a été défini, vous devez supprimer la variable
d'environnement CLASSPATH. Dans votre panneau de configuration,
cliquez sur Paramètres>Paramètres système avancés. Passez ensuite à
l'onglet Avancé et cliquez sur Variables d'environnement. Cliquez sur
Variables utilisateur et Variables système. Choisissez la variable appelée
CLASSPATH et cliquez sur Supprimer. Elle sera ainsi supprimée des
variables utilisateur et des variables système.
Pour les utilisateurs plus avancés :
Si le CLASSPATH n'a pas été défini, le répertoire courant est utilisé par
défaut. S'il a été défini, le répertoire courant n'a pas été inclus
implicitement. Il peut être inclus au début des chemins de classe existants.
Problème
Le programme se compile mais ne peut pas être exécuté.
Message d'erreur
Erreur : Méthode principale introuvable dans la classe Hello
Solutions possibles
Vous devez vérifier le programme pour vous assurer qu'il existe une
méthode main() et vérifier la signature de la méthode main() indiquée dans
le message d'erreur.
Il est maintenant temps de plonger dans la véritable raison d'être de ce livre.
Nous allons examiner plusieurs façons de développer des applications
dorsales avec Java, en commençant par Spring.
Chapitre 3 : Java avec Spring
Ce chapitre traite de l'initialisation et du développement d'un backend de
site web à l'aide de Spring. Il est divisé en quatre parties distinctes :

Choisissez votre cadre

Initialiser votre projet Spring
Programmer le backend
Construire le backend
Nous les détaillerons dans un instant, mais vous devez d'abord installer
Spring. Vous trouverez tous les détails pertinents à l'adresse suivante :
[Link]
[Link]
Examinons maintenant les deux premières parties de ce tutoriel :
Choisissez votre cadre
Vous pouvez créer un site web de centaines de façons différentes, en
utilisant l'un des nombreux langages disponibles. Il n'y a pas de bonne ou de
mauvaise façon de procéder, et vous pouvez même utiliser le même cadre
pour le backend et le frontend. Nous utiliserons un cadre simple qui peut
être utilisé pour n'importe quel projet, même ceux qui évoluent rapidement -
Java avec Spring.
Initialisation du projet Spring
Avant de nous plonger dans ce sujet, nous devons savoir ce qu'est Spring.
Spring est un cadre convivial qui permet de découpler facilement les
programmes. Il utilise l'injection de dépendances pour faciliter le
changement d'implémentation ou de composants - nous y reviendrons dans
un instant.
La principale raison pour laquelle Spring est si populaire pour le backend
est qu'il offre de nombreux composants prêts à l'emploi pour les
applications web. Par exemple, avec Spring Security, vous pouvez avoir un
contrôle d'accès robuste et facile, tandis que Spring Data vous aide à vous
connecter facilement aux bases de données.
Ensuite, il y a Spring Initializer, que nous allons utiliser pour initialiser
notre projet. Si vous ne l'avez pas encore fait, téléchargez Spring sur votre
système, puis ouvrez l'assistant Spring. Ici, vous verrez plusieurs options, et
vous devrez choisir les suivantes :

Votre projet
La langue
La version de Spring Boot concernée
Les métadonnées du projet
Les dépendances.
Voyons de quoi il s'agit :
Votre projet
Vous devrez choisir entre Maven et Gradle - plus tard, il y aura un tutoriel
séparé pour ces deux outils mais, pour l'instant, nous utiliserons Gradle. Ces
deux outils permettent d'automatiser la construction de votre application.
Nous devons lui indiquer quelles sont les dépendances de notre projet, par
exemple Spring, et ensuite il le construira.
La langue
Comme ce livre traite de Java, c'est ce que nous choisirons.
La version de Spring Boot concernée
Il suffit de sélectionner la version que vous avez téléchargée.
Qu'est-ce que Spring Boot ? Spring est utilisé pour programmer
l'application, tandis que Spring Boot s'occupe des frais généraux liés à
l'exécution de l'application. Il examinera l'application, fera des vérifications
et des hypothèses, et s'assurera que vous disposez des configurations
standard dont votre application a besoin pour fonctionner. Par exemple, il
intègre des fonctionnalités de serveur, vous n'avez donc pas besoin d'y
penser. Gradle prendra ensuite tout cela en compte et construira votre
application Java.
Les métadonnées du projet
Dans cette section, les champs 1 et 2 indiquent le propriétaire du logiciel et
le nom de l'application. La méthode la plus courante consiste à utiliser le
schéma com.[nom de l'organisation].[nom du logiciel]. Les options les plus
intéressantes sont les versions Java et l'emballage. En ce qui concerne la
version, il doit s'agir de la version la plus stable et la plus récente. Nous
aborderons la question de l'emballage plus loin.
L'emballage
Lorsque vous créez une application à l'aide de Java, vous avez le choix
entre deux types de fichiers : .jar et .war. En général, les fichiers .war sont
des archives d'applications web qui s'exécutent sur le serveur de
l'application. Un fichier .jar est un fichier d'archive Java, qui s'exécute
également dans le serveur d'application et sur la machine de l'utilisateur.
Nous utiliserons .jar.
Les dépendances
Ici, vous choisissez d'autres dépendances que vous souhaitez définir,
comme Spring Data ou Spring Security. Pour l'instant, laissez ce champ
vide. Nous ajouterons manuellement les dépendances pertinentes lorsque
nous en aurons besoin.
Une fois que vous avez fait tout cela, cliquez sur le bouton Générer pour
créer le nouveau projet.
Programmer le backend
Notre projet est maintenant initialisé, et nous pouvons maintenant nous
atteler à la programmation du Backend. Cela se fera en cinq étapes :

Organiser la structure des dossiers de votre projet

Comprendre ce qui a été généré
Ajout d'un point final unique - pour que vous puissiez le
comprendre
Ajout d'une connexion à la base de données pour que les
données puissent être stockées
Ajout d'une authentification simple garantissant des points de
terminaison privés.
Commençons.
Organiser la structure des dossiers
Nous utiliserons la structure de dossier ci-dessous pour ce projet :

Le dossier du projet
Le backend
Le frontend
Déplacez le dossier généré par votre Spring Initializer dans le dossier du
projet. Renommez-le Backend.
Comprendre ce qui a été généré
Ouvrez le projet dans votre IDE Java et assurez-vous que vous avez installé
Gradle. Nous avons installé Eclipse, alors suivez ces étapes pour installer le
plugin Gradle Eclipse :

1. Ouvrez Eclipse et cliquez sur le menu Aide

2. Choisir Eclipse Marketplace
3. Tapez Gradle dans la barre de recherche
4. Cliquez sur le bouton Installer
5. Accepter la licence et cliquer sur Terminer
Une fois cette opération effectuée, Eclipse redémarre.
Pour l'instant, comme il n'y a rien dans votre projet, son exécution
entraînera sa fermeture immédiate, car il n'a rien à faire.
Avant de faire quoi que ce soit d'autre, nous devons examiner ce qui a été
généré et ce que cela signifie.
Pour ce faire, nous devons comprendre tous les dossiers et fichiers contenus
dans le répertoire racine :
.gradle - C'est le cache de Gradle. Par exemple, lorsque Gradle résout une
dépendance, celle-ci est mise en cache dans ce dossier.
.idea - Ce fichier stocke les paramètres du projet et ne contient rien pour
l'instant.
build - Lorsque le projet est exécuté, ce dossier est créé et stocke les classes
Java qui ont été compilées. Celles-ci sont ensuite chargées dans la JVM
pour que le projet puisse être exécuté.
gradle - Vous ne pouvez pas utiliser Gradle sans le gradle-wrapper. Celle-ci
fournit la compilation Gradle requise.
src - Ce fichier contient le code source. Nous allons maintenant examiner
un fichier généré appelé [Link].
.gitignore - C'est l'endroit où sont stockés les répertoires et les fichiers qui
ne doivent pas être inclus dans git.
[Link] - Il contient quatre sections distinctes :

Plugins - Les plugins Gradle étendent les capacités du projet.

Ils peuvent étendre Gradle, configurer votre projet et appliquer
une configuration spécifique.
Nous utilisons trois plugins :

Spring Boot - Permet d'utiliser Gradle pour construire une

application Spring Boot. Sans cela, Gradle n'aurait pas les
moyens de construire le projet.
Spring Dependency Management - Permet de définir les
dépendances sans avoir à fournir de numéro de version. Le
plugin fait correspondre la version de Spring Boot avec ces
dépendances.
Java - Comme on peut s'y attendre, ceci nous permet d'utiliser
Gradle pour construire un projet Java.
Métadonnées - Les sections groupe et version sont explicites, et la
compatibilité avec la source vous indique la version de Java compatible
avec votre code source.
Repositories - C'est ici que nous indiquons à Gradle où il doit chercher les
dépendances définies.
Dépendances - C'est ici que Gradle est informé des dépendances requises et
qu'il lui est demandé de les récupérer. Chaque dépendance aura deux parties
- la dépendance et la configuration. Le nom de la dépendance est explicite,
mais la configuration mérite un examen plus approfondi. La configuration
informe Gradle de l'objectif de la dépendance, et le plugin Java fournit ces
informations. La plupart du temps, l'implémentation sera utilisée car la
dépendance est typiquement utilisée pour implémenter le programme.
Gradlew - Il s'agit d'un script shell qui démarre le gradle-wrapper sur les
systèmes Unix et macOS.
[Link] - Il s'agit d'un script shell qui démarre le gradle-wrapper sur un
système Windows.
[Link] - Il s'agit d'un fichier texte d'aide généré par l'initialisateur
Spring.
[Link] - C'est ici que les paramètres de Gradle sont définis.
Avant de commencer à programmer, jetons un coup d'œil au fichier que
nous avons mentionné plus tôt. Le fichier
[Link] est un fichier source Java et
comporte 14 lignes de code :
package com.(votre nom de projet).playgroundwebbackend ;

import [Link] ;
import
[Link] ;

@SpringBootApplication
public class PlaygroundWebBackendApplication {
 public static void main(String[] args) {

[Link]([Link],
args) ;
}

}
La plupart de ces éléments sont assez explicites, mais vous avez peut-être
remarqué une annotation étrange - @SpringBootApplication. Vous verrez
de nombreuses annotations de ce type dans Spring, et nous en examinerons
quelques-unes plus tard. En règle générale, les annotations sont utilisées en
Java comme des marqueurs interprétés. Spring examinera vos fichiers et
appliquera la logique appropriée.
En ce qui concerne @SpringBootApplication, voici ce qu'il fait. Cette
annotation en remplace trois autres :

@EnableAutoConfiguration examine vos applications,

effectue ses vérifications et hypothèses, et s'assure que votre
application dispose de la configuration standard requise pour
fonctionner.
@ComponentScan indique où chercher les classes avec les
annotations Spring.
@Configuration informe Spring que la classe est utilisée pour
la configuration.
D'accord, c'était beaucoup de choses à assimiler. Prenez un peu de temps
pour comprendre, puis nous passerons à la partie suivante - la mise en place
d'un point de terminaison simple, juste pour vous donner une idée de ce
dont il s'agit. Ensuite, nous connecterons une base de données et nous nous
assurerons que notre application est sécurisée.
Ajouter un point final unique - pour que vous puissiez le comprendre
La première chose à faire est d'indiquer à Spring que nous avons besoin de
développer des fonctionnalités web. Pour ce faire, il suffit de modifier les
dépendances listées dans le fichier [Link] :
 dépendances {
implémentation '[Link]:spring-boot-
starter-web'
testImplementation '[Link]:spring-
boot-starter-test'
}
L'ajout du suffixe -web nous permet d'accéder à davantage de bibliothèques.
Une fois les dépendances réimportées, nous pouvons commencer à coder.
Avant d'en arriver là, il faut savoir que, dans Spring, un point de
terminaison s'appelle un contrôleur.
Spring utilise le cadre Spring Web MVC, les données servies par
l'application. Il peut s'agir d'une page web dont le rendu est assuré par
Spring. Le modèle est référencé, envoyant les données au contrôleur, et la
vue reçoit les informations requises. Comme Spring n'est pas utilisé pour le
rendu des vues, nous n'en avons pas. En tant que tel, le contrôleur est le
point de terminaison puisqu'il répond à la requête web.
La définition d'un nouveau contrôleur nécessite la création de deux
éléments :

Un nouveau paquet nommé controller

Une nouvelle classe Java nommée HelloWorldCreator
La définition d'un point final nécessite trois choses :

1. La nouvelle classe doit être déclarée comme contrôleur

Spring doit savoir que HelloWorldController est en fait un contrôleur. Cela
se fait à l'aide d'une annotation de stéréotype et il en existe deux qui
peuvent être utilisées pour définir les contrôleurs - @Controller et
@RestController.
@RestController est une spécialisation de @Controller utilisée pour
faciliter la mise en œuvre de la configuration. En effet, l'annotation
@ResponseBody n'a pas besoin d'être explicitement ajoutée aux points
d'extrémité. L'annotation est tout simplement ajoutée à la classe :
 @RestController
public class HelloWorldController {}

2. Ensuite, nous créons le point de terminaison

C'est assez simple à faire : il suffit de définir une méthode. Elle peut appeler
différentes classes et renvoyer n'importe quel type d'objet. Pour rester
simple, nous allons renvoyer une chaîne de caractères :
public String sayHelloWorld(){
return "Hello World !";
}

3. Enfin, le chemin est défini et le type d'extrémité est

demandé
Enfin, Spring a besoin de connaître le chemin et le type de requête qui est
mappé à notre point de terminaison. Nous le définirons simplement comme
une requête "get" dans /sayhello. Comme vous l'avez probablement deviné,
nous utilisons une annotation pour ce faire.
@GetMapping("/sayhello")
public String sayHelloWorld(){
retourner "Hello World !";
}
Votre classe devrait ressembler à ceci :
package com.(votre nom de
projet).[Link] ;

import [Link] ;
import [Link] ;

@RestController
 public class HelloWorldController {

@GetMapping("/sayhello")
public String sayHelloWorld(){
return "Hello World !";
}

}
Appuyez sur le bouton Exécuter et voyez ce qui se passe. Une fois
l'application lancée, ouvrez votre navigateur et tapez
localhost:8080/sayhello dans la barre de recherche. Vous devriez constater
que votre chaîne est renvoyée.
Travailler avec des données
À un moment ou à un autre, un backend web doit stocker des données. La
création d'une application Todo nécessite la définition d'un simple objet
todo-Object et la mise en œuvre de points de terminaison pour la lecture,
l'écriture, la mise à jour et la suppression d'entrées. Cependant, avant de
commencer à coder, Spring a besoin de savoir que nous travaillons avec des
données.
Nous allons utiliser MongoDB, mais une configuration similaire s'applique
à d'autres bases de données. L'ajout de la fonctionnalité est aussi simple que
l'ajout d'une dépendance nommée [Link]:spring-boot-starter-
data-mongodb dans le fichier appelé [Link] :

implémentation '[Link]:spring-boot-starter-
data-mongodb'

Vous devez avoir une instance MongoDB en cours d'exécution sur votre
système, et la façon la plus simple est d'utiliser un fichier docker-compose.
Téléchargez et installez Docker à partir de
[Link] puis créez un nouveau
fichier. Cela doit être fait dans le répertoire racine de votre projet, et non
dans le projet Spring. Appelez le fichier [Link] et ajoutez
le code suivant, en vous assurant que les espaces réservés sont remplacés
par les bonnes informations :
version : "3
les services :
playground-web-db :
image : mongo:4.2.2
l'environnement :
MONGO_INITDB_DATABASE : playground-web
ports :
- 27017:27017
Le démarrage de la base de données s'effectue en exécutant la commande
ci-dessous dans un terminal. Cette opération s'effectue à partir du dossier
racine de votre projet - assurez-vous que la fenêtre du terminal reste ouverte
:

docker-compose -f [Link] up

Structurer l'application
Bon, revenons à Spring. Ensuite, nous devons réfléchir à la manière dont
notre application sera structurée :

Nous avons besoin d'un objet de données décrivant l'objet

ToDo
Nous avons besoin d'un référentiel qui puisse communiquer
avec notre base de données.
Nous avons besoin d'un service qui puisse gérer la logique
commerciale supplémentaire
Nous avons besoin d'un contrôleur qui acceptera les demandes
de lecture, de création, de mise à jour et de suppression
d'entrées.
Créer l'objet de données
La première chose à faire est de créer un paquetage et de l'appeler data.
Ensuite, nous avons besoin d'une classe Java que nous appellerons ToDo,
caractérisant un objet todo. Pour rester simple, l'objet todo ne comporte que
trois éléments : un identifiant unique, un statut et un titre.
La classe se présente comme suit :
package com.(votre nom de projet).[Link] ;

public class ToDo {

private String id ;

private String title ;

private Boolean completed ;

}
Les deux propriétés, "titled" et "completed", sont définies par l'utilisateur,
mais le framework touche la propriété "id" pour garantir son intégrité. La
plupart des objets ont un identifiant unique, et Spring nous donne une
annotation appelée @Id. Cette annotation marque le champ id comme une
clé primaire, générant automatiquement une valeur.
Nous avons également besoin d'un constructeur et de quelques méthodes
d'obtention pour les propriétés afin de nous assurer que tout fonctionne
comme il se doit.
package com.(votre nom de projet).[Link] ;

import [Link] ;

public class ToDo {

 @Id
private String id ;

private String title ;

private Boolean completed ;

public ToDo(String title, Boolean completed){

[Link] = title ;
[Link] = completed ;
}

public String getId() {

retourner l'id ;
}

public String getTitle() {

titre de retour ;
}

public Boolean getCompleted() {

retour effectué ;
}

}
Créer un référentiel
Le référentiel interagira avec la base de données, et c'est là que Spring se
distingue. Si nous voulons interagir avec une base de données Mongo, nous
devons créer deux choses - un package que nous appellerons repository et
une interface pour étendre MongoRepository, appelée ToDoRepository.
MongoRepository utilise des génériques, donc deux paramètres sont
nécessaires lorsque nous l'étendons. Le premier paramètre est l'entité dont
nous avons besoin, la classe ToDo, et le second permet à Spring de savoir
quel est le type de l'attribut id, une chaîne dans notre cas.
package com.(votre nom de
projet).[Link] ;

import com.(votre nom de

projet).[Link] ;
import
[Link] ;

public interface ToDoRepository extends MongoRepository<ToDo,

String> {}
Créer le service
Tout d'abord, créez un nouveau paquetage et appelez-le service. Nous
devons maintenant créer une classe dans ce paquetage et la nommer
ToDoService - c'est dans cette classe que se déroule la logique
commerciale, et c'est le SEUL endroit où nous devrions travailler avec des
données. Nous n'avons pas de logique métier dans notre application, mais
nous avons besoin de méthodes pour lire, créer, mettre à jour et supprimer
des entités.
Comment faire ?
Tout d'abord, Spring doit être informé que la classe est un service, ce que
nous faisons en ajoutant l'annotation @Service. Cela nous permettra de
bénéficier d'autres fonctionnalités de Spring.
Ensuite, notre référentiel doit être ajouté en tant que propriété privée afin
qu'il puisse être utilisé. L'injection de constructeur Spring intervient ici -
l'annotation @Autowired est ajoutée, et Spring s'assure que nous avons une
instance au moment de l'exécution.
Les méthodes doivent maintenant être complétées :

Récupérer tous les todos

Récupérer une tâche par son identifiant
Enregistrer une tâche existante ou nouvelle
Supprimer une tâche par son identifiant
Parce que le MongoRepository a été étendu, nous avons déjà les méthodes
dont nous avons besoin :
package com.(votre nom de projet).[Link]
;

import com.(votre nom de

projet).[Link] ;
import com.(votre nom de
projet).[Link]
n;
import com.(votre nom de
projet).[Link] ;
import [Link] ;
import [Link] ;

import [Link] ;

@Service
public class ToDoService {

@Autowired
private ToDoRepository toDoRepository ;

public List<ToDo> findAll(){

return [Link]() ;
 }

public ToDo findById(String id){

return
[Link](id).orElseThrow(EntityNotFoundExcepti
on::new) ;
}

public ToDo save(ToDo toDo){

return [Link](toDo) ;
}

public void deleteById(String id){

[Link](id) ;
}

}
Tout cela devrait être simple, à l'exception d'une méthode : findById. Il se
peut que si nous utilisons un identifiant pour essayer de trouver une entité,
il n'y en ait pas une qui corresponde. C'est pourquoi notre référentiel
renvoie une option d'une tâche. Les optionnels peuvent ou non contenir
l'entité, donc, pour simplifier les choses, on demande au programme de
lancer une exception s'il ne trouve pas de correspondance. L'exception doit
être créée dans un nouveau paquetage nommé Exception.
package com.(votre nom de
projet).[Link] ;

public class EntityNotFoundException extends RuntimeException

{}
Créer le contrôleur
Nous avons maintenant besoin d'un nouveau contrôleur appelé
ToDoController, et il doit être créé dans le package controller. Encore une
fois, c'est assez simple, je vais donc vous donner le code final, puis nous
discuterons de certaines choses qui sont différentes du
HelloWorldController.
On pourrait se demander pourquoi nous utilisons le service plutôt que de
renvoyer les entités ici. La raison en est que lorsque vous commencez à
ajouter des contrôleurs et des objets de données, les choses peuvent devenir
un peu désordonnées !
package com.(votre nom de
projet).[Link] ;

import com.(votre nom de

projet).[Link] ;
import com.(votre nom de
projet).[Link] ;
import [Link] ;
import [Link].* ;

import [Link] ;

@RestController
@RequestMapping("/api/todo")
public class ToDoController {

@Autowired
private ToDoService toDoService ;

@GetMapping
public List<ToDo> findAll(){
 return [Link]() ;
}

@GetMapping("/{id}")
public ToDo findById(@PathVariable String id){
return [Link](id) ;
}

@PostMapping
public ToDo create(@RequestBody ToDo toDo){
return [Link](toDo) ;
}

@PutMapping("/{id}")
public ToDo update(@RequestBody ToDo toDo){
return [Link](toDo) ;
}

@DeleteMapping("/{id}")
public void deleteById(@PathVariable String id){
[Link](id) ;
}

}
La première chose à noter est une deuxième annotation dans la classe.
Celle-ci est appelée @RequestMapping, et elle garantit que /api/todo est
utilisé pour mapper tous les points de terminaison.
L'identifiant doit être passé par l'URL pour obtenir un document particulier,
par exemple, localhost:8080/api/todo/5d6e53da5c88f13387cb8fa3. Pour ce
faire, nous ajoutons des crochets aux annotations @GetMapping et
@PathVariable incluses dans l'en-tête de la méthode.
Un corps json est transmis pour créer ou mettre à jour des entités. Il doit
contenir les informations nécessaires à la création ou à la mise à jour des
entités. Nous indiquons à Spring que nous voulons le faire avec l'annotation
@RequestBody :
// Pour la création
{
"title" : "Finish it",
"completed":faux
}
// Pour la mise à jour
{
"id" : "5d6e54bd5c88f133b8209f34",
"titre" : "Finissez-en",
"completed" : vrai
}
Exécutez-le maintenant, et vous devriez voir que vous pouvez maintenant
obtenir des todos, créer des todos, mettre à jour des todos, et les supprimer :
// Obtenir tout
curl -X GET [Link]

// En créer un
curl -X POST \N
[Link] \N ---------------
 -H 'Content-Type : application/json' \N -H 'Content-Type :
application/json' -H 'Content-Type : application/json' \N
-d '{
"title" : "Finish it",
"completed":faux
}'

// Obtenir un
curl -X GET [Link] de ToDo>

// Mise à jour de la première

curl -X PUT \N
[Link] de la tâche à accomplir> \N-
\N- [Link]
-H 'Content-Type : application/json' \N -H 'Content-Type :
application/json' -H 'Content-Type : application/json' \N
-d '{
"id" : "<ID de la tâche>",
"titre" : "Finissez-en",
"completed" : vrai
}'

// En supprimer un
curl -X DELETE [Link] de ToDo>
Sécuriser les points finaux
Avant de construire l'application, nous voulons nous assurer que nous
disposons d'un point d'accès sécurisé. Nous pourrions utiliser un service de
gestion des utilisateurs, mais nous nous contenterons de sécuriser les
terminaux et d'ajouter un utilisateur à des fins d'authentification.
Tout d'abord, nous devons ajouter une nouvelle dépendance au fichier
Gradle, nommée [Link]:spring-boot-starter-security.
Ensuite, Spring doit être configuré pour savoir comment sécuriser
l'application. La configuration de Spring se fait à l'aide d'annotations et de
classes.
Créez un paquetage et appelez-le configuration. Dans ce paquetage, créez
une classe et appelez-la WebSecurityConfiguration.
Ajoutez l'annotation @Configuration pour que Spring sache que la classe
est destinée à la configuration. Nous allons définir la gestion de l'accès à
l'aide de cette configuration, de sorte que la classe
WebSecurityConfigurerAdaptor doit être étendue :
@Configuration
public class WebSecurityConfiguration extends
WebSecurityConfigurerAdapter {}
Pour sécuriser les points d'extrémité, la méthode configure de
WebSecurityConfigurerAdaptor doit être remplacée.
@Override
protected void configure(HttpSecurity http) throws Exception {
http
.authorizeRequests().antMatchers("/api/**").authenticated()
.et()
.httpBasic()
.et()
.exceptionHandling()
.authenticationEntryPoint(restAuthenticationEntryPoint)
.et()
 .formLogin()
. loginProcessingUrl("/api/login")
.successHandler(loginSuccessHandler)
.failureHandler(new
SimpleUrlAuthenticationFailureHandler()) ;
[Link]().ignoringAntMatchers("/api/login").csrfTokenReposit
ory([Link]()) ;
}
L'instance HttpSecurity de l'application, nommée http, est configurée dans
la méthode. Les différentes commandes sont enchaînées à l'aide de la
méthode and. Il se passe beaucoup de choses ici, nous allons donc les
décomposer par ligne.
Protection globale
Tout d'abord, l'application doit être informée que toutes les requêtes vers
/api/ doivent être sécurisées, c'est-à-dire autorisées. Toutes les requêtes http
doivent être authentifiées par http-basic.
Si un utilisateur tente d'accéder à une page protégée, un point d'entrée
renvoie un message 401 non autorisé.
Nous pourrions envoyer les informations d'identification avec toutes les
demandes, mais nous voulons une page de connexion où les utilisateurs
peuvent saisir leurs informations de connexion et obtenir un jeton. Cela
nous permet d'identifier les sessions individuelles des utilisateurs, de sorte
qu'il n'est pas nécessaire d'envoyer les informations d'identification à
chaque fois.
Le paramètre loginProcessingUrl indique à l'application l'URL à laquelle
les informations d'identification doivent être envoyées - ce paramètre est
utilisé dans la partie frontale.
Ensuite, deux gestionnaires sont définis, l'un pour une connexion réussie et
l'autre pour une connexion échouée.
Enfin, le CSRF est pris en charge.
Attendez, qu'est-ce que CSRF ?
C'est l'acronyme de Cross-Site Request Forgery, et je vais vous donner une
vue d'ensemble, afin que vous compreniez pourquoi des changements
doivent être apportés au backend.
Nous ne voulons pas que les pirates aient trop de facilité à se faire passer
pour de vrais utilisateurs, et nous essayons de nous en assurer en veillant à
ce que chaque requête envoyée au backend ait un identifiant unique dans
l'en-tête. Le frontend est responsable de la mise en place de ce jeton, et il le
fait automatiquement. Dans notre configuration, cela ne nous protège pas -
si notre configuration échoue, un cookie est utilisé pour transmettre le jeton
- mais cela nous donne une couche de protection.
La dernière ligne configure les éléments suivants :

Nous ne devrions pas appliquer la protection csrf au point final

de connexion - c'est là que l'utilisateur obtient un jeton.
Nous devrions utiliser un référentiel cookie-csrf-token standard
avec une protection csrf.
Nous devons définir httponly comme false dans le référentiel,
afin que la méthode cookie-to-header puisse être utilisée par le
frontend.
Page de connexion - Success Handler
Le gestionnaire de succès est une classe contenue dans le paquetage de
configuration et est utilisé pour étendre
SimpleUrlAuthenticationSuccessHandler.
Plus simplement, si nous obtenons une connexion réussie, nous ne voulons
pas qu'une réponse 200 Okay soit renvoyée par le backend.
SimpleUrlAuthenticationSuccessHandler le fera, mais il redirigera
également l'utilisateur vers une URL spécifique. Ce n'est pas ce que nous
voulons. Tout ce que nous voulons, c'est une réponse 200, donc, pour
faciliter les choses, nous copions le code de
SimpleUrlAuthenticationSuccessHandler et nous supprimons la logique de
la redirection. Ce qui nous laisse avec :
@Component("loginSuccessHandler")
public class LoginSuccessHandler extends
SimpleUrlAuthenticationSuccessHandler {

private RequestCache requestCache = new

HttpSessionRequestCache() ;

@Override
public void onAuthenticationSuccess(HttpServletRequest
request, HttpServletResponse response, Authentication
authentication) throws ServletException, IOException {

SavedRequest savedRequest =
[Link](request, response) ;

if (savedRequest == null) {
clearAuthenticationAttributes(request) ;
retour ;
}
String targetUrlParam = getTargetUrlParameter() ;
if (isAlwaysUseDefaultTargetUrl() || (targetUrlParam != null
&& [Link]([Link](targetUrlParam)))))
{
[Link](request, response) ;
clearAuthenticationAttributes(request) ;
retour ;
}

clearAuthenticationAttributes(request) ;
}
 public void setRequestCache(RequestCache requestCache) {
[Link] = requestCache ;
}

}
Cette classe doit être injectée dans WebSecurityConfigurerAdaptor, c'est
pourquoi l'annotation @Component est nécessaire pour indiquer à Spring
que la classe doit être injectée ultérieurement.
Page de connexion - Gestionnaire d'échec
Si la connexion échoue, tout ce que nous voulons, c'est une réponse 401 non
autorisée. Nous pouvons le faire assez facilement en utilisant la classe
SimpleUrlAuthenticationFailureHandler - pas besoin d'écrire et
d'implémenter notre propre code.
Gestion des exceptions - RestAuthenticationEntryPoint
Si un utilisateur tente d'accéder à une page sans autorisation, nous voulons
qu'une réponse 401 soit renvoyée. Une nouvelle classe doit être créée et
nommée [Link], et le code ci-dessous doit y
être copié :
@Composant
public final class RestAuthenticationEntryPoint
implements AuthenticationEntryPoint {

@Override
public void commence(HttpServletRequest request,
HttpServletResponse response,
[Link]
authException) throws IOException, ServletException {
[Link](HttpServletResponse.SC_UNAUTHORI
ZED, "Unauthorized") ;
 }
}
Injecter des gestionnaires dans WebSecurityConfiguration
Les gestionnaires doivent être injectés pour que nous puissions les utiliser :

@Configuration
public class WebSecurityConfiguration extends
WebSecurityConfigurerAdapter {

@Autowired
private LoginSuccessHandler ;

@Autowired
private RestAuthenticationEntryPoint ;

@Override
protected void configure(HttpSecurity http) throws Exception {
...
Définir un utilisateur avec des informations d'identification
Si nous devions exécuter cette application maintenant, toute requête
/api/todo/ échouerait parce que nous ne sommes pas des utilisateurs
autorisés. Cependant, nous pouvons toujours accéder au premier point
d'accès appelé /sayHello.
L'étape suivante consiste à configurer un utilisateur avec des droits d'accès
à /api/todo/, ce qui est fait en ajoutant deux méthodes à
WebSecurityConfiguration.
@Bean
public UserDetailsService userDetailsService() {
 Chaîne mot de passe = "mot de passe" ;
String username = "user" ;
InMemoryUserDetailsManager manager = new
InMemoryUserDetailsManager() ;
String encodedPassword = passwordEncoder().encode(password)
;
[Link]([Link](username).password(enc
odedPassword).roles("USER").build()) ;
gestionnaire de retour ;
}

@Bean
public PasswordEncoder passwordEncoder() {
return new BCryptPasswordEncoder() ;
}
La première méthode nous permet d'informer Spring que nous voulons que
les détails de l'utilisateur soient stockés dans la mémoire de l'application et
qu'un nouvel utilisateur soit créé.
Comme les mots de passe ne doivent pas être stockés en texte clair, nous
devons les encoder, et un encodeur de mots de passe est défini dans la
deuxième méthode.
Avez-vous remarqué qu'une nouvelle annotation a été utilisée pour ces deux
méthodes ? Elle s'appelle @Bean et indique à Spring que nous voulons
créer un bean Java. Si nous omettons cette annotation, notre configuration
n'aura accès à aucune des deux méthodes.
Votre classe de configuration ressemble maintenant à ceci :
package com.(votre nom de
projet).[Link] ;
import [Link] ;
import [Link] ;
import [Link] ;
import
[Link]
ecurity ;
import
[Link].
WebSecurityConfigurerAdapter ;
import [Link] ;
import
[Link] ;
import
[Link]
er ;
import
[Link] ;
import
[Link]
Manager ;
import
[Link]
terceptor ;
import
[Link]
ticationFailureHandler ;
import
[Link]
y;
@Configuration
public class WebSecurityConfiguration extends
WebSecurityConfigurerAdapter {

@Autowired
private RestAuthenticationEntryPoint ;

@Autowired
private LoginSuccessHandler ;

@Override
protected void configure(HttpSecurity http) throws Exception {
http
.authorizeRequests().antMatchers("/api/**").authentica
ted()
.et()
.httpBasic()
.et()
.exceptionHandling()
.authenticationEntryPoint(restAuthenticationEntryP
oint)
.et()
.formLogin()
.loginProcessingUrl("/api/login")
.successHandler(loginSuccessHandler)
.failureHandler(new
SimpleUrlAuthenticationFailureHandler()) ;
 [Link]().ignoringAntMatchers("/api/login").csrfTokenRepo
sitory([Link]()) ;
}

@Bean
public UserDetailsService userDetailsService() {
String username = "user" ;
Chaîne mot de passe = "mot de passe" ;
InMemoryUserDetailsManager manager = new
InMemoryUserDetailsManager() ;
String encodedPassword =
passwordEncoder().encode(password) ;
[Link]([Link](username).password
(encodedPassword).roles("USER").build()) ;
gestionnaire de retour ;
}

@Bean
public PasswordEncoder passwordEncoder() {
return new BCryptPasswordEncoder() ;
}
}

Si nous devions exécuter l'application maintenant, nous aurions des points

de terminaison sécurisés auxquels seuls les utilisateurs enregistrés peuvent
accéder lorsqu'ils sont connectés. Il existe un moyen simple de tester cela en
utilisant Postman. Cependant, une augmentation de la sécurité entraîne un
processus de test plus complexe.
Tout d'abord, une requête POST est nécessaire pour se connecter. Cette
requête va à api/login/, et le nom d'utilisateur et le mot de passe sont soumis
comme données de formulaire :

Un nouveau cookie est défini dans la réponse de connexion.

Postman utilise automatiquement le cookie, mais il doit également être
placé dans chaque requête en tant qu'en-tête :
Maintenant, tout devrait bien fonctionner.
Construire l'application
C'est la partie la plus facile - si vous vous souvenez, nous avons utilisé
Gradle pour aider à automatiser la construction. Tout ce que nous avons à
faire est d'ouvrir un Terminal et d'aller dans le dossier du projet. Ensuite,
nous l'exécutons simplement :

gradle build

Un fichier .jar est construit sous ./build/libs/, et tout ce que nous avons à
faire est d'exécuter l'application, et elle fonctionnera :

java -jar ./build/libs/playground-web-backend-0.0.1-

[Link]

Félicitations, vous avez terminé notre tutoriel Spring avec Java.

Dans le prochain chapitre, nous verrons comment utiliser Maven.
Chapitre 4 : Java avec Maven
Dans ce chapitre, nous utiliserons Maven pour construire un projet Java
simple afin d'expliquer comment tout cela fonctionne. Nous allons créer une
application simple qui nous indique l'heure et la construire à l'aide de
Maven.
Cela vous prendra environ 15 minutes, et tout ce dont vous avez besoin est
votre IDE et le JDK.
Comme dans de nombreux guides de démarrage avec Spring, vous pouvez
faire l'une des deux choses suivantes : partir de zéro ou télécharger le code à
partir d'un dépôt alternatif. Nous allons partir de zéro :
Première étape
La première étape consiste à créer un projet Java pour que Maven puisse le
construire. Nous allons garder cela très simple pour l'instant, et vous pouvez
le créer dans n'importe quel dossier de projet que vous choisissez.
Deuxième étape
Une fois que votre répertoire de projet est en place, créez une structure de
sous-répertoire comme suit.
└── src
└─── principal
└── java
└── Bonjour
Dans le répertoire src/main/java/hello, des classes Java peuvent être créées,
toutes celles que vous voulez. Pour ce guide, nous en créerons deux :
[Link] et [Link].
src/main/java/hello/[Link]
paquet hello ;

public class HelloWorld {

 public static void main(String[] args) {
Greeter greeter = new Greeter() ;
[Link]([Link]()) ;
}
}COPY
src/main/java/hello/[Link]
paquet hello ;

public class Greeter {

public String sayHello() {
retourner "Hello world !";
}
}COPY
Troisième étape
Votre projet est prêt à être construit par Maven, il vous faut donc maintenant
installer Maven.
Ouvrez [Link] Maven est un fichier zip,
recherchez donc un lien indiquant apache-maven-{version} - [Link] pr
[Link].
Téléchargez le fichier et décompressez-le, en le sauvegardant à un endroit
où vous pourrez facilement y accéder.
Le dossier bin doit être ajouté à votre chemin d'accès, puis vous pouvez
ouvrir la ligne de commande et tester l'installation :
mvn -v
Si tout va bien, vous devriez voir des informations concernant votre
installation Maven, quelque chose de similaire à ceci :
 Apache Maven 3.3.9
(bb52d8502b132ec0a5a3f4c09453c07478323dc5 ; 2015-11-
10T16:41:47+00:00)
Maison Maven : /home/dsyer/Programmes/apache-maven
Version Java : 1.8.0_152, fournisseur : Azul Systems, Inc.
Domicile Java : /home/dsyer/.sdkman/candidats/java/8u152-
zulu/jre
Localité par défaut : en_GB, encodage de la plateforme : UTF-8
Nom du système d'exploitation : "linux", version : "4.15.0-36-
generic", arch : "amd64", famille : "unix"
Maven est installé avec succès.
Quatrième étape
Il est temps de créer la définition de votre projet Maven. Ceux-ci sont
définis à l'aide d'un fichier XML appelé [Link]. Ce fichier fournit le nom
et la version de votre projet ainsi que les dépendances sur les bibliothèques
externes.
Commencez par créer un fichier à la racine du projet et appelez-le [Link].
Assurez-vous qu'il est placé à côté du dossier appelé src et entrez-y ce qui
suit :
[Link]
<?xml version="1.0" encoding="UTF-8"?>
<projet xmlns="[Link]
xmlns:xsi="votre groupe ou organisation/2001/XMLSchema-
instance"
xsi:schemaLocation="[Link]
[Link]
<modelVersion>4.0.0</modelVersion>

<groupId>[Link]</groupId>
<artifactId>gs-maven</artifactId>
<emballage>jar</emballage>
<version>0.1.0</version>

<propriétés>
<[Link]>1.8</[Link]>
<[Link]>1.8</[Link]>
</properties>

<b>Construction>
<plugins>
<plugin>
<groupId>[Link]</groupId>
<artifactId>maven-shade-plugin</artifactId>
<version>3.2.4</version>
<exécutions>
<exécution>
<phase>package</phase>
<b>Objectifs>
<goal>ombre</goal>
</goals>
<configuration>
<transformateurs>
<transformateur
 implementation="[Link]
[Link]">
<mainClass>[Link]</mainCl
ass>
</transformer>
</transformers>
</configuration>
</execution>
</executions>
</plugin>
</plugins>
</build>
</projet>COPY
L'élément <packaging> est facultatif et, en outre, il s'agit de la forme la plus
simple du fichier [Link] dont vous avez besoin pour construire votre
projet en Java. Les détails suivants sur la configuration du projet sont inclus
:

<modelVersion> - La version du modèle de POM, qui est

toujours 4.0.0
<groupID> - L'organisation ou le groupe propriétaire du
projet, plus souvent exprimé sous la forme d'un nom de
domaine (inversé)
<artifactID> - Le nom donné à l'artefact de la bibliothèque
pour le projet - c'est-à-dire le nom donné au WAR et au fichier
JAR.
<version> - La version du projet que vous construisez
<packaging> - Indique comment empaqueter le projet. La
valeur par défaut est jar, mais si vous voulez un fichier WAR,
 remplacez-la par war.
Spring recommande d'utiliser l'approche sémantique pour choisir les
schémas de version.
Pour l'instant, vous avez un projet Maven très simple et minimal.
Cinquième étape
Maven est maintenant configuré et prêt à construire votre projet. Vous
pouvez maintenant utiliser Maven pour exécuter les objectifs du cycle de
vie de la construction, y compris ceux de compiler le code, de créer des
paquets de bibliothèques, d'installer des bibliothèques dans le référentiel de
dépendances, et ainsi de suite.
Essayez votre construction en entrant la commande suivante dans la ligne
de commande :
mvn compile
Maven s'exécutera comme la commande lui a demandé d'exécuter votre
objectif de compiler le fichier. Regardez dans le répertoire target/classes
quand c'est fait, où vous verrez les fichiers .class compilés.
Il est peu probable que vous ayez besoin de travailler avec des fichiers
.class ou de les distribuer directement, c'est pourquoi nous utiliserons
l'objectif du paquet :
paquet mvn
Il compile le code, exécute les tests nécessaires et, pour finir, l'emballe dans
un fichier JAR qu'il place dans le répertoire cible. Le nom du fichier JAR
est basé sur <artifactId> et <version>. Par exemple, pour le petit fichier
POM que nous avons construit, il s'appellera [Link].
Le code suivant doit être exécuté pour lancer le fichier :
java -jar target/[Link]
Si vous changez la valeur de <packaging> de jar à war, vous verrez un
fichier WAR au lieu d'un fichier JAR dans le répertoire.
Maven conserve également un référentiel contenant les dépendances
stockées sur votre machine locale. Il se trouve généralement dans un
répertoire appelé xxx.m2/repository dans votre répertoire personnel, et il
vous permet d'accéder facilement aux dépendances de votre projet. Si vous
souhaitez installer le fichier JAR dans ce référentiel, vous devez invoquer
l'objectif install :
mvn install
L'objectif est de compiler et de tester le code, de l'empaqueter et de le
copier dans le référentiel local des dépendances. De cette façon, il peut être
référencé en tant que dépendance par d'autres projets.
Sixième étape
Il est maintenant temps de déclarer les dépendances dans notre build
Maven. L'exemple Hello World est autonome et ne dépend d'aucune autre
bibliothèque. Cependant, la plupart des applications dépendent d'autres
bibliothèques lorsqu'elles ont besoin de fonctionnalités complexes ou
communes.
Supposons, par exemple, qu'en plus de dire "Hello World", vous souhaitiez
imprimer la date et l'heure. Vous pouvez utiliser les facilités offertes par les
bibliothèques Java natives, mais vous pouvez aussi rendre les choses un peu
plus excitantes en utilisant les bibliothèques Joda Time.
Tout d'abord, le fichier [Link] doit être modifié pour ressembler à
ceci :
src/main/java/hello/[Link]
paquet hello ;

import [Link] ;

public class HelloWorld {

public static void main(String[] args) {
LocalTime currentTime = new LocalTime() ;
 [Link]("L'heure locale actuelle est : " +
currentTime) ;
Greeter greeter = new Greeter() ;
[Link]([Link]()) ;
}
}COPY
HelloWorld utilise la classe LocalTime de Joda Time pour obtenir l'heure
actuelle et l'imprimer.
Si vous construisez le projet en lançant mvn compile, il échouera. Pourquoi
? Parce que Joda Time n'a pas été déclaré dans le build comme une
dépendance de compilation. Ceci est facilement corrigé en incluant les
lignes suivantes, à l'intérieur de l'élément <project>, dans votre fichier
[Link] :
<dépendances>
<dépendance>
<groupId>joda-time</groupId>
<artifactId>joda-time</artifactId>
<version>2.9.2</version>
</dependency>
</dependencies>COPY
Ce bloc XML déclare les dépendances du projet, en particulier une
dépendance liée à la bibliothèque Joda Time. À l'intérieur de l'élément
<dependency>, trois sous-éléments sont utilisés pour définir les
coordonnées de la dépendance :

<groupId> - indique l'organisation ou le groupe propriétaire

de la dépendance
<artifactId> - indique la bibliothèque requise
 <version> - indique la version spécifique de la bibliothèque
requise
Par défaut, chaque dépendance est considérée comme une dépendance de
compilation. Cela signifie qu'elles sont (ou devraient être) disponibles au
moment de la compilation. Vous pouvez également spécifier un élément
<scope> afin de spécifier une portée particulière :

fournies - il s'agit des dépendances nécessaires à la

compilation du code, mais qui sont fournies par un conteneur
au moment de l'exécution. Le conteneur exécute le code, par
exemple, une API Java Servlet.
test - il s'agit des dépendances nécessaires à la compilation et à
l'exécution des tests, mais qui ne sont pas nécessaires à la
construction ou à l'exécution du code d'exécution.
Si vous exécutez mvn package ou mvn compile maintenant, la dépendance
Joda Time devrait être résolue à partir du dépôt central, et vous aurez une
compilation réussie.
Septième étape
Nous pouvons maintenant écrire un test.
<dépendance>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>COPY
Ensuite, il faut créer un scénario de test :
src/test/java/hello/[Link]
paquet hello ;
 import static [Link] ;
import static [Link].* ;

import [Link] ;

public class GreeterTest {

private Greeter greeter = new Greeter() ;

@Test
public void greeterSaysHello() {
assertThat([Link](), containsString("Hello")) ;
}

}COPY
Maven utilise "surefire", un plugin pour l'exécution des tests unitaires. La
configuration par défaut de ce plugin compile et exécute les classes dont les
noms correspondent à *Test dans src/test/java. Cela peut être fait en ligne
de commande :
mvn test
Vous pouvez également utiliser mvn install comme nous l'avons fait
précédemment.
Le fichier [Link] terminé devrait ressembler à ceci :
[Link]
<?xml version="1.0" encoding="UTF-8"?>
<projet xmlns="[Link]
xmlns:xsi="votre groupe ou organisation/2001/XMLSchema-
instance"
xsi:schemaLocation="[Link]
[Link]
<modelVersion>4.0.0</modelVersion>

<groupId>[Link]</groupId>
<artifactId>gs-maven</artifactId>
<emballage>jar</emballage>
<version>0.1.0</version>

<propriétés>
<[Link]>1.8</[Link]>
<[Link]>1.8</[Link]>
</properties>

<dépendances>
<!-- tag::joda[] -->
<dépendance>
<groupId>joda-time</groupId>
<artifactId>joda-time</artifactId>
<version>2.9.2</version>
</dependency>
<!-- end::joda[] -->
<!-- tag::junit[] -->
<dépendance>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
 <version>4.12</version>
<scope>test</scope>
</dependency>
<!-- end::junit[] -->
</dépendances>

<b>Construction>
<plugins>
<plugin>
<groupId>[Link]</groupId>
<artifactId>maven-shade-plugin</artifactId>
<version>3.2.4</version>
<exécutions>
<exécution>
<phase>package</phase>
<b>Objectifs>
<goal>ombre</goal>
</goals>
<configuration>
<transformateurs>
<transformer
implementation="[Link]
stResourceTransformer">

<mainClass>[Link]</mainClass>
</transformer>
 </transformers>
</configuration>
</execution>
</executions>
</plugin>
</plugins>
</build>

</projet>COPY
Ce fichier utilise le plugin Maven Shade, ce qui facilite l'exécution du
fichier JAR ; cependant, ce petit guide a pour but de vous familiariser avec
Maven, et non avec les plugins. Félicitations, vous avez maintenant
construit une définition de projet simple qui permet à Maven de vous aider
à construire des projets Java.
Chapitre 5 : Java avec Gradle
Ce chapitre vous permettra de vous familiariser avec Gradle en construisant
une application simple. Cela prendra environ 15 minutes, et tout ce dont
vous avez besoin est le JDK et un IDE.
Comme pour le guide Maven, vous pouvez partir de zéro ou télécharger le
code à partir d'une source externe - nous partons de zéro.
Première étape
Tout d'abord, nous devons créer un nouveau projet Java à construire avec
Gradle. Nous allons garder les choses simples pour l'instant, alors allez-y et
faites-le.
Deuxième étape
Ensuite, nous créons la structure du répertoire. Faites-le dans le répertoire
de votre choix - créez un sous-répertoire comme suit :
└── src
└─── principal
└── java
└── Bonjour
Vous pouvez créer toutes les classes Java que vous souhaitez dans le
répertoire src/main/java/hello. Nous allons créer les deux mêmes classes
que dans le guide Maven - [Link] et [Link]
src/main/java/hello/[Link]
paquet hello ;

public class HelloWorld {

public static void main(String[] args) {
Greeter greeter = new Greeter() ;
[Link]([Link]()) ;
 }
}COPY
src/main/java/hello/[Link]
paquet hello ;

public class Greeter {

public String sayHello() {
retourner "Hello world !";
}
}COPY
Troisième étape
Nous pouvons maintenant installer Gradle. Pour ce faire, nous vous
recommandons d'utiliser un installateur :

SDKMAN
Homebrew (brew install gradle)
Si aucune de ces solutions ne vous convient, les binaires peuvent être
téléchargés à partir de [Link] Vous n'avez
besoin que des binaires, trouvez donc le fichier [Link]. Vous
pouvez aussi choisir le fichier [Link] si vous voulez aussi la
documentation et les sources.
Décompressez et enregistrez le fichier sur votre ordinateur et assurez-vous
que le dossier bin est ajouté à votre chemin d'accès.
Testez l'installation en lançant Gradle depuis votre ligne de commande :
gradle
Si tout va bien, vous verrez quelque chose de semblable à ce qui suit :
:aide
 Bienvenue à Gradle 6.0.1.

Pour lancer une compilation, exécutez gradle <task> ...

Pour voir la liste des tâches disponibles, lancez gradle tasks

Pour voir la liste des options de la ligne de commande, lancez

gradle --help

Pour obtenir plus de détails sur une tâche, lancez gradle help --task
<task>.

Pour le dépannage, consultez le site [Link]

Des fonctionnalités Gradle obsolètes ont été utilisées dans cette

version, ce qui la rend incompatible avec Gradle 7.0.
Utilisez '--warning-mode all' pour afficher les avertissements de
dépréciation individuels.
Voir
[Link]
ml#sec:command_line_warnings

BUILD SUCCESSFUL en 455ms

1 tâche réalisable : 1 exécutée
Gradle est installé avec succès.
Vous pouvez maintenant l'explorer pour voir ce qu'il peut faire. Avant de
créer un projet .gradle, découvrez quelles sont les tâches à accomplir :
tâches gradle
Une liste des tâches disponibles devrait apparaître sur votre écran. En
supposant que Gradle a été lancé dans un dossier qui ne contient pas déjà un
fichier [Link], vous verrez des tâches élémentaires, telles que :
:tâches

------------------------------------------------------------
Tâches exécutables à partir du projet racine
------------------------------------------------------------

Tâches de configuration de la construction

-----------------
init - Initialise une nouvelle compilation Gradle.
wrapper - Génère des fichiers wrapper Gradle.

Tâches d'aide
----------
buildEnvironment - Affiche toutes les dépendances buildscript
déclarées dans le projet racine "gs-gradle".
components - Affiche les composants produits par le projet racine
'gs-gradle'. [en cours d'incubation]
dependencies - Affiche toutes les dépendances déclarées dans le
projet racine "gs-gradle".
dependencyInsight - Affiche la vue d'ensemble d'une dépendance
spécifique dans le projet racine "gs-gradle".
dependentComponents - Affiche les composants dépendants des
composants du projet racine 'gs-gradle'. [en cours d'incubation]
help - Affiche un message d'aide.
model - Affiche le modèle de configuration du projet racine 'gs-
gradle'. [en cours d'incubation]
outgoingVariants - Affiche les variantes sortantes du projet racine
"gs-gradle".
 projects - Affiche les sous-projets du projet racine "gs-gradle".
properties - Affiche les propriétés du projet racine "gs-gradle".
tasks - Affiche les tâches exécutables à partir du projet racine "gs-
gradle".

Pour voir toutes les tâches et plus de détails, exécutez gradle tasks -
-all

Pour obtenir plus de détails sur une tâche, lancez gradle help --task
<task>.

Des fonctionnalités Gradle obsolètes ont été utilisées dans cette

version, ce qui la rend incompatible avec Gradle 7.0.
Utilisez '--warning-mode all' pour afficher les avertissements de
dépréciation individuels.
Voir
[Link]
ml#sec:command_line_warnings

BUILD SUCCESSFUL en 477ms

1 tâche réalisable : 1 exécutée
Bien que ces tâches soient présentes, sans une configuration de
construction, elles n'ont pas beaucoup de valeur. Au fur et à mesure que
vous étoffez le fichier [Link], vous découvrirez que certaines tâches
sont plus utiles. Et au fur et à mesure que des plugins sont ajoutés au
fichier, cette liste de tâches va continuer à s'allonger, il serait donc utile de
lancer la commande de temps en temps pour voir ce qui a été ajouté.
Quatrième étape
Nous voulons construire notre code et le faire en ajoutant un plugin qui
nous donne une fonctionnalité de construction de base.
Commencez par construire un simple fichier [Link] dans votre
<dossier projet>, celui que vous avez créé au début. Ajoutez-y une seule
ligne de code :
appliquer le plugin : 'java'COPY
Ce n'est peut-être qu'une ligne, mais elle est très puissante. Essayez de
lancer à nouveau gradle tasks, et vous verrez que de nouvelles tâches ont
été ajoutées à la liste. Cela inclut celles pour construire un projet, créer une
JavaDoc et exécuter des tests.
Gradle build sera souvent utilisé car il compile le code, le teste et l'assemble
dans un fichier JAR. Il est exécuté à l'aide de cette commande :
gradle build
Laissez passer quelques secondes et vous devriez voir apparaître un
message indiquant "BUILD SUCCESSFUL" (construction réussie). Cela
indique que la construction est terminée.
Regardez dans le dossier de construction pour voir les résultats de la
construction, et vous devriez trouver quelques répertoires. Trois d'entre eux
sont :

classes - ce sont les fichiers .class compilés pour le projet

rapports - ces rapports sont produits par votre système de
construction et comprennent des éléments tels que les rapports
de test
libs - il s'agit des bibliothèques assemblées pour le projet et
sont généralement des fichiers WAR et WAR.
Dans le dossier classes, vous trouverez les fichiers .class qui proviennent du
code Java compilé. Les deux fichiers spécifiques que vous devriez trouver
sont [Link] et [Link].
Votre projet n'aura aucune dépendance de bibliothèque pour le moment,
vous ne devriez donc rien voir dans le dossier dependency_cache.
Dans le dossier des rapports, vous verrez un rapport contenant des détails
sur les tests unitaires en cours d'exécution du projet - ce n'est pas le rapport
le plus intéressant à lire.
Vous verrez un fichier JAR portant le même nom que le dossier du projet
dans le dossier libs. Un peu plus loin, vous verrez comment le nom et la
version du JAR peuvent être spécifiés.
Cinquième étape
Il est temps de déclarer nos dépendances. Notre exemple HelloWorld est
autonome et ne dépend pas de bibliothèques externes. Cependant, la plupart
des applications ont besoin de bibliothèques externes pour des
fonctionnalités complexes ou communes.
Comme nous l'avons fait avec notre projet Maven, vous voudrez peut-être
voir les données et l'heure, ainsi que Hello World ! Encore une fois, nous
utiliserons les bibliothèques Joda Time pour cela, donc modifiez
[Link], pour qu'il ressemble à ceci :
paquet hello ;

import [Link] ;

public class HelloWorld {

public static void main(String[] args) {
LocalTime currentTime = new LocalTime() ;
[Link]("L'heure locale actuelle est : " +
currentTime) ;

Greeter greeter = new Greeter() ;

[Link]([Link]()) ;
}
}COPY
La classe LocalTime de Joda Time est utilisée pour obtenir l'heure actuelle
et l'imprimer. Encore une fois, cette compilation échouerait parce que Joda
Time n'a pas été déclaré comme une dépendance de compilation.
Pour commencer, il faut ajouter une source pour les bibliothèques tierces :
dépôts {
mavenCentral()
}COPY
Ce bloc de code indique que la compilation doit utiliser le référentiel central
Maven pour résoudre les dépendances. Gradle s'appuie fortement sur de
nombreuses facilités et conventions établies par l'outil de construction
Maven, y compris l'utilisation de Maven Central comme source de
dépendances.
Sixième étape
Nous pouvons maintenant déclarer des bibliothèques tierces :
sourceCompatibility = 1.8
targetCompatibility = 1.8

dépendances {
implémentation "joda-time:joda-time:2.2"
testImplementation "junit:junit:4.12"
}COPY
Une dépendance est déclarée en utilisant le bloc de dépendances pour Joda
Time. Spécifiquement, vous voulez la version 2.2 de joda-time dans le
groupe joda-time.
Il s'agit d'une dépendance de compilation, ce qui signifie qu'elle doit être
présente au moment de la compilation. Les autres types de dépendances
notables sont les suivants :

l'implémentation - il s'agit des dépendances nécessaires à la

compilation du code, mais un conteneur qui exécute le code,
 tel que l'API Servlet Java, les fournit au moment de
l'exécution.
testImplementation - il s'agit des dépendances nécessaires à
la compilation et à l'exécution des tests, mais qui ne sont pas
nécessaires à la construction ou à l'exécution du code
d'exécution.
Enfin, nous devons nommer l'artefact JAR :
pot {
archiveBaseName = 'gs-gradle'
archiveVersion = '0.1.0'
}COPY
Ce bloc spécifie le nom du fichier JAR. Dans notre cas, [Link]
sera rendu.
Exécutez gradle build maintenant, et la dépendance Joda Time sera résolue
à partir du dépôt central, fournissant un build réussi.
Septième étape
La dernière étape consiste à construire le projet à l'aide du Gradle Wrapper.
C'est la méthode préférée, et elle contient deux scripts - un script batch
Windows et un script shell OS X et Linux. Ce sont les scripts qui
permettent d'exécuter les constructions Gradle sans avoir besoin que Gradle
soit installé sur le système. Vous auriez dû l'ajouter à votre fichier de
construction à un moment donné, mais il est désormais intégré à Gradle, et
vous n'avez donc plus besoin de le faire. A la place, il suffit d'utiliser cette
commande :
$ gradle wrapper --gradle-version 6.0.1
Une fois cette opération terminée, de nouveaux fichiers
apparaissent. Les scripts à la racine du dossier, le jar du wrapper et
les fichiers de propriétés sont ajoutés à un nouveau dossier appelé
gradle/wrapper :
└─── <dossier du projet>
└
 └── gradlew
└── [Link]
└── gradle
└─── wrapper
└── [Link]
└── [Link]
Vous pouvez maintenant utiliser le Gradle Wrapper pour construire votre
projet. Il doit être ajouté au système de contrôle de version afin qu'il puisse
être construit de la même manière chaque fois que votre projet est cloné.
Vous pouvez l'utiliser de la même manière qu'une version installée de
Gradle. Maintenant, vous pouvez exécuter le script Wrapper, et la tâche de
construction sera exécutée, comme précédemment :
./gradlew build
Lorsque vous exécutez le wrapper pour la première fois pour une version
spécifique de Gradle, les binaires Gradle relatifs à cette version sont
téléchargés et mis en cache. Les fichiers du wrapper sont conçus de manière
à être intégrés au contrôle des sources, ce qui permet à quiconque de
construire le projet sans avoir à installer Gradle et à le configurer.
Votre code est maintenant construit, et vous pouvez voir les résultats ici :
construire
├─── classes
│ └─── principal
│ └─── Bonjour
│ ├─── [Link]
│ └── [Link]
├── dependency-cache
├─── libs

│└
 │ └── [Link]
└── tmp
└─── jar
└── [Link]
Les deux fichiers de classe, HelloWorld et Greeter, sont inclus, ainsi qu'un
fichier JAR :
jar tvf build/libs/[Link]
0 Fri May 30 16:02:32 CDT 2014 META-INF/
25 Fri May 30 16:02:32 CDT 2014 META-INF/[Link]
0 Fri May 30 16:02:32 CDT 2014 hello/
369 Fri May 30 16:02:32 CDT 2014 hello/[Link]
988 Fri May 30 16:02:32 CDT 2014 hello/[Link]
Notez que les fichiers de classe sont regroupés et que, bien que joda-time
ait été déclaré comme dépendance, la bibliothèque n'a pas été incluse. Vous
ne pouvez pas non plus exécuter le fichier JAR.
Comment faire fonctionner ce code ? En utilisant le plugin d'application
inclus dans Gradle. Il doit être ajouté au fichier [Link] :
appliquer le plugin : 'application'

mainClassName = '[Link]'
L'application peut maintenant être exécutée :
./gradlew run
:compileJava UP-TO-DATE
:processResources UP-TO-DATE
:classes UP-TO-DATE
:run
 L'heure locale actuelle est : 16:16:20.544
Bonjour à tous !

CONSTRUIRE AVEC SUCCÈS

Temps total : 3.798 secondes

Il faut un peu plus de réflexion pour regrouper les dépendances. Par
exemple, si un fichier WAR est construit, un format utilisé pour empaqueter
des dépendances tierces, nous pouvons utiliser le plugin WAR dans Gradle.
Si vous utilisez Spring Boot et que vous voulez que votre fichier JAR soit
exécutable, vous pouvez utiliser le plugin spring-boot-gradle. Gradle n'a pas
assez d'informations pour savoir ce qu'il faut choisir, mais nous devrions en
avoir assez pour commencer à utiliser Gradle.
Voici le fichier [Link] complet :
Pour conclure ce guide, voici le fichier [Link] terminé :
[Link]
appliquer le plugin : 'java'
appliquer le plugin : 'eclipse'
appliquer le plugin : 'application'

mainClassName = '[Link]'

// tag::repositories[]
dépôts {
mavenCentral()
}
// end::repositories[]

// tag::jar[]
 pot {
archiveBaseName = 'gs-gradle'
archiveVersion = '0.1.0'
}
// end::jar[]

// tag::dependencies[]
sourceCompatibility = 1.8
targetCompatibility = 1.8

dépendances {
implémentation "joda-time:joda-time:2.2"
testImplementation "junit:junit:4.12"
}
// end::dependencies[]

// tag::wrapper[]
// end::wrapper[]COPY
Félicitations, vous avez terminé ce tutoriel rapide sur l'utilisation de Gradle
pour construire vos projets Java.
Chapitre 6 : Java avec Hibernate
Ce chapitre vous présentera Hibernate avec Spring en construisant une
application d'inscription d'étudiants. Nous utiliserons également la base de
données MYSQL pour construire cette application simple qui collecte les
informations de l'utilisateur au cours du processus d'inscription, les
enregistre dans la base de données MYSQL et authentifie les détails au
moment de la connexion.
Première étape
La première étape consiste à utiliser un modèle Maven pour créer un
nouveau projet d'application web.
Ouvrez votre IDE et créez votre projet.
Utilisez le modèle maven-archetype-webapp pour le faire - vous pouvez
utiliser la chaîne 'webapp' pour filtrer le catalogue afin de trouver ceci
Assurez-vous que les valeurs correctes sont fournies pour ArtifactId et
GroupId.
Vous trouverez ci-dessous un exemple de structure utilisant [Link] et
Maven [Link].
Deuxième étape
Ensuite, [Link] doit être mis à jour pour supporter Hibernate ORM dans
Spring et, pour ce faire, vous devez ajouter ces dépendances au fichier
[Link] :

jstl, spring-webmvc et servlet-api - supporte Spring

mysql-connector-java - fournit un support MYSQL
spring-jdbc - fournit un accès aux données à l'aide de JDBC
Spring
spring-orm - fournit un accès aux données à l'aide de Spring
spring-data-jpa - fournit le support JPA
hibernate-validator et hibernate-entitymanager - supportent
Hibernate
jta - fournit un soutien aux transactions
Voici comment ajouter ces dépendances à votre fichier :
<dépendance>
<groupId>[Link]</groupId>
 <artifactId>spring-webmvc</artifactId>
<version>[Link]</version>
</dependency>
<dépendance>
<groupId>[Link]</groupId>
<artifactId>servlet-api</artifactId>
<version>2.5</version>
<scope>fourni</scope>
</dependency>
<dépendance>
<groupId>[Link]</groupId>
<artifactId>jstl</artifactId>
<version>1.2</version>
</dependency>
<dépendance>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.21</version>
</dependency>
<dépendance>
<groupId>[Link]</groupId>
<artifactId>hibernate-validator</artifactId>
<version>[Link]</version>
</dependency>
<dépendance>
<groupId>[Link]</groupId>
<artifactId>hibernate-entitymanager</artifactId>
<version>[Link]</version>
</dependency>
<dépendance>
<groupId>[Link]</groupId>
<artifactId>jta</artifactId>
<version>1.1</version>
</dependency>
<dépendance>
<groupId>[Link]</groupId>
<artifactId>spring-jdbc</artifactId>
<version>[Link]</version>
</dependency>
<dépendance>
<groupId>[Link]</groupId>
<artifactId>spring-orm</artifactId>
<version>[Link]</version>
</dependency>
<dépendance>
<groupId>[Link]</groupId>
<artifactId>spring-data-jpa</artifactId>
<version>[Link]</version>
 <exclusions>
<exclusion>
<groupId>[Link]</groupId>
<artifactId>spring-aop</artifactId>
</exclusion>
</exclusions>
</dependency>
Troisième étape
L'étape suivante consiste à modifier votre fichier [Link] pour qu'il
contienne les éléments suivants.
Ajoutez un servlet et indiquez l'emplacement du fichier de configuration du
servlet. Dans notre exemple, nous créons un fichier de configuration dans le
dossier WEB-INF/config de votre projet et nous l'appelons
[Link].
Ensuite, lorsqu'une URL correspondant au modèle d'URL est fournie par le
client, un mappage de servlet est invoqué pour mapper votre servlet
nouvellement créé.
Enfin, un ContextLoaderListener est nécessaire pour garantir l'intégration
de Spring à l'application et fournir les fichiers de contexte JPA
contextConfigLocation.
Voici comment procéder :
<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5"
xmlns= "[Link]
xmlns:xsi= "Votre organisation ou groupe/2001/XMLSchema-
instance"
xsi:schemaLocation="[Link]
[Link]
<servlet>
<servlet-name>studentHibernateServlet</servlet-name>
<servlet-
class>[Link]</servlet-
class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/config/[Link]</param-
value>
</init-param>
</servlet>

<servlet-mapping>
<servlet-name>studentHibernateServlet</servlet-name>
<url-pattern>*.html</url-pattern>
</servlet-mapping>

<contexte-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:/[Link]</param-value>
</context-param>

<listener>
<listener-
class>[Link]</li
stener-class>
</listener>
 <display-name>Archetype Created Web Application</display-
name>
</web-app>
Quatrième étape
Il faut maintenant créer un fichier de configuration Spring Bean dans le
dossier WEB-INF/config. Si vous utilisez Spring Tool Suite comme IDE,
activez les espaces de noms mvc et context.
Le fichier [Link] s'affiche et ressemble à ceci :
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="[Link]
xmlns:xsi= "Votre organisation ou groupe/2001/XMLSchema-
instance"
xmlns:context="[Link]
"
xmlns:mvc="[Link]
xsi:schemaLocation="[Link]
mvc [Link]
[Link]
[Link]
[Link]
[Link]
[Link]
[Link]">

</beans>
Une fois les espaces de noms activés, recherchez les balises <beans> et
</beans> et insérez le code suivant entre elles. Cela indique que
l'application est le paquet de base de l'analyse du composant contextuel et
qu'elle est axée sur les annotations :
<mvc:annotation-driven />

<context:component-scan base-package="[Link]"
/>
Pour trouver les fichiers jsp, ajoutez le bean Spring
InternalResourceViewResolver suivant :
<bean
class="[Link]
wResolver">
<property name="prefix" value="/WEB-INF/jsp/" />
<property name="suffix" value=".jsp" />
</bean>
Un bean doit également être inclus pour spécifier un fichier de propriétés.
Ce fichier stockera les propriétés et les messages personnalisés. La
configuration ci-dessous vous permet de créer le fichier de propriétés dans
le dossier /src/main/resources et de l'appeler [Link] :
<bean id="messageSource"
class="[Link]
ageSource">
<property name="basename" value="messages" />
</bean>
Cinquième étape
Ensuite, créez un fichier dans le dossier src/main/resources/META-INF et
appelez-le [Link]. Ce fichier définit l'unité de persistance requise
par JPA. Ajoutez le code ci-dessous à ce fichier, en définissant une unité de
persistance appelée punit :
<persistence xmlns="[Link]
 xmlns:xsi="Votre organisation ou groupe/2001/XMLSchema-
instance"
xsi:schemaLocation="{[Link]
{[Link]
version="2.0">

<persistence-unit name="punit">
</persistence-unit>

</persistence>
Sixième étape
Le fichier [Link] indique que vous devez créer un fichier dans le dossier
src/main/resources et l'appeler jpaContext. Ce fichier définit les
configurations relatives à Hibernate et à JPA.
Notez que tout fichier de projet Maven créé dans le dossier
src/main/resources est automatiquement ajouté au chemin de la classe par
Maven. Si vous utilisez Spring Tool Suite, activez les espaces de noms txt,
jpa et context.
Le contenu suivant est inséré dans votre nouveau fichier :
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="[Link]
xmlns:xsi="Votre organisation ou groupe/2001/XMLSchema-
instance"
xmlns:tx="[Link]
xmlns:context="[Link]
"
xmlns:jpa="[Link]
xsi:schemaLocation="[Link]
eans [Link]
 [Link]
[Link]
[Link]
[Link]
[Link]
[Link]
[Link]
[Link]
[Link]">

<bans>
Une fois les espaces de noms activés, le code suivant doit être inclus entre
les balises <beans> et /beans> - cela indique que l'application est un paquet
de base jpa repository scan et qu'elle est axée sur les annotations.
<context:annotation-config />

<jpa:repositories base-package="[Link]"
/>
Ensuite, le bean PersistenceAnnotationBeanPostProcesser doit être inclus.
Celui-ci traite les annotations du contexte de persistance et l'unité de
persistance et injecte les ressources liées à JPA.
<bean
class="[Link]
nBeanPostProcessor" />
Assurez-vous que le bean EntityManagerFactory est inclus pour lister toutes
les ressources et propriétés liées à JPA :
<bean id="entityManagerFactory"
class="[Link]
rFactoryBean">
<property name="persistenceUnitName" value="punit" />
 <property name="dataSource" ref="dataSource" />
<property name="jpaVendorAdapter">
<bean
class="[Link]
dapter">
<property name="showSql" value="true" />
</bean>
</property>
<property name="jpaPropertyMap">
<map>
<entry key="[Link]"
value="[Link].MySQL5InnoDBDialect" />
<entry key="[Link]" value="validate"
/>
<entry key="hibernate.format_sql" value="true" />
</map>
</property>
</bean>
Le bean de source de données doit également être inclus car c'est là que
nous spécifions les propriétés de la base de données MYSQL, telles que le
nom d'utilisateur, le mot de passe et l'URL. L'URL de connexion <in
connection url> doit être remplacée par l'URL de connexion réelle pour se
connecter à la base de données MYSQL et le nom d'utilisateur <include
username> et le mot de passe <include password> doivent être remplacés
par les valeurs réelles.
<bean id="dataSource"
class="[Link]
ource">
 <property name="driverClassName"
value="[Link]" />
<property name="url" value="jdbc:mysql//<include
connection url>:3306/studentEnrollment?
autoReconnect=true&createDatabaseIfNotExist=true&" />
<property name="username" value="<include username>" />
<property name="password" value="<include password>" />
</bean>
Enfin, le gestionnaire de transactions doit être inclus pour définir la portée
ou le contrôle des transactions :
<bean id="transactionManager"
class="[Link]">
<property name="entityManagerFactory"
ref="entityManagerFactory" />
</bean>
<tx:annotation-driven transaction-manager="transactionManager" />
Ceci complète la configuration longue du fichier [Link].
Septième étape
Créez maintenant un nouveau dossier dans WEB-INF et appelez-le jsp. Les
fichiers jsp seront créés ici, comme l'indique le fichier [Link] du
haricot InternalResourceViewResolver. Un autre nouveau fichier doit être
créé, nommé [Link]. Celui-ci obtiendra les informations suivantes :
Ensuite, un autre fichier doit être créé avec un formulaire de nom
d'utilisateur et de mot de passe - appelez-le [Link] :

Créez deux autres fichiers - [Link] et [Link] - pour indiquer les

tentatives de connexion réussies ou échouées. Ces pages ne servent qu'à
afficher le contenu, et non à effectuer un traitement réel.
Huitième étape
Nous devons maintenant créer des paquets dans le dossier src/main/java
pour ces classes - Model, Spring controller, Service et Repository. Votre
projet devrait ressembler à ceci après la création de ces packages :

Neuvième étape
Dans le paquetage appelé [Link], créez une classe
POJO (plain old Java object). Cette classe contiendra les détails de l'entité
du modèle de l'étudiant pendant le processus d'inscription. Faites de même
avec une autre classe POJO appelée StudentLogin - elle contient les détails
de la connexion de l'étudiant.
Dixième étape
Dans le même paquet, créez une classe d'interface et appelez-la
[Link] - elle prend en charge les opérations pour la base de
données du niveau référentiel.
L'application a besoin de deux méthodes d'interface : l'une pour enregistrer
les données d'inscription dans la base de données et l'autre pour vérifier les
données à partir de la base de données.
@Repository("studentRepository")
public interface StudentRepository extends
JpaRepository<Student, Long> {

@Query("select s from Student s where [Link] =

:userName")
 Student findByUserName(@Param("userName") String
userName) ;

}
L'implémentation d'Hibernate prend en charge la méthode save(), ce qui
signifie que nous n'avons pas besoin d'instructions SQL distinctes pour
insérer les données.
Onzième étape
Créez une autre classe dans le paquet [Link]. Il
s'agira d'une classe d'interface nommée [Link].
public interface StudentService {
L'étudiant sauve (l'étudiant) ;
booléen findByLogin(String userName, String password) ;
booléen findByUserName(String userName) ;
}
Nous avons maintenant besoin d'une autre classe POJO - implémentation du
niveau de service - appelée [Link] dans le même
paquetage. Cette classe contiendra la logique d'application permettant
d'enregistrer les détails ou de les vérifier à partir de la base de données.
@Service("studentService")
public class StudentServiceImpl implements StudentService {

@Autowired
private StudentRepository studentRepository ;

@Transactional
public Student save(Student student) {
return [Link](student) ;
 }

public boolean findByLogin(String userName, String password) {

Étudiant stud =
[Link](userName) ;

if(stud != null && [Link]().equals(password)) {

retourner vrai ;
}

retourner faux ;
}

public boolean findByUserName(String userName) {

Étudiant stud =
[Link](userName) ;

if(stud != null) {
retourner vrai ;
}

retourner faux ;
}

}
Douzième étape
Dans le paquetage [Link], créez une classe POJO -
Controller tier - appelée [Link]. La logique de routage de
l'application sera stockée ici pour déterminer si l'action de connexion ou
d'inscription est appelée.
@Contrôleur
@SessionAttributes("étudiant")
public class StudentController {

@Autowired
private StudentService studentService ;

@RequestMapping(value="/signup",
method=[Link])
public String signup(Model model) {
Étudiant étudiant = nouvel Étudiant() ;
[Link]("student", student) ;
retourner "signup" ;
}

@RequestMapping(value="/signup",
method=[Link])
public String signup(@Valid @ModelAttribute("student")
Student student, BindingResult result, Model model) {
if([Link]()) {
retourner "signup" ;
} else
if([Link]([Link]())) {
[Link]("message", "User Name exists. Try
another user name") ;
retourner "signup" ;
 } else {
[Link](student) ;
[Link]("message", "Saved student details") ;
return "redirect:[Link]" ;
}
}

@RequestMapping(value="/login",
method=[Link])
public String login(Model model) {
StudentLogin studentLogin = new StudentLogin() ;
[Link]("studentLogin", studentLogin) ;
retourner "login" ;
}

@RequestMapping(value="/login",
method=[Link])
public String login(@Valid @ModelAttribute("studentLogin")
StudentLogin, BindingResult result) {
if ([Link]()) {
retourner "login" ;
} else {
boolean found =
[Link]([Link](),
[Link]()) ;
if (found) {
retourner "succès" ;
 } else {
retourner "échec" ;
}
}

}
}
Treizième étape
Comme nous l'avons vu, nous utilisons l'annotation @valid lorsque nous
voulons que les paramètres d'entrée du formulaire soient validés (ceux qui
atteignent la méthode) et que le résultat soit stocké dans l'objet appelé
BindingResult. La validation de champs spécifiques nécessite des
annotations telles que @Size, @NotEmpty, @NotNull, etc. Ces annotations
se trouvent dans le validateur Hibernate.
Lorsque l'un de ces validateurs échoue, un message personnalisé s'affiche.
Le contenu de ce message est spécifié dans le fichier appelé
[Link]. Créez un nouveau fichier appelé [Link]
dans le dossier src/[Link] et entrez ce qui suit :
NotEmpty=Le champ ne peut pas être vide
NotNull=Le champ ne peut pas être vide

Email=L'adresse électronique n'est pas valide / bien formée

Passé=La date de naissance doit se situer dans le passé

Size={0} doit avoir une longueur comprise entre {2} et {1}

caractères
typeMismatch=Format non valide
Quatorzième étape
L'avant-dernière étape nécessite une connexion à la base de données
MYSQL pertinente pour l'application et la création d'un nouveau schéma de
base de données appelé studentEnrollment. Cette opération est réalisée à
l'aide de MySQL Workbench. Cela doit être fait parce que ce schéma a été
spécifié dans le bean dataSource du fichier [Link].
Une fois que vous avez créé cette table, créez une table dans le schéma de
la base de données et appelez-la "étudiant". Pour ce faire, utilisez
l'instruction CREATE TABLE suivante :
CREATE TABLE `student` (
`id` bigint(20) NOT NULL AUTO_INCREMENT,
`dateOfBirth` datetime NOT NULL,
`emailAddress` varchar(255) NOT NULL,
`firstName` varchar(255) NOT NULL,
`lastName` varchar(255) NOT NULL,
`password` varchar(8) NOT NULL,
`userName` varchar(20) NOT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=43 DEFAULT
CHARSET=latin1 ;
Quinzième étape
Votre projet a été construit et doit maintenant être déployé. Nous utiliserons
pour cela le serveur Tomcat 7. Exécutez-le localement en faisant un clic
droit sur le projet et en cliquant sur Run As (Exécuter sous), puis en
choisissant Run on Server (Exécuter sur le serveur).
Vous pouvez également le déployer à distance sur des serveurs natifs
prenant en charge Tomcat en cliquant avec le bouton droit de la souris sur le
projet et en sélectionnant Exporter en tant que fichier WAR. Copiez-le dans
/var/lib/tomcat7 et redémarrez le serveur Tomcat.
Chapitre 7 : Java avec Apache Struts
Nous sommes arrivés à notre dernier tutoriel, et celui-ci est de loin le plus
long et le plus complexe. Alors, installez-vous confortablement et
commençons à utiliser Apache Struts.
Exigences de Java
Struts 2 nécessite :

JSP 2.0 ou supérieur

Servlet API 2.4 ou supérieur
Java 7 ou supérieur
Première étape
Pour commencer à créer une application utilisant Apache Struts 2, nous
allons d'abord utiliser Maven pour créer une nouvelle application web afin
de gérer les dépendances des artefacts.
Ouvrez votre IDE Java et créez une application web. Appelez-la
basic_struts, en vous assurant qu'elle suit la structure de projet dictée par
Maven. Ajoutez le code suivant dans votre fichier [Link] :
<b>Construction>
<finalName>basic-struts</finalName>
</build>
L'exécution de l'application à l'aide de Maven nécessite le plugin Jetty
Maven dans votre fichier [Link], ajoutez donc le code suivant :
<b>Construction>
...
<plugins>
<plugin>
<groupId>[Link]</groupId>
 <artifactId>jetty-maven-plugin</artifactId>
<version>9.4.7.v20170914</version>
<configuration>
<webApp>
<contextPath>/${[Link]}</contextPath>
</webApp>
<stopKey>CTRL+C</stopKey>
<stopPort>8999</stopPort>
<scanIntervalSeconds>10</scanIntervalSeconds>
<scanTargets>
<scanTarget>src/main/webapp/WEB-
INF/[Link]</scanTarget>
</scanTargets>
</configuration>
</plugin>
</plugins>
</build>
L'utilisation de ce plugin vous permet d'utiliser mvn jetty:run pour lancer
l'application.
Deuxième étape
Ensuite, nous voulons donner à cette application un [Link]. Créez-le sous
src/main/webapp et appelez-le Basic Struts 2 Application - Welcome.
Ajoutez un titre h1 dans le corps du fichier qui dit Bienvenue à Struts 2 !
<!DOCTYPE html>
<%@ page language="java" contentType="text/html ;
charset=UTF-8" pageEncoding="UTF-8" %>
 <html>
<b>En-tête>
<meta charset="UTF-8">
<title>Application basique Struts 2 - Bienvenue</title>
</head>
<body>
<h1>Bienvenue à Struts 2!</h1>
</body>
</html>
Lancez maintenant l'application en utilisant mvn jetty:run.
Ouvrez votre navigateur web et tapez [Link]
struts/[Link] dans la ligne d'adresse - vous devriez voir quelque chose
comme ceci sur votre écran :

Troisième étape
Maintenant que nous savons que notre application web Java fonctionne,
nous pouvons ajouter les fichiers JAR à son chemin de classe. Nous
n'ajouterons que le minimum de fichiers nécessaires au framework struts 2.
Ainsi, dans votre fichier [Link], ajoutez le code ci-dessous - il s'agit d'un
nœud de dépendance :
 <dépendance>
<groupId>[Link]</groupId>
<artifactId>struts2-core</artifactId>
<version>${[Link]}</version>
</dependency>
Assurez-vous que ${[Link]} est remplacé par la version que vous
utilisez. Cela donne à Maven les fichiers JAR dont Struts2-core a besoin. Si
vous utilisez Struts 2.2.3 ou plus, il n'est pas nécessaire de spécifier un
nœud de dépendance distinct pour javassist.
Quatrième étape
Nous devons maintenant ajouter la journalisation, et nous utiliserons log4j2
pour nous permettre de voir ce qui se passe en dessous. Dans le dossier
src/main/resources, mettez en place une configuration log4j2 et ajoutez-y ce
qui suit :
<?xml version="1.0" encoding="UTF-8"?>
<Configuration>
<Appenders>
<Console name="STDOUT" target="SYSTEM_OUT">
<PatternLayout pattern="%d %-5p [%t] %C{2} (%F:%L)
- %m%n"/>
</Console>
</Appenders>
<Loggers>
<Logger name="[Link].xwork2"
level="debug"/>
<Logger name="[Link].struts2" level="debug"/>
<Root level="warn">
 <AppenderRef ref="STDOUT"/>
</Root>
</Loggers>
</Configuration>
Notez qu'ici, nous spécifions que la cible du journal est la console.
Ensuite, log4j2 a besoin d'un nœud de dépendance, donc ajoutez ce qui suit
à votre fichier [Link] :
<dépendance>
<groupId>[Link].log4j</groupId>
<artifactId>log4j-core</artifactId>
<version>${[Link]}</version>
</dependency>
<dépendance>
<groupId>[Link].log4j</groupId>
<artifactId>log4j-api</artifactId>
<version>${[Link]}</version>
</dependency>
Nous pouvons utiliser la dernière version de Log4j2 sans entrer en conflit
avec la version fournie par le framework en utilisant log4j-api et log4j-core.
Optionnellement, si vous utilisez maven bom (bill of materials) dans la
partie dependencyManagement de log4j2 et Struts, votre fichier [Link]
ressemblera à ce qui suit. En procédant de cette manière, il n'y a pas de
ligne de version pour tous les modules utilisés et tous les modules log4j-* et
struts2-* sont gérés de manière à ce qu'ils soient de la même version.
<propriétés>
<[Link]>UTF-
8</[Link]>
 <[Link]>UTF-
8</[Link]>
<[Link]>1.8</[Link]>

<[Link]>[Link]</[Link]>
<[Link]>2.10.0</[Link]>
</properties>

<dependencyManagement>
<dépendances>
<dépendance>
<groupId>[Link]</groupId>
<artifactId>struts2-bom</artifactId>
<version>${[Link]}</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<dépendance>
<groupId>[Link].log4j</groupId>
<artifactId>log4j-bom</artifactId>
<version>${[Link]}</version>
<scope>import</scope>
<type>pom</type>
</dependency>
</dépendances>
 </dependencyManagement>

<dépendances>
<!-- Struts 2 -->
<dépendance>
<groupId>[Link]</groupId>
<artifactId>struts2-core</artifactId>
</dependency>

<dépendance>
<groupId>[Link].log4j</groupId>
<artifactId>log4j-core</artifactId>
</dependency>
</dépendances>
Cinquième étape
Ensuite, il faut ajouter le filtre de servlet Struts 2, pour s'assurer que le
framework fonctionne correctement avec l'application web. Créez un fichier
[Link] sous src/main/webapp/WEB-INF et ajoutez la classe et le mapping
du filtre :
<?xml version="1.0" encoding="UTF-8"?>
<web-app id="WebApp_ID" version="2.4"
xmlns= "[Link]
xmlns:xsi="[Link]
instance"
xsi:schemaLocation="[Link]
[Link]
<display-name>Basic Struts2</display-name>
 <welcome-file-list>
<welcome-file>index</welcome-file>
</welcome-file-list>

<filtre>
<nom du filtre>struts2</filtre-name>
<filter-
class>[Link]
Filter</filter-class>
</filter>

<filter-mapping>
<nom du filtre>struts2</filtre-name>
<url-pattern>/*</url-pattern>
</filter-mapping>

</web-app>
Sixième étape
Nous voulons maintenant créer un fichier [Link]. Struts 2 utilise des
annotations ou des fichiers de configuration XML (dans certains cas, les
deux) pour spécifier les relations entre les classes Java, les URL et les pages
de visualisation. Nous aurons la configuration minimale requise pour notre
application, donc créez votre fichier sous src/main/resources et appelez-le
[Link]. Assurez-vous qu'il se trouve dans le chemin de classe racine de
l'application web et ajoutez ce qui suit :
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration
2.5//EN"
 "[Link]

<struts>

<constant name="[Link]" value="true" />

<package name="basicstruts2" extends="struts-default">

<action name="index">
<result>/[Link]</result>
</action>
</package>

</struts>
Ce fichier indique au framework que le navigateur doit être redirigé vers
[Link] lorsque l'URL se termine par [Link].
Septième étape
Nous pouvons maintenant créer notre application et l'exécuter.
Exécutez l'application web avec le plugin maven jetty en exécutant mvn
jetty:run.
Regardez la console, et vous devriez voir une liste de messages de
débogage vous indiquant que le framework a été inclus dans l'application
web.
Ouvrez votre navigateur web, tapez [Link]
struts/[Link], et vous devriez voir la même page que si vous aviez
ouvert [Link]
Regardez les messages du weblog dans la console et vous devriez en
trouver qui parlent de [Link] et de [Link] :
...
 2017-04-17 11:16:01,084 DEBUG [qtp1723848804-22]
[Link] ([Link]) -
Création d'un DefaultActionProxy pour l'espace de noms [/] et le
nom de l'action [index]
...
2017-04-17 11:16:01,172 DEBUG [qtp1723848804-22]
[Link] ([Link])
- Forwarding to location : /[Link]
...
Hello World avec Struts 2
Lorsque vous soumettez des formulaires HTML ou cliquez sur des liens
hypertextes dans les applications web Struts 2, les données saisies ne sont
pas envoyées vers une autre page du serveur, comme vous pourriez le
penser. Au lieu de cela, elle est dirigée vers une classe Java que vous avez
fournie. Ces classes Java sont connues sous le nom d'Actions, et lorsqu'une
action est déclenchée, une ressource est choisie par un Résultat pour
afficher la réponse. En général, la ressource est une page du serveur, mais il
peut aussi s'agir d'une fenêtre d'applet Java, d'une feuille de calcul Excel ou
d'un fichier PDF.
Disons que nous voulons un exemple "Hello World" montrant un message
de bienvenue. Pour ce faire, nous avons besoin de ce qui suit :

Mise en place d'une application web vide dans Struts

Créer le modèle - une classe qui stocke le message de
bienvenue
Créer la vue - une page serveur qui présente notre message
Créer le contrôleur - une classe d'action qui contrôle
l'interaction entre les vues, les utilisateurs et les modèles.
Créer un mapping [Link] pour relier la vue et la classe
Action.
La création de tous ces composants nous aide à diviser le flux de travail en
trois préoccupations :
 Voir
Modèle
Contrôleur
Cela permet de mieux gérer les applications au fur et à mesure qu'elles se
développent et deviennent plus complexes.
Commençons par un exemple de classe de modèle, d'action, de page de
serveur et de mappage.
Nous voulons modifier notre projet basic-struts en ajoutant ce qui suit :

Une classe de modèle dans laquelle notre message sera stocké

Une vue où notre message sera affiché
Une classe Action, qui sera notre contrôleur
Une configuration qui fait le lien entre les deux.
Première étape
Nous allons commencer par créer notre classe de modèle. Créez-la sous
src/[Link] et appelez-la MessageStore. Incluez la déclaration de
paquetage illustrée ci-dessous :
package [Link] ;

public class MessageStore {

private String message ;

public MessageStore() {
message = "Hello Struts User" ;
}

public String getMessage() {

message de retour ;
}
}
Notez que nous avons utilisé une méthode getter publique pour accéder à
l'attribut string du message privé.
Deuxième étape
Ensuite, nous pouvons créer notre classe Action, qui sera le contrôleur.
Cette classe répond aux actions de l'utilisateur - dans notre cas, lorsqu'un
lien HTML est cliqué et qu'une URL spécifique est envoyée au conteneur
Servlet. Au moins une des méthodes de la classe Action sera exécutée et un
résultat sous forme de chaîne sera renvoyé. En fonction des valeurs du
résultat, une page d'affichage est rendue - la nôtre sera [Link].
Créez la classe et ajoutez les instructions import et package suivantes :
package [Link] ;

import [Link] ;

import [Link] ;

public class HelloWorldAction extends ActionSupport {

private MessageStore messageStore ;

public String execute() {

messageStore = new MessageStore() ;

retour SUCCESS ;
}

public MessageStore getMessageStore() {

return messageStore ;
}
}
Le cadre crée un objet de la classe HelloWorldAction. La méthode execute
est appelée en réponse à une action de l'utilisateur - un clic sur le lien
hypertexte envoie au conteneur Servlet une URL spécifiée.
La méthode execute crée un objet de la classe MessageStore et renvoie une
chaîne constante indiquant SUCCESS.
Notez à nouveau que nous utilisons une méthode getter publique pour
accéder à l'objet MessageStore privé.
Troisième étape
Ensuite, une page serveur est nécessaire pour afficher notre message que
nous avons stocké dans la classe de modèle MessageStore. Créez une SP
dans src/main/webapp, appelez-la [Link] et ajoutez ce qui suit :
<!DOCTYPE html>
<%@ page language="java" contentType="text/html ;
charset=UTF-8" pageEncoding="UTF-8" %>
<%@ taglib prefix="s" uri="/struts-tags" %>
<html>
<b>En-tête>
<meta http-equiv="Content-Type" content="text/html ;
charset=UTF-8">
<title>Bonjour le monde!</title>
</head>
<body>
<h2><s:property value="[Link]" /></h2>
</body>
</html>
Notez la directive taglib. Elle informe le conteneur Servlet que des balises
Struts 2 sont utilisées sur la page. Chaque balise est précédée d'un s.
La balise >s:property> est utilisée pour afficher la valeur retournée. Pour ce
faire, elle appelle la méthode getMessageStore de la classe de contrôleur
HelloWorldAction. La méthode renvoie un objet MessageStore.
Lorsque nous ajoutons .message à la section de l'attribut de valeur
messageStore, le cadre Struts 2 est invité à appeler getMessage, une
méthode de l'objet MessageStore. Cette méthode renvoie une chaîne, qui est
ensuite affichée par <s:property>.
Nous reviendrons sur les balises dans la suite de ce chapitre.
Quatrième étape
L'étape suivante consiste à ajouter un mappage. Celui-ci relie le contrôleur
(classe HelloWorldAction), la vue ([Link]) et l'URL. Il permet au
framework de connaître le nom de la classe qui répondra à l'action, la
méthode de la classe qui sera exécutée et la vue qui sera rendue en fonction
du résultat de la chaîne renvoyée.
Votre fichier [Link], dans src/main/resources, dans le projet MVN, doit
être édité en ajoutant le mappage d'action. Le nœud d'action - action
name='hello" - doit être placé entre le nœud d'ouverture du paquet et le
nœud de fermeture, à la suite de name="index", qui est le mappage d'action.
Votre fichier devrait ressembler à ceci :
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts
Configuration 2.5//EN"
"[Link]
<struts>
<constant name="[Link]" value="true" />

<package name="basicstruts2" extends="struts-default">

<action name="index">
 <result>/[Link]</result>
</action>
<action name="hello"
class="[Link]"
method="execute">
<result name="success">/[Link]</result>
</action>
</package>
</struts>
Cinquième étape
Nous voulons ajouter une URL d'action à notre fichier [Link]. Cela
permettra à l'utilisateur de cliquer sur un lien, indiquant au framework que
la méthode d'exécution de la classe HelloWorldAction doit être exécutée, ce
qui affichera la vue [Link].
La première étape consiste à ajouter la directive taglib à la jsp (en haut) :
<%@ taglib prefix="s" uri="/struts-tags" %>
Ensuite, la balise p suivante doit être ajoutée après la balise h1 :
<p><a href="<s:url action='hello'/>">Bonjour le monde</a></p>
<p>.
Maintenant, [Link] devrait ressembler à ceci :
<!DOCTYPE html>
<%@ page language="java" contentType="text/html ;
charset=UTF-8" pageEncoding="UTF-8" %>
<%@ taglib prefix="s" uri="/struts-tags" %>
<html>
<b>En-tête>
 <meta http-equiv="Content-Type" content="text/html ;
charset=UTF-8">
<title>Application basique Struts 2 - Bienvenue</title>
</head>
<body>
<h1>Bienvenue à Struts 2!</h1>
<p><a href="<s:url action='hello'/>">Bonjour le monde</a>
</p><p>.
</body>
</html>
La balise url de Struts crée l'URL et lui attribue l'action hello. Cette action
est associée à la classe HelloWorldAction et à la méthode d'exécution de la
classe. Lorsque l'on clique sur l'URL, le framework exécute la méthode
execute. Il renvoie alors une chaîne de succès (constante SUCCESS), et la
vue [Link] est rendue.
Sixième étape
Exécutez votre application en utilisant mvn jetty:run. Ouvrez votre
navigateur et allez sur [Link] et
vous verrez quelque chose comme ceci sur votre écran :
Si vous cliquez sur le lien "Hello World", la page suivante devrait s'afficher
:

Comment fonctionne ce code ?

Le navigateur envoie au serveur web une demande pour l'URL

[Link]
Le conteneur recevra une requête du serveur web pour la
ressource [Link]. Conformément aux paramètres
[Link], le conteneur détermine que les requêtes sont
acheminées vers
[Link]
 lter - ce qui inclut toutes les requêtes *.action. Ce filtre est le
point d'entrée dans le cadre Struts.
Le cadre recherche alors un mappage d'action appelé "hello". Il
détermine que cela correspond à la classe HelloWorldAction,
et le cadre instancie cette action en appelant la méthode
execute.
Un objet MessageStore est créé par la méthode execute, et
SUCCESS (= "succès") est renvoyé. Le mappage d'action est
vérifié par le framework pour voir quelle page doit être
chargée si SUCCESS est renvoyé. Le framework indique au
conteneur qu'il doit afficher la réponse à la requête, c'est-à-dire
la ressource [Link].
Pendant le traitement de [Link], la <s:property
value="[Link]" /> appellera le getter de
HelloWorldAction, getMessageStore, suivi de l'objet
MessageStore, getMessage - getMessageStore renvoie cet
objet. La balise fusionnera la valeur de l'attribut message et la
réponse.
Enfin, le navigateur recevra une réponse en HTML pur.
Les exemples de codes d'application peuvent être téléchargés à partir de
[Link]
Utilisation des étiquettes
Vous trouverez l'exemple d'application et le code associé à l'adresse
suivante : [Link]
Après notre tutoriel HelloWorld, nous en venons aux balises. Les
dépendances de l'artefact continueront à être gérées par Maven, tout comme
la construction des fichiers .war.
Dans la section précédente, un lien hypertexte a été créé vers [Link] en
ajoutant une balise url à [Link]. Dans cette section, nous allons
approfondir la balise url et d'autres éléments.
Les applications web se distinguent des sites web classiques par le fait
qu'elles créent des réponses dynamiques. Les balises sont utilisées comme
un moyen facile de référencer des données dynamiques à partir d'une page
web. Certaines imitent les balises HTML standard, ajoutant de la valeur,
tandis que d'autres créent des contrôles utiles qui ne sont pas standard.
L'utilisation de ces balises sur la page d'affichage nécessite l'inclusion d'une
directive de bibliothèque de balises. La syntaxe de cette directive est
typiquement :
<%@ taglib prefix="s" uri="/struts-tags" %>
Cela signifie que toutes les balises Strut 2 auront un préfixe s.
Vous trouverez le fichier TLD de Struts 2 dans le dossier META-INF du jar
du noyau de Struts 2, si vous souhaitez le lire.
Tag url
Vous pouvez utiliser les balises Struts 2 lorsque vous souhaitez créer des
liens vers d'autres ressources web, notamment celles déjà présentes dans
l'application locale.
Le langage HTML propose une balise simple pour vous aider à créer des
liens hypertextes, mais cette balise nécessite généralement l'inclusion
d'informations redondantes. En outre, cette balise ne peut pas accéder très
facilement aux données dynamiques fournies par le cadre.
Alors que le HTML fournit une balise simple pour créer des liens
hypertextes, la balise HTML nous oblige souvent à inclure des informations
redondantes. En outre, la balise HTML ne permet pas d'accéder facilement
aux données dynamiques fournies par le cadre.
L'une des utilisations les plus courantes dans les applications web consiste à
créer un lien vers une autre page. Dans notre précédent tutoriel, Hello
World, un lien a été ajouté à [Link] dans [Link] - nous avons utilisé
une balise url pour ce faire.
<!DOCTYPE html>
<%@ page language="java" contentType="text/html ;
charset=UTF-8" pageEncoding="UTF-8" %>
<%@ taglib prefix="s" uri="/struts-tags" %>
<html>
 <b>En-tête>
<meta http-equiv="Content-Type" content="text/html ;
charset=UTF-8">
<title>Application basique Struts 2 - Bienvenue</title>
</head>
<body>
<h1>Bienvenue à Struts 2!</h1>
<p><a href="<s:url action='hello'/>">Bonjour le monde</a>
</p><p>.
</body>
</html>
Si vous l'exécutez dans le conteneur Servlet et que vous passez la souris sur
le lien hypertexte créé par la balise (Hello World), vous verrez l'URL créée
sous la forme [Link]. Il s'agit du dossier racine du contexte web.
Regardez le fichier [Link] dans ce tutoriel, et vous verrez ce qui suit :
...
<action name="hello"
class="[Link]"
method="execute">
<result name="success">/[Link]</result>
</action>
...
Il s'agit d'un nœud d'action qui associe [Link] à la méthode execute de
la classe HelloWorldAction. Si la valeur renvoyée est "success",
[Link] (la vue, qui se trouve dans le dossier racine) est renvoyée à
l'utilisateur.
Un cas d'utilisation très courant est celui de l'URL qui a besoin d'une valeur
pour un paramètre de chaîne de requête, c'est-à-dire userName. La balise
param de Struts 2 ajoute le paramètre avec sa valeur à l'intérieur de la balise
url.
Ajoutez le code suivant à votre fichier [Link] - placez-le après le lien
Hello World.
...
<s:url action="hello" var="helloLink">
<s:param name="userName">Bruce Phillips</s:param>
</s:url>

</p><a href="${helloLink}">Bonjour Bruce Phillips</a></p><a

href="${helloLink}">Bonjour Bruce Phillips</a>.
...
Au lieu d'utiliser la balise url comme valeur de l'attribut href dans la balise
anchor, la balise s:url est séparée dans son propre bloc de code. La balise
param est imbriquée dans la balise url. La balise param permet de spécifier
un nom de paramètre, par exemple userName, ainsi qu'une valeur - dans
notre cas, cette valeur est Bruce Phillips.
Notez que nous avons utilisé l'attribut var, la valeur if, qui est une référence
qui peut être utilisée pour se référer à notre url créée.
Examinez la balise d'ancrage ci-dessus. Notez que l'attribut href a pour
valeur ${helloLink}. La page affichée est un substitut au lien hypertexte
créé à l'aide de la balise url de référence ${helloLink}. Nous veillerons à ce
que le paramètre de la chaîne de requête soit encodé dans l'URL, comme il
se doit.
Ensuite, nous verrons comment utiliser Struts pour accéder à la valeur du
paramètre.
Étiquette de formulaire
Vous trouverez l'exemple d'application et le code associé à l'adresse
suivante : [Link]
De nos jours, la plupart des applications web comportent plusieurs
formulaires de saisie de données, et l'utilisation de balises facilite la
création de formulaires de saisie. Chaque balise de formulaire dans Struts 2
possède plusieurs attributs, ce qui leur permet d'imiter les attributs des
balises HTML standard.
Nous utiliserons la balise form pour créer l'enveloppe extérieure de notre
formulaire. Le nom de l'action sera défini pour soumettre à l'aide de
l'attribut action.
Ajoutez le code après le lien vers Hello Bruce Phillips dans le fichier
[Link].
</p> <p>Obtenez votre bonjour personnel en remplissant et en
envoyant ce formulaire.

<s:form action="hello">
<s:textfield name="userName" label="Votre nom" />
<s:submit value="Submit" />
</s:form>
Nous utilisons la balise textfield pour nous donner une balise HTML
d'entrée du texte de la balise, et nous obtenons un bouton Submit à l'aide de
la balise submit. Lorsque le serveur renvoie la page d'index, vous devriez
voir ce qui suit - open [Link] :
Les balises submit, textfield et form ont été converties en HTML :
<form id="hello" name="hello" action="/using-
tags/[Link];jsessionid=6233ot11na1mtshbr292hu1w"
method="post">
<table class="wwFormTable">
<tr>
<td class="tdLabel"><label for="hello_userName"
class="label">Votre nom:</label></td>.
<td class="tdInput"><input type="text" name="userName"
value="" id="hello_userName"/></td>
</tr>
<tr>
 <td colspan="2">
<div class="formButton">
<input type="submit" value="Submit" id="hello_0"/>
</div>
</td>
</tr>
</tableau>
</form>
Un tableau a été créé dans le formulaire par Struts 2, ce qui nous aide à
placer les éléments du formulaire dans la bonne position. La balise textfield
nous a fourni une balise d'entrée HTML de type texte ; la valeur name
correspond à la valeur name de la balise textfield. Nous avons également
obtenu une balise HTML label basée sur la valeur label de la balise
textfield.
Ensuite, nous examinerons le traitement de la soumission du formulaire à
l'aide de Struts 2.
étiquette de propriété
Vous trouverez l'exemple d'application et le code associé à l'adresse
suivante : [Link]
Dans notre exemple d'application, vous trouverez ce code :
<s:property value="[Link]" />
L'utilisation la plus courante de la balise property est l'obtention d'une
valeur renvoyée. La méthode publique get de la classe Action est appelée et
la valeur est ajoutée au code HTML renvoyé au navigateur.
La valeur [Link] indique à Struts 2 d'appeler la méthode
getMessageStore de la classe Action, et un objet MessageStore est renvoyé.
La section .message indique à Struts 2 que la méthode getMessage de l'objet
MessageStore doit être appelée. Une chaîne est renvoyée et elle est incluse
dans le code HTML renvoyé au navigateur.
La balise property présente une caractéristique utile : elle convertit
automatiquement les types de données courants, tels que booléen, double,
int, etc., en leurs équivalents sous forme de chaînes de caractères.
Démontrons-le en plaçant une variable statique int dans notre classe
HelloWorldAction :
private static int helloCount = 0 ;
public int getHelloCount() {
return helloCount ;
}
Chaque fois que nous appelons la méthode execute, helloCount est
augmenté de 1. Ajoutez le code suivant à la méthode execute de la classe
HelloWorldAction.
helloCount++ ;
Chaque fois qu'un lien est cliqué sur la page [Link] ou qu'un formulaire
est soumis, la méthode execute de la classe HelloWorldAction est exécutée
et le champ statique helloCount augmente de 1.
La balise property peut être utilisée pour ajouter la valeur de l'attribut
helloCount à [Link] en ajoutant le code ci-dessous après la balise
h2 :
<p>J'ai dit bonjour <s:property value="helloCount" /> plusieurs
fois!</p>
Bien que la méthode getHelloCount renvoie un nombre entier, elle a été
convertie en chaîne de caractères et ajoutée au corps de la balise p.
Bien que helloCount soit statique, sa méthode get ne l'est pas, car la
méthode getHelloCount doit être dynamique pour renvoyer la valeur
helloCount.
Si la méthode get renvoie un objet, la balise property garantit que Struts 2
appelle la méthode toString de cet objet. La méthode toString de la classe
Object doit toujours être surchargée dans les classes de modèle.
Le code suivant doit être ajouté à la méthode toString de la classe
MessageStore :
public String toString() {
return message + " (from toString)" ;
}
Et ce qui suit doit aller dans [Link] :
<p><s:property value="messageStore" /></p><s:property
value="messageStore" /></p><s:property
Étant donné que la méthode getMessageStore de la classe
HelloWorldAction renvoie un objet MessageStore, la méthode string de la
classe MessageStore est appelée. La chaîne renvoyée est affichée dans votre
navigateur, comme ci-dessous :

Actions de codage
Vous trouverez l'exemple d'application et le code associé à l'adresse
suivante : [Link]
Nous pouvons maintenant passer au codage des actions Struts, qui
comprend trois parties :

Mappage des actions aux classes

Cartographier les résultats en fonction des vues
Ajouter la logique du contrôleur à la classe Action
Nous avons déjà abordé la question du mappage des URL, comme
[Link], vers les classes d'action, comme HelloWorldAction.
<action name="hello"
class="[Link]"
method="execute">
<result name="success">/[Link]</result>
</action>
Ce mappage d'action spécifie que, si la méthode d'exécution de l'action
HelloWorld renvoie un "succès", la page [Link] sera affichée dans
le navigateur.
Dans cette partie du tutoriel, nous verrons comment écrire la logique du
contrôleur dans notre classe Action.
Classes d'action
Dans le modèle MVC, une classe Action joue le rôle de contrôleur. Ces
classes répondent aux actions de l'utilisateur, appellent d'autres classes ou
exécutent elles-mêmes la logique commerciale, et renvoient des résultats
indiquant à Struts ce qui doit être rendu.
Les classes d'action sont utilisées pour étendre la classe ActionSupport
fournie par le cadre, qui, à son tour, fournit les implémentations par défaut
pour des actions telles que l'entrée et l'exécution. Elle implémente
également un certain nombre d'interfaces. Lorsque la classe ActionSupport
est étendue par la classe Action, cette dernière peut faire l'une des deux
choses suivantes : remplacer les implémentations par défaut ou en hériter.
Regardez votre classe HelloWorldAction du tutoriel sur les balises, et vous
devriez voir que la classe étend la classe ActionSupport et surcharge la
méthode execute.
La méthode execute est l'endroit où nous spécifions ce que le contrôleur
doit faire en réponse à [Link].
public String execute() throws Exception {
messageStore = new MessageStore() ;

helloCount++ ;

retour SUCCESS ;
}
Traitement des formulaires d'entrée
La classe Action a plusieurs responsabilités, mais l'une d'entre elles consiste
à traiter les données saisies par l'utilisateur dans les formulaires et à
permettre à la page de visualisation d'accéder aux résultats du traitement.
Nous pouvons illustrer cela en affichant un message personnel sur la page
de visualisation [Link].
Nous avons déjà ajouté un formulaire à [Link] dans la section tags :
<s:form action="hello">
<s:textfield name="userName" label="Votre nom" />
<s:submit value="Submit" />
</s:form>
Notez la valeur de l'attribut name pour la balise textfield appelée userName.
Lorsque l'on clique sur le bouton Submit de ce formulaire, [Link] est
exécuté. Les valeurs des champs du formulaire sont envoyées à
HelloWorldAction - à condition qu'une méthode set publique soit définie,
correspondant à la valeur du nom du champ du formulaire, la classe Action
peut obtenir ces valeurs automatiquement.
Dans ce cas, la méthode publique setUserName doit être définie dans
HelloWorldAction pour que la classe reçoive automatiquement la valeur
userName.
Ajoutez le code ci-dessous à votre classe HelloWorldAction :
private String userName ;

public String getUserName() {

return userName ;
}

public void setUserName(String userName) {

[Link] = userName ;
}
Le message MessageStore peut être personnalisé en ajoutant le code ci-
dessous à la méthode execute de HelloWorldAction. Il doit être placé après
la déclaration d'instanciation de l'objet MessageStore :
if (userName != null) {
[Link]( [Link]() + " " +
userName) ;
}
Construisez l'application et exécutez-la en utilisant mvn jetty:run. Saisissez
votre nom dans le formulaire et cliquez sur Submit - vous devriez voir
quelque chose de similaire à ceci, mais avec votre nom :
Lors de la soumission du formulaire, les méthodes set de la classe
HelloWorldAction sont appelées à condition qu'elles correspondent aux
noms des champs du formulaire. Dans notre exemple, nous avons appelé la
méthode setUserName et transmis la valeur du champ du formulaire intitulé
username.
Dans notre fichier [Link], un lien d'action est inclus avec un paramètre de
chaîne de requête de nom d'utilisateur=Bruce+Phillips. Cliquez sur ce lien
et vous devriez voir apparaître ceci :
Étant donné que nous avons défini le paramètre de la chaîne de requête
comme étant userName, la valeur de ce paramètre est transmise à
setUserName.
Sur la page de visualisation [Link], la valeur userName est
également accessible via la balise property.
Cette section vous a montré comment la classe Action pouvait être codée
pour traiter les entrées des formulaires ou les valeurs des paramètres des
chaînes de requête. Si le formulaire comporte de nombreux champs, il serait
difficile d'avoir des méthodes set pour chaque champ. C'est pourquoi, dans
la prochaine section, nous verrons comment intégrer les classes de modèles,
les champs de formulaires de visualisation et le traitement des formulaires
dans la classe Action.
Traitement des formulaires
Vous trouverez l'exemple d'application et le code associé à l'adresse
suivante : [Link]
Suite à la dernière section, vous devriez maintenant avoir un projet coding-
actions qui fonctionne. Nous allons maintenant voir comment utiliser Struts
2 pour aller plus loin dans le traitement des soumissions de formulaires.
Nous verrons comment utiliser les classes de modèles Java pour stocker les
données des formulaires et comment créer un formulaire Struts 2
correspondant à la classe de modèle.
Nous pouvons ajouter le code de cette section à notre exemple d'actions.
Formulaires et classes de modèles Java
Supposons que nous voulions un formulaire qu'un utilisateur puisse
soumettre pour s'inscrire à un tirage au sort. Les règles de gestion nous
indiquent que l'utilisateur doit fournir des informations spécifiques, à savoir
:

Prénom
Nom de famille
Adresse électronique
 L'âge
Une classe Java sera utilisée pour encapsuler les données, en s'assurant que
chaque champ d'instance possède des méthodes publiques get et set.
Ajoutez ce qui suit à votre [Link], créé dans la
section Actions de ce tutoriel.
public class Person {
private String firstName ;
private String lastName ;
private String email ;
private int age ;

public String getFirstName() {

return prénom ;
}

public void setFirstName(String firstName) {

[Link] = firstName ;
}

public String getLastName() {

return lastName ;
}

public void setLastName(String lastName) {

[Link] = lastName ;
}

public String getEmail() {

 retour d'email ;
}

public void setEmail(String email) {

[Link] = email ;
}

public int getAge() {

retourner l'âge ;
}

public void setAge(int age) {

[Link] = age ;
}

public String toString() {

return "Prénom : " + getFirstName() + " Last Name : " +
getLastName() +
"Email : " + getEmail() + " Age : " + getAge() ;
}
}
Il y a plusieurs choses à noter à propos de cette classe :

Chaque champ d'instance possède une méthode publique get et

set
L'attribut age est un nombre entier
Une méthode publique toString est définie pour renvoyer une
chaîne de caractères représentant l'état de l'objet.
 Comme aucun constructeur n'a été spécifié, Java en fournit un
par défaut pour donner aux champs d'instance des valeurs
nulles.
Structure du formulaire
Les informations ci-dessus peuvent être collectées à l'aide d'un formulaire
Struts 2. Lorsque ce formulaire est créé, nous devons nous assurer que
chaque champ du formulaire est lié à un champ d'instance particulier. Ces
champs d'instance seront de type Personne.
Regardez le formulaire et nous parlerons ensuite de son contenu.
La première chose à faire est de créer une page de vue dans
src/main/webapp et de l'appeler [Link] :
<%@ taglib prefix="s" uri="/struts-tags" %>
<%@ page language="java" contentType="text/html ;
charset=UTF-8" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<b>En-tête>
<meta http-equiv="Content-Type" content="text/html ;
charset=UTF-8" />
<title>Enregistrer</title>
</head>
<body>
<h3>Enregistrez-vous pour un prix en remplissant ce
formulaire.</h3>

<s:form action="register">
<s:textfield name="[Link]" label="Prénom" />
 <s:textfield name="[Link]" label="Nom de
famille" />
<s:textfield name="[Link]" label ="Email"/>
<s:textfield name="[Link]" label="Age" />
<s:submit/>
</s:form>
</body>
</html>
Nous devons ajouter la déclaration de la bibliothèque de balises en haut de
la page, car nous utiliserons les balises Struts 2.
Le formulaire est soumis à une action appelée register, qui doit également
être définie dans [Link].
Notez qu'il y a des balises de champ de texte. Chacune a une valeur de nom
avec un attribut de classe Person, c'est-à-dire firstName. La valeur de
l'attribut name fait également référence à un objet nommé personBean, qui
est de type Person. Lorsque la classe Action est créée pour gérer la
soumission du formulaire, nous devons spécifier l'objet dans la classe
Action.
La valeur du nom complet est [Link], ce qui indique à
Struts 2 que la valeur d'entrée du champ de texte doit être utilisée comme
argument personBean.
Nous avons également un champ de texte pour chacun des champs
d'instance de la classe Person. N'oubliez pas que l'attribut age de la classe
Person est un entier. Les valeurs des champs de formulaire sont des chaînes,
et Struts 2 convertit la valeur de la chaîne saisie dans le champ de
formulaire âge en un entier lorsque la méthode setAge est appelée à partir
de l'objet personBean.
Création de classes d'action pour gérer l'envoi de formulaires
Lorsque l'on clique sur le bouton Submit, deux choses sont envoyées au
framework Struts 2 : l'action "register" et les données du formulaire.
N'oubliez pas que dans notre tutoriel sur les actions, la classe Action étend
la classe ActionSupport.
Placez la classe suivante dans le paquet [Link] :
package [Link] ;

import [Link] ;
import [Link] ;

public class Register extends ActionSupport {

private static final long serialVersionUID = 1L ;

private Person personBean ;

public String execute() throws Exception {

/Appeler la classe Service pour stocker l'état du personBean
dans la base de données

retour SUCCESS ;
}

public Person getPersonBean() {

return personBean ;
}

public void setPersonBean(Person person) {

personBean = person ;
}
 }
Un attribut a été déclaré dans la classe Register appelée personBean. Il
s'agit d'un attribut de type personne, et l'objet possède une méthode
publique set et get.
La classe Register surchargera la méthode execute, qui est spécifiée dans
[Link] pour être appelée lorsqu'il y a une action register. Dans notre cas,
la méthode execute renverra une constante de chaîne SUCCESS, héritée
d'ActionSupport. Si nous construisions une application réelle, nous
pourrions appeler d'autres classes dans la méthode execute, comme les
objets Service, et leur demander d'effectuer le traitement commercial du
formulaire, c'est-à-dire de stocker les données de l'utilisateur dans le
référentiel de données.
L'objet personBean déclaré dans la classe d'action appelée Register
correspond au nom du personBean utilisé dans les champs de texte. Le
framework examine la classe Action et recherche un objet personBean lors
de la soumission du formulaire. Le constructeur par défaut de la classe
Person crée l'objet. Ensuite, la méthode publique set du personBean est
appelée pour chaque champ du formulaire avec une valeur de nom
[Link] et les données de l'utilisateur sont transmises à la
méthode. Tout cela se produit avant que la méthode execute ne puisse faire
son travail.
Lorsque la méthode d'exécution de la classe Register est exécutée, son objet
personBean aura des valeurs pour les champs d'instance où les valeurs sont
égales à celles saisies par l'utilisateur dans les champs de formulaire
correspondants.
Comme nous utilisons une classe de modèle Java pour encapsuler les
données du formulaire, il n'est pas nécessaire d'avoir un attribut séparé
contenant des méthodes publiques get et set pour chaque champ du
formulaire dans la classe d'action appelée Register.
Ajouter la vue pour le résultat
Lorsque la méthode execute renvoie SUCCESS, nous voulons qu'une page
de remerciement s'affiche pour montrer l'enregistrement de l'utilisateur.
Créez le fichier dans src/main/webapp et appelez-le [Link]. Ajoutez
le code suivant :
<%@ taglib prefix="s" uri="/struts-tags" %>
<%@ page language="java" contentType="text/html ;
charset=UTF-8" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<b>En-tête>
<meta http-equiv="Content-Type" content="text/html ;
charset=UTF-8" />
<title>Inscription réussie</title>
</head>
<body>
<h3>Merci de vous inscrire pour un prix.</h3>

<p>Vos informations d'enregistrement : <s:property

value="personBean" /> </p> <p>Il n'y a pas d'informations
d'enregistrement.

</p><a href="<s:url action='index' />" >Retour à la page

d'accueil</a>.</p><a href="<s:url action='index' />" >Retour à la
page d'accueil</a>.
</body>
</html>
Créer un mappage d'actions dans [Link]
Nous voulons qu'une relation soit spécifiée entre la page de soumission du
formulaire, la page de visualisation du succès et la classe Action. Pour ce
faire, nous devons inclure un nœud d'action dans notre fichier [Link].
Ajoutez le code suivant à votre fichier entre l'action help et le nœud de
fermeture du package :
<action name="register"
class="[Link]"
method="execute">
<result name="success">/[Link]</result>
</action>
Cette action informe Struts 2 que la méthode execute de la classe Register
doit être appelée lorsque l'action register est donnée. Si le résultat renvoyé
est "success", la vue [Link] est affichée dans le navigateur.
Nous n'avons pas besoin de donner à Struts des informations sur le
traitement du formulaire. Les valeurs des champs du formulaire sont
transférées automatiquement à l'objet personBean, tant que la convention de
nommage est respectée pour que les champs du formulaire correspondent
au [Link].
Créez un nouveau lien vers [Link], afin que l'utilisateur trouve la bonne
page d'enregistrement. Pour ce faire, ajoutez le lien suivant à votre fichier
[Link] :
<p><a href="[Link]">Veuillez vous inscrire</a> pour notre
tirage au sort.</p><a href="[Link]">Veuillez vous inscrire</a>
pour notre tirage au sort.
Si vous avez tout fait correctement, vous pouvez utiliser mvn jetty:run pour
lancer votre application. Ouvrez [Link]
processing/[Link] et vous devriez voir une encre d'enregistrement.
Cliquez dessus et quelque chose comme ce qui suit apparaîtra :
Complétez le formulaire avec vos propres données et cliquez sur Soumettre.
Vous verrez alors la page suivante, mais avec vos données personnelles.

Validation du formulaire
Vous trouverez l'exemple d'application et le code associé à l'adresse
suivante : [Link]
Cette partie du tutoriel examine comment valider les entrées de l'utilisateur
dans les formulaires en utilisant Struts 2. Vous pouvez valider les
formulaires de deux manières avec Struts 2, mais nous nous concentrerons
sur la méthode de base pour les besoins de ce tutoriel, une méthode dans
laquelle la classe Action inclut la validation.
Ajouter la méthode de validation
La seule façon pour la classe Action de valider la saisie de l'utilisateur sur
les formulaires Struts 2 est de définir une méthode de validation dans la
classe Action. Nous utiliserons le code de la section Traitement des
formulaires et supposerons que nous avons les règles de gestion suivantes :
L'utilisateur :

Doit fournir un prénom

Vous devez fournir une adresse électronique valide
Il faut être âgé de 18 ans ou plus pour s'inscrire
Si vous vous souvenez de la section précédente, Struts 2 place les entrées de
l'utilisateur provenant des champs du formulaire dans personBean, la classe
de modèle Java. Ainsi, tout ce que l'utilisateur inscrit dans le champ
firstName deviendra la valeur de l'instance firstName du personBean - cela
se produit par le biais de la méthode appelée [Link].
La méthode validate nous permet d'utiliser les bonnes méthodes get pour
obtenir les valeurs des champs d'instance du personBean. Une fois les
valeurs obtenues, la logique peut être utilisée pour appliquer les règles de
gestion susmentionnées.
Ajoutez une méthode de validation à la classe Action appelée [Link]
et insérez-y le code suivant :
public void validate(){
if ([Link]().length() == 0) {
addFieldError("[Link]", "Le prénom est
obligatoire") ;
}

if ([Link]().length() == 0) {
addFieldError("[Link]", "Email is required.") ;
}

if ([Link]() < 18) {

 addFieldError("[Link]", "Age is required and must
be 18 or older") ;
}
}
Lorsque l'on appuie sur le bouton "submit" du formulaire d'inscription, les
données saisies par l'utilisateur sont transférées par Struts 2 dans les champs
d'instance de personBeans. La méthode validate est ensuite
automatiquement exécutée. Si une instruction if renvoie un résultat positif,
la méthode addFieldError de cette instruction est appelée - lorsque la classe
Action étend ActionSupport, elle hérite de cette méthode.
Si des erreurs ont été ajoutées, la méthode execute ne sera pas appelée. Au
lieu de cela, l'entrée est renvoyée en tant que résultat lorsque l'action est
appelée.
Traiter les données renvoyées
Que se passe-t-il lorsque le formulaire est renvoyé ? Cela indique que
l'utilisateur a saisi des informations non valides et, la plupart du temps, nous
voulons que la page web contenant le formulaire s'affiche à nouveau, avec
un message d'erreur pour indiquer à l'utilisateur ce qui n'a pas fonctionné.
La valeur de retour de l'entrée est gérée en ajoutant le résultat ci-dessous au
nœud d'action [Link] :
<result name="input">/[Link]</result>
Veillez à le placer après le nœud de résultat de l'action d'enregistrement,
avant que le nœud d'action ne soit fermé.
Messages d'erreur
Lorsque la validation a échoué et que Struts 2 renvoie des données,
[Link] est réaffiché par le framework. Comme des balises de formulaire
ont été utilisées, les messages d'erreur sont automatiquement ajoutés. Ceux-
ci sont spécifiés dans l'appel à la méthode addFieldError, qui prend deux
arguments : le nom du champ du formulaire concerné par l'erreur et le
message d'erreur, qui doit s'afficher au-dessus du champ ferme.
Cet appel à la méthode addFieldError :
addFieldError("[Link]", "Le prénom est
obligatoire")
provoque l'affichage d'un message du type "First name is required" au-
dessus du champ firstName du formulaire.
Apportez les modifications susmentionnées au code de votre didacticiel sur
les formulaires de traitement et exécutez l'application. Cliquez sur le lien
"Veuillez vous inscrire" et cliquez sur "Soumettre" dans le formulaire
d'inscription. Vous devriez voir quelque chose comme ceci :

La méthode validate a été appelée et la validation a échoué. Le fichier

[Link] contenant les messages d'erreur pertinents s'est affiché.
Style des messages d'erreur
Nous pouvons fournir du CSS en utilisant la balise s:head. Cela inclut un
style que nous pouvons utiliser pour le message d'erreur. Ajoutez la balise
<s:head /> juste avant la fermeture de la balise HTML </head>. Exécutez
l'application, suivez les étapes ci-dessus pour soumettre le formulaire, et
vous devriez voir quelque chose comme ceci :

Fichiers de ressources de messages

Vous trouverez l'exemple d'application et le code associé à l'adresse
suivante : [Link]
Vous devez avoir complété la section sur la validation des formulaires et
avoir mis en place un projet de validation des formulaires.
Nous allons examiner les capacités des ressources de message dans Struts 2,
également connues sous le nom de "resource bundles". Elles nous
permettent de placer du texte dans une page de vue, de l'afficher dans
l'ensemble de l'application, de changer la langue du texte en fonction de
l'endroit où se trouve l'utilisateur et de créer des étiquettes pour les champs
de formulaire.
Dans les applications web construites à l'aide de Struts 2, les fichiers de
propriétés des ressources de messages peuvent être associés aux classes
d'action. Pour ce faire, il faut créer des fichiers de propriétés dont les noms
correspondent à ceux des classes d'action et utiliser l'extension .properties.
Les fichiers de propriétés et les classes d'action doivent se trouver dans le
même paquetage.
Pour ce tutoriel, nous supposerons que nous voulons que les étiquettes des
champs du formulaire se trouvent dans un fichier séparé. Ainsi, nous
pourrons les modifier à notre guise et les afficher dans différentes langues.
Les modifications de cette section peuvent être apportées à votre exemple
de validation de formulaire.
Créez un fichier sous src/main/resources dans le paquetage
[Link], appelez-le [Link], et ajoutez le
texte suivant :
[Link]=Prénom
[Link]=Nom de famille
[Link]=Age
[Link]=Email
thankyou=Merci d'avoir enregistré %{[Link]}.
Ce n'est rien d'autre qu'un fichier de propriétés Java standard. La clé est
indiquée à gauche du signe = et la valeur à droite. Après l'exécution de
Register, le nom de la clé peut être référencé pour mettre les propriétés à la
disposition de la page de visualisation.
Attribut clé
L'attribut key est utilisé dans la balise textfield pour indiquer au framework
les valeurs à utiliser pour le nom du champ de texte et les attributs label.
Plutôt que de fournir directement ces attributs et valeurs, nous utilisons
l'attribut key.
Ouvrez votre fichier [Link] du tutoriel sur la validation des formulaires,
et vous devriez voir l'attribut suivant :
<s:textfield name="[Link]" label="Prénom" />
Comme vous pouvez le voir ci-dessous, il est possible d'utiliser l'attribut clé
plutôt que de devoir spécifier les attributs.
<s:textfield key="[Link]" />
La valeur de l'attribut key indique au framework d'utiliser cette valeur pour
[Link], l'attribut name. Le framework utilise la valeur de
l'attribut key pour trouver une clé ayant la même valeur que l'attribut label
dans les fichiers properties. Ainsi, dans notre cas, le framework cherchera
dans [Link] s'il existe une clé avec une valeur
[Link]. La valeur de la clé, First name, est utilisée comme
valeur de l'attribut label.
L'attribut key doit être activé pour localiser le fichier de propriétés, ce qui
implique que l'affichage de la page doit provenir de l'exécution d'une classe
d'action. Si vous regardez [Link] de votre projet de validation de
formulaire, vous verrez que le lien menant à [Link] est juste un lien
URL standard.
<p><a href="[Link]">Veuillez vous inscrire</a> pour notre
tirage au sort.</p><a href="[Link]">Veuillez vous inscrire</a>
pour notre tirage au sort.
Le lien ci-dessus doit être modifié pour passer par la classe d'action appelée
[Link]. Le lien ci-dessus doit être remplacé par le suivant :
<s:url action="registerInput" var="registerInputLink" />
<p><s:a href="%{registerInputLink}">Veuillez vous
inscrire</s:a> pour notre tirage au sort.</p><s:a href="%
{registerInputLink}">Veuillez vous inscrire</s:a> pour notre tirage
au sort.
La balise url est utilisée pour créer un lien vers l'action registerInput. Ce
lien est ensuite utilisé comme valeur de l'attribut href de la balise anchor.
L'action registerInput doit être définie dans le fichier [Link], ajoutez
donc ce qui suit à ce fichier :
<action name="registerInput"
class="[Link]" method="input" >
<result name="input">/[Link]</result>
 </action>
Le nœud d'action ci-dessus indique au framework d'exécuter la méthode
input de la classe Register en réponse à l'action registerInput. La classe
Register hérite de la méthode input de la classe ActionSupport. La méthode
input héritée a pour comportement par défaut de renvoyer une chaîne de
caractères, et le nœud de résultat indiquera que, si "input" est le résultat, la
vue doit être rendue à [Link].
Ainsi, [Link] pourra accéder aux propriétés que nous avons définies
dans [Link]. Le framework s'assurera que ces propriétés sont
mises à la disposition de [Link] (la page de visualisation) car la page a
été rendue après l'exécution de la classe d'action [Link].
Votre projet contient un fichier [Link]. Suivez les instructions qu'il
contient pour créer un fichier war et le copier dans votre conteneur de
servlets. Ouvrez la page d'accueil que vous voyez dans votre fichier
[Link] dans votre navigateur, et vous devriez voir quelque chose
comme ce qui suit. Passez votre souris sur le lien hypertexte Please
Register, et vous devriez voir un lien d'action registerInput.
Cliquez sur le lien, et vous devriez voir la page de visualisation, [Link].
Les valeurs clés des étiquettes des champs du formulaire doivent provenir
du fichier [Link].
Étiquette de texte
La balise text peut également être utilisée pour afficher les valeurs d'un
fichier de propriétés. Dans le fichier appelé [Link], remplacez la
balise h3 par ce qui suit :
<h3><s:text name="thankyou" /></h3>
Étant donné que le rendu a lieu après l'exécution de la classe d'action
[Link], l'attribut clé, thankyou, est disponible avec sa valeur dans la
page de visualisation.

Si vous voulez savoir comment la valeur du champ de saisie du prénom

s'est affichée sur [Link], regardez dans [Link] la valeur
de la clé thankyou :
thankyou=Merci d'avoir enregistré %{[Link]}.
Le balisage %{[Link]} indique au framework que cette
partie doit être remplacée par le résultat getPersonBean, qui est un objet
Person. La méthode GetFirstName doit ensuite être appelée et renvoie une
chaîne de caractères, c'est-à-dire la valeur saisie par l'utilisateur dans
[Link] dans [Link].
Propriétés au niveau du paquet
Vous trouverez l'exemple d'application et le code associé à l'adresse
suivante : [Link]
Imaginons que nous voulions un fichier de propriétés qui contienne des clés
et des valeurs référencées à partir de plusieurs pages de vue, toutes rendues
après l'exécution de leurs classes d'action respectives ? Dans Struts 2, nous
pouvons utiliser plusieurs fichiers de propriétés, à condition qu'ils soient
listés dans la hiérarchie du paquetage.
Créez un fichier dans src/main/resources dans le paquetage
[Link] et appelez-le [Link]. Ajoutez-y ce qui suit :
greeting=Bienvenue dans le monde merveilleux de Struts 2
Lorsqu'une action rend une vue, tant que cette action est listée dans la
hiérarchie [Link], la vue peut utiliser une balise textuelle dont
l'attribut name a pour valeur greeting pour afficher la clé de la propriété
greeting.
Ajoutez ce qui suit juste avant la balise h2 dans [Link] :
<h1><s:text name="greeting" /></h1>
Maintenant, votre fichier war peut être reconstruit et déployé dans le
conteneur de servlets. Ouvrez [Link] et cliquez sur le lien Hello
World - vous devriez voir quelque chose comme ceci :
Les clés/valeurs des propriétés de [Link] sont désormais
disponibles pour toutes les vues rendues après l'exécution d'une classe
d'action de la hiérarchie des packages, pour autant qu'elle contienne
[Link].
Propriétés mondiales
Les propriétés globales peuvent également être spécifiées dans [Link], et
toutes les clés et valeurs qui y sont définies sont disponibles pour toute page
de vue rendue après l'exécution d'une classe d'action.
Créez un fichier appelé [Link] et ajoutez-y ce qui suit :
contact=Pour obtenir de l'aide, contactez <a
href='[Link]
Enregistrez-le dans le dossier src/main/resources.
Le texte suivant doit être ajouté à votre fichier [Link] après
name="[Link]" - cela indique au framework que le fichier existe :
<constant name="[Link]" value="global" />
Si vous souhaitez que la clé constante soit utilisée dans une page de
visualisation, il convient d'ajouter ce qui suit au fichier [Link], juste
avant la balise de fermeture :
<hr />
 <s:text name="contact" />
Votre fichier war peut maintenant être reconstruit et déployé dans votre
conteneur de servlets. Ouvrez [Link], et vous devriez voir quelque
chose comme ce qui suit :

Struts 2 recherche une clé de propriété de contact dans chaque fichier de

propriété, en commençant par le fichier de propriété correspondant à la
classe d'action, en passant par ceux de la hiérarchie des paquets de la classe
d'action, et enfin par ceux que le fichier [Link] spécifie.
Dans notre cas, Struts 2 recherche la clé de contact dans [Link],
et la valeur est affichée à l'emplacement de la balise text.
La balise texte peut être incluse dans tous les fichiers JSP de l'exemple.
Internationalisation (i18n)
Lorsque vous utilisez des fichiers de ressources de messages, vous pouvez
également vous assurer que le texte est fourni dans différentes langues. Par
défaut, l'emplacement de l'utilisateur est utilisé pour déterminer la langue -
si c'est en pour l'anglais, les fichiers de propriétés affichés seront ceux qui
n'ont pas de locale spécifiée. Si, par exemple, il s'agit de es pour l'espagnol,
Struts 2 recherche les fichiers avec la spécification es, tels que
Register_es.properties.
Créez un fichier dans le paquet contenant votre fichier [Link] et
appelez-le Register_es.properties. Ajoutez les traductions suivantes en
espagnol (toutes nos excuses aux hispanophones pour les erreurs !):
[Link]=Nombre
[Link]=Apellidos
[Link]=Edad
[Link]=Correo
thankyou=Gracias por registrarse, %{[Link]}.
Ici, nous voulons que Struts 2 sache qu'il doit utiliser une valeur locale.
Dans notre cas, cette valeur est es plutôt que la valeur par défaut de
l'emplacement actuel de l'utilisateur. Ajoutez le code suivant à votre fichier
[Link] :
<h3>Registro español</h3>
<s:url action="registerInput" var="registerInputLinkES">
<s:param name="request_locale">es</s:param>
</s:url>
<p><s:a href="%{registerInputLinkES}">Por favor,
regístrese</s:a> para nuestro sorteo</p>
Nous avons inclus un paramètre à l'URL appelé request_locate avec un
paramètre es. La classe d'action qui répond à l'URL, [Link], détecte
que la locale est es et recherche tous les fichiers de propriété contenant _es,
par exemple Register_es.properties. Ces fichiers de propriétés seront
utilisés pour trouver des valeurs pour les clés de propriétés auxquelles la
page de visualisation fait référence, c'est-à-dire [Link].
Lorsque vous cliquez sur le lien, vous devriez voir un formulaire similaire
au précédent, mais les libellés des champs du formulaire sont en espagnol :

Nous pouvons créer des versions _es.properties de [Link]

(package_es.properties) et [Link] (global_es.properties), le même
concept peut être mis en œuvre pour créer une page d'enregistrement
complète en langue espagnole.
Traitement des exceptions
Vous trouverez l'exemple d'application et le code associé à l'adresse
suivante : [Link]
Dans cette partie, nous verrons comment Struts 2 peut être activé pour gérer
les exceptions que les applications web génèrent et qui ne sont pas prises en
compte. Struts 2 offre de bonnes capacités de gestion des exceptions,
notamment l'enregistrement automatique des exceptions non capturées et la
redirection des utilisateurs vers une page d'erreur.
Gestion globale des exceptions
Le cadre Struts 2 vous permet de spécifier comment les exceptions non
capturées doivent être gérées. La spécification se fait dans le fichier
[Link], et la logique de traitement peut être appliquée à des actions
spécifiques ou à toutes les actions, c'est-à-dire un traitement global. Nous
allons d'abord nous intéresser à la gestion globale.
La gestion globale des exceptions est activée par l'ajout d'une paire de
nœuds au fichier [Link]. Ces nœuds sont global-results et global-
exception-mapping. Jetez un coup d'œil au fichier [Link] de votre projet
de gestion des exceptions :
<global-results>
<result name="securityerror">/[Link]</result>
<result name="error">/[Link]</result>
</global-results>

<global-exception-mappings>
<exception-mapping
exception="[Link]
ception" result="securityerror" />
<exception-mapping exception="[Link]"
result="error" />
</global-exception-mappings>
Le nœud de mappage permet au framework de savoir ce qu'il faut faire si
l'application lance une exception non capturée (type spécifié) ou un enfant
du type spécifié.
Prenons l'exemple de l'exception SecurityBreachException. Si cette
exception est levée mais n'est pas rattrapée, la classe d'action renvoie
"securityerror" et toutes les autres exceptions non rattrapées renvoient
également "error" à la classe d'action.
La valeur du résultat est liée à la page de visualisation concernée par le
nœud de résultats global. Par exemple, le résultat "securityerror" indique au
cadre de travail d'envoyer l'utilisateur à une page de vue différente,
[Link].
Traitement des exceptions par action
Si une exception doit être traitée d'une manière spécifique pour une action
spécifique, le nœud de mappage d'exception du nœud d'action est utilisé :
<action name="actionpecificexception"
class="[Link]"
method="throwSecurityException">
<exception-mapping
exception="[Link]
ception" result="login" />
<result>/[Link]</result>
<result name="login">/[Link]</result>
</action>
Ce nœud d'action provient du fichier [Link] de l'application d'exemple.
Il spécifie que lorsqu'une exception SecurityBreachException non capturée
est levée par la méthode throwSecurityException, le framework renvoie
"login" comme résultat. L'utilisateur sera alors redirigé vers la page de
visualisation [Link].
Comme vous pouvez le constater, le mappage d'exception spécifique à une
action est prioritaire si la même exception est mappée globalement.
Enregistrement des exceptions
Le framework Struts 2 peut être configuré pour enregistrer les exceptions
non capturées. Pour ce faire, les valeurs des paramètres doivent être
spécifiées dans le fichier [Link]. L'API de la classe
ExceptionMappingInterceptor spécifie trois paramètres pour activer la
journalisation :

logEnabled - active la journalisation

logLevel - spécifie le niveau de journalisation à utiliser
logCategory - spécifie la catégorie du journal
Si vous souhaitez que ces valeurs soient définies pour toutes les actions
utilisant une pile d'intercepteurs spécifique d'un paquet, il faut ajouter ce qui
suit à [Link], immédiatement après le nœud d'ouverture du paquet :
<intercepteurs>
<interceptor-stack name="appDefaultStack">
<interceptor-ref name="defaultStack">
<param name="[Link]">true</param>
<param name="[Link]">ERROR</param>
</interceptor-ref>
</interceptor-stack>
</interceptors>

<default-interceptor-ref name="appDefaultStack" />

Ce nœud d'intercepteur configure une nouvelle pile d'intercepteurs et la
nomme appDefaultStack. Cette pile est basée sur la pile par défaut de
l'intercepteur ou sur les intercepteurs de Struts 2 qui s'exécutent chaque fois
que le cadre de travail appelle une méthode de la classe Action.
ExceptionMappingInterceptor est contenu dans la pile par défaut.
Conformément à la définition de la pile par défaut, il est appelé "exception".
Lorsqu'un nœud param appelé [Link] est spécifié avec true
comme valeur, cela signifie que le paramètre appelé logEnabled de
ExceptionMappingInterceptor a été défini à true.
Lorsqu'une exception non capturée est levée, elle est gérée par le
framework, qui écrit une entrée dans le journal avec la trace de la pile. Dans
notre exemple, nous avons défini ces exceptions pour qu'elles soient
enregistrées au niveau ERROR.
Affichage des informations sur les exceptions dans le navigateur
Des informations sur les exceptions peuvent être affichées dans le
navigateur. Pour ce faire, on utilise les balises s:property et on leur attribue
la valeur 'exception' et exceptionStack. Regardez le fichier [Link], et vous
devriez voir ceci :
 <h4>L'application a mal fonctionné.</h4>

</p> <p>Veuillez contacter le support technique avec les

informations suivantes :</p> <p>Les informations suivantes sont
disponibles sur le site web de la société

<h4>Nom de l'exception : <s:property value="exception" /> </h4>.

<h4>Détails de l'exception : <s:property value="exceptionStack"

/></h4>
Lors du déclenchement de l'intercepteur d'exception, les champs
disponibles sont ajoutés au message d'exception et à la trace de la pile.
Lorsque l'intercepteur d'exception est déclenché, il ajoute aux champs
disponibles pour l'affichage le message d'exception et la trace de la pile de
l'exception.
Débogage de Struts
Vous trouverez l'exemple d'application et le code associé à l'adresse
suivante : [Link]
Lorsque vous développez une application avec Struts 2, il se peut que vous
souhaitiez voir les informations gérées par le framework. Nous allons
examiner deux outils que vous pouvez utiliser pour vous montrer comment
Struts voit l'application. Le premier est un plugin de configuration et le
second est un intercepteur de débogage. Nous verrons également comment
le niveau du journal peut être défini pour déterminer le nombre de messages
d'erreur que vous voyez.
Plugin de configuration
Il s'agit d'un plugin de navigateur qui vous indique la configuration utilisée
par le framework lors de l'exécution de votre application. Pour ajouter ce
plugin, vous devez ajouter le fichier struts-2-config-browser-plugin-
[Link] au chemin de la classe de l'application. Le plugin fait partie de
Struts 2 et peut également être trouvé dans Maven.
L'utilisation du plugin est aussi simple que d'appeler [Link] dans
l'espace de noms config-browser, c'est-à-dire que le lien suivant pourrait se
trouver sur votre page d'administration :
<a href='<s:url action="index" namespace="config-browser"
/>'>Lancer le navigateur de configuration</a>
Dans notre exemple d'application, la page [Link] renvoie au navigateur
de configuration. En cliquant sur ce lien, le framework renverra quelque
chose comme ce qui suit dans votre navigateur :

Si vous cliquez sur un lien d'action, vous pouvez voir la configuration de

cette action. Par exemple, si vous cliquez sur le lien de l'action
d'enregistrement, vous verrez quelque chose comme ceci :
De là, vous pouvez cliquer sur un onglet - Résultats, Intercepteurs,
Mappages d'exception, Valideurs ou Propriétés - et obtenir des informations
sur la manière dont le framework a configuré cette action.
Le menu du plugin du navigateur de configuration se trouve sur le côté
gauche. Si vous cliquez sur Constants, vous verrez une liste des constantes
de votre application et des valeurs associées. Si vous cliquez sur Jars, vous
verrez les jars utilisés par votre application.
Utilisation de l'intercepteur de débogage
Jetez un coup d'œil à votre fichier [Link]. Si devMode est défini comme
true, le DebuggingInterceptor est activé lorsqu'une action est traitée par
Struts 2. Cet intercepteur recherchera une chaîne de requête ajoutée à
l'action URL - il devrait être appelé debug, et sa valeur devrait être browser,
console, xml, ou command.
Si la chaîne de requête est localisée, DebuggingInterceptor cessera
d'exécuter l'action. Au lieu de cela, il retournera aux informations de
débogage du navigateur. Le format des informations renvoyées dépend de la
valeur du paramètre de requête.
Dans [Link], vous devriez voir un lien qui affiche des informations sur le
débogage. Ce lien contiendra une chaîne de requête debug=browser. En
cliquant sur ce lien, vous verrez apparaître un tableau dont les colonnes
peuvent être réduites ou développées. Il vous montre les objets gérés par le
framework, ainsi que leur état.
Si vous voulez que les liens expand et collapse de la page debug info
s'affichent et interagissent correctement, la balise s:head doit être ajoutée à
la section head du JSP. Le plugin Struts 2 dojo doit également être ajouté au
chemin de la classe d'application. Ce plugin fait partie de Struts et peut
également être trouvé dans Maven.
Logging Struts 2
Le framework écrit beaucoup d'informations dans un journal, à condition
que les propriétés du journal soient configurées au niveau debug. Jetez un
coup d'œil à [Link] dans l'application d'exemple. Vous devriez voir
deux paquets principaux - [Link] et [Link].struts2. Tous
deux ont été configurés pour écrire le journal et les messages de débogage.
Lorsque l'application est exécutée, regardez le standard de votre conteneur
de servlets pour voir les informations du journal.
Étiquettes du formulaire
Vous trouverez l'exemple d'application et le code associé à l'adresse
suivante : [Link]
Il est temps de s'intéresser à quelques autres contrôles de formulaires dans
Struts 2. Nous avons déjà étudié l'utilisation des formulaires pour le
traitement, la validation et les ressources de message. Nous avons
également étudié l'en-tête, les contrôles de champ de texte, le formulaire et
les attributs clés. Dans cette partie, nous allons nous pencher sur l'utilisation
de quelques autres contrôles de formulaire :

sélectionner
radio
case à cocher
liste de contrôle
Téléchargez l'exemple d'application - il utilise des balises de formulaire et
vous montre comment un utilisateur peut modifier ses informations. Toutes
les informations disponibles pour l'édition sont encapsulées dans un objet
de la classe Personne, qui connaîtra les informations suivantes sur un
utilisateur :

Leur prénom
Leur nom de famille
Leur sport préféré
Leur sexe
Leur état de résidence
Qu'ils aient plus ou moins de 21 ans
Les modèles de voitures qu'ils possèdent
Pour qu'un utilisateur puisse modifier ses informations personnelles, un
formulaire est nécessaire. Créez-en un qui ressemble à celui-ci :
Ce formulaire fournit les détails que l'utilisateur peut modifier et, une fois le
formulaire soumis, l'état de l'objet Personne est mis à jour par le cadre.
Dans les fichiers de l'application d'exemple, regardez [Link], et vous
verrez les noms et prénoms sur le formulaire, fournis par la balise textfield.
Sélectionner une étiquette
Les utilisateurs peuvent choisir leur sport favori dans une liste de choix, et
l'application utilise la balise select pour proposer ces options.
<s:select key="[Link]" list="sports" />
L'attribut clé est utilisé dans les balises du formulaire pour déterminer les
valeurs des autres attributs, tels que la valeur et l'étiquette. Notez que la
classe EditAction est également associée à un fichier de propriétés qui
utilise la valeur de l'attribut clé pour fournir les étiquettes de valeur.
Le cadre utilise la valeur de l'attribut de liste de la balise select pour
déterminer quelle méthode de la classe d'action doit être appelée pour créer
les valeurs de l'option. Dans notre exemple, la valeur de l'attribut de liste
"sports" entraînera l'appel de la méthode getSports à partir de la classe
EditAction. Un tableau de chaînes est renvoyé, contenant les valeurs
"hockey", "tennis" et "cricket", qui sont ensuite utilisées pour créer des
balises d'option dans la balise select.
Le cadre décidera de l'option présélectionnée. Il utilise la valeur de l'attribut
key pour appeler une méthode sur l'objet. L'attribut key ayant pour valeur
[Link], la méthode getSport de l'objet personBean est appelée. Si
la valeur renvoyée correspond à une valeur d'option, l'option est
"sélectionnée".
Voici le code HTML résultant de la balise select :
<tr>
<td class="tdLabel">
<label for="save_personBean_sport" class="label">Sport
préféré:</label>
</td>
<td>
<select name="[Link]"
id="save_personBean_sport">
<option value="hockey">hockey</option>
<option value="tennis">tennis</option>
<option value="cricket"
selected="selected">cricket</option>
</select>
</td>
</tr>
Notez que le cadre Struts crée un formatage de tableau lorsque la balise
select est utilisée. Les feuilles de style sont utilisées pour définir les classes
CSS, et celles-ci sont définies dans la balise s:head, qui se trouve dans la
section head du fichier [Link].
Puisque la méthode getSport renvoie "cricket", le cricket est l'option
sélectionnée.
Étiquette radio
Comme son homologue en HTML, la balise radio affiche au moins deux
choix, mais l'utilisateur ne peut en sélectionner qu'un seul. Le code de
l'exemple d'application est le suivant :
<s:radio key="[Link]" list="genders" />
Là encore, la valeur de l'attribut key détermine les valeurs de l'étiquette et
les attributs values. Le texte de l'étiquette provient du fichier
[Link], dont la clé est [Link].
L'attribut de liste d'étiquettes radio oblige le cadre à appeler getGenders à
partir d'EditAction. Le tableau d'objets de type chaîne qui est renvoyé est
utilisé dans la création des boutons radio.
<tr>
<td class="tdLabel">
<label for="save_personBean_gender" class="label">Genre:
</label>
</td>
<td>
<input type="radio" name="[Link]"
id="save_personBean_gendermale" value="male"/>
<label for="save_personBean_gendermale">male</label>

<input type="radio" name="[Link]"

id="save_personBean_genderfemale" value="female"/>
 <label
for="save_personBean_genderfemale">femme</label>

<input type="radio" name="[Link]"

id="save_personBean_gendernot sure" checked="checked"
value="not sure"/>
<label for="save_personBean_gendernot sure">not
sure</label>
</td>
</tr>
Comme pour la balise select, lorsque la méthode getGender est appelée à
partir de l'objet personBean, elle est utilisée pour décider quel bouton radio
doit être coché.
Select Tag - Object Backed
Lorsque l'utilisateur voit des options qui ont toutes leur propre valeur mais
qui sont différentes de ce qui est affiché, il utilise une balise select
différente. Dans notre exemple d'application, l'état de résidence de
l'utilisateur est stocké sous forme d'abréviation, par exemple KS pour
Kansas. Cependant, sur le formulaire, la boîte de sélection affichera le nom
complet. Le code ci-dessous est utilisé pour créer cette balise select :
<s:select key="[Link]" list="states"
listKey="stateAbbr" listValue="stateName" />
Il est demandé au cadre d'appeler la méthode getStates de la classe
EditAction par la valeur de la liste. Une liste d'objets State est renvoyée, et
chaque objet possède deux méthodes : getStateAbbr et getStateName.
L'attribut listKey permet également au cadre d'utiliser la valeur renvoyée.
Pour ce faire, il appelle la méthode getStateAbbr de l'attribut value de la
balise option HTML. Il obtient également la valeur retournée en appelant la
méthode getStateName en tant que valeur visible par l'utilisateur. Le code
ci-dessus donnerait ceci :
<tr>
 <td class="tdLabel">
<label for="save_personBean_residency"
class="label">Résident de l'État:</label>
</td>
<td>
<select name="[Link]"
id="save_personBean_residency">
<option value="AR">Arkansas</option>
<option value="MA">Massachusetts</option>
<option value="WA">Washington</option>
<option value="KS"
selected="selected">Kansas</option>
<option value="NY">New York</option>
</select>
</td>
</tr>
Lorsque la méthode getResidency de l'objet personBean est appelée, la
valeur renvoyée détermine la balise d'option de la balise select à marquer
comme sélectionnée. Comme getResidency renvoie KS dans notre exemple,
la balise option dont l'attribut value est égal à KS est sélectionnée.
Étiquette de case à cocher
Nous pouvons utiliser la balise checkbox lorsque nous voulons créer un
type d'entrée HTML égal à la balise checkbox. La valeur de l'attribut key
indique au framework quelle méthode doit être appelée pour déterminer si
une case est cochée ou non. La méthode doit renvoyer true ou false
(valeurs booléennes) - true signifie que la case est cochée et false signifie
qu'elle ne l'est pas.
<s:checkbox key="personBean.over21" />
Comme isOver21 donne un résultat de true, la case est cochée :
<tr>
<td valign="top" align="right"></td>
<td valign="top" align="left">
<input type="checkbox" name="personBean.over21"
value="true" checked="checked" id="save_personBean_over21"/>
<input type="hidden"
id="__checkbox_save_personBean_over21"
name="__checkbox_personBean.over21" value="true" />
<label for="save_personBean_over21"
class="checkboxLabel">21 ou plus</label>
</td>
</tr>
Si le formulaire est soumis et que la case à cocher n'est pas cochée, la
valeur de la case à cocher n'est pas enregistrée. Le framework Struts 2 doit
mettre à jour la valeur du champ over21 de personBeans à false parce que la
case n'a pas été cochée. Pour cette raison, le framework doit être en mesure
de savoir si la case n'a pas été cochée après l'envoi du formulaire.
Regardez le code HTML créé par la balise checkbox. Vous devriez voir
qu'un champ caché a été créé, associé à la case à cocher personBean.over21.
Lorsque la soumission du formulaire est interceptée par le framework, ce
champ caché vérifie l'existence du champ checkbox dans les données du
formulaire posté. Si ce n'est pas le cas, le framework sait que la variable
d'instance over21 de l'objet personBean doit être mise à jour à false.
checkboxlist Tag
Struts 2 nous offre également un contrôle de champ de formulaire lorsque
nous voulons créer une série de cases à cocher associées, et qu'une ou
plusieurs d'entre elles peuvent être cochées. Dans notre exemple
d'application, notre classe Personne contient un tableau de chaînes de
caractères, utilisé pour stocker les modèles de voitures possédés par une
personne.
La balise checkbox permet de créer une série de cases à cocher pour chaque
modèle de voiture que l'utilisateur peut posséder. Chaque chaîne du tableau
carModels dans personBeans aura une valeur qui déterminera les cases à
cocher.
<s:checkboxlist key="[Link]"
list="carModelsAvailable" />
La valeur des attributs de liste de la balise checkbox informe le cadre de la
méthode qu'il doit appeler pour obtenir les modèles de voiture. Dans notre
exemple d'application, la méthode getCarModel de la classe EditAction est
appelée et renvoie un tableau de chaînes. Le cadre créera une case à cocher
pour chaque élément du tableau, qui inclut le champ caché dont nous avons
parlé plus haut.
La balise checkboxlist possède une valeur d'attribut clé qui informe le cadre
de la méthode qu'il doit appeler sur l'objet personBean pour déterminer
laquelle des cases à cocher doit être vérifiée. La méthode getCarModels
renvoie un tableau de chaînes, et chaque valeur de chaîne est comparée au
tableau renvoyé par getCarModelsAvailable - pour celles qui correspondent,
la case est cochée.
<tr>
<td class="tdLabel">
<label for="save_personBean_carModels"
class="label">Modèles de voitures possédés:</label>
</td>
<td>
<input type="checkbox" name="[Link]"
value="Mazda" id="[Link]-1"
checked="checked"/>
<label for="[Link]-1"
class="checkboxLabel">Mazda</label>
 <input type="checkbox" name="[Link]"
value="Opel" id="[Link]-2"/>
<label for="[Link]-2"
class="checkboxLabel">Opel</label>

<input type="checkbox" name="[Link]"

value="Audi" id="[Link]-3"/>
<label for="[Link]-3"
class="checkboxLabel">Audi</label>

<input type="checkbox" name="[Link]"

value="BMW" id="[Link]-4"
checked="checked"/>
<label for="[Link]-4"
class="checkboxLabel">BMW</label>
<input type="hidden"
id="__multiselect_save_personBean_carModels"
name="__multiselect_personBean.carModels" value="" />
</td>
</tr>
Validation des formulaires à l'aide de XML
Vous trouverez l'exemple d'application et le code associé à l'adresse
suivante : [Link]
Nous allons maintenant nous pencher sur la validation de ce qu'un
utilisateur saisit dans les champs du formulaire et utiliser la validation XML
que Struts 2 nous fournit. Dans la section précédente sur la validation des
formulaires, nous avons utilisé la méthode validate de la classe Action, mais
en utilisant un fichier XML séparé, vous pouvez utiliser les validateurs
intégrés dans le framework.
Dans l'exemple d'application, les informations que nous pouvons modifier
sont encapsulées dans un objet de la classe Personne. Le formulaire suivant
est utilisé pour permettre à l'utilisateur de modifier les informations
stockées :

Lorsque le formulaire est soumis, nous devons valider les données saisies.
Validation à l'aide de XML
Nous pouvons utiliser un fichier XML distinct pour valider les entrées - le
fichier contient les règles de validation. Ce fichier doit s'appeler
[Link]. Dans notre exemple d'application, le
fichier s'appelle [Link], et il est stocké sous
src/main/resources/org/apache/struts/edit/action.
Le fichier de validation XML contient un certain nombre de validateurs
différents que vous pouvez utiliser.
Nous devons nous assurer que l'utilisateur saisit son prénom dans notre
formulaire, et cette règle peut être appliquée par le framework à l'aide du
validateur requiredstring. Celui-ci vérifiera qu'une chaîne de caractères a
bien été saisie dans le champ du formulaire.
Format du validateur XML
Le fichier de validation XML contient ce XML :
<!DOCTYPE validators PUBLIC "-//Apache Struts//XWork
Validator 1.0.3//EN" "[Link]
[Link]">

<validateurs>
<validator type="requiredstring">
<param name="fieldname">[Link]</param>
<message>Le prénom est obligatoire.</message>
</validator>
</validators>
Le nœud du validateur peut contenir un ou plusieurs nœuds. L'attribut type
permet de spécifier le validateur que le cadre doit utiliser, et le paramètre, le
nœud name="fieldname", indique au cadre à quelle entrée la règle doit être
appliquée. Enfin, le nœud message indique au framework le message à
afficher en cas d'échec de la validation.
Par exemple, si aucune valeur n'est saisie dans le champ du prénom et que
l'utilisateur clique sur le bouton Enregistrer les modifications, le message
suivant s'affiche :
Validation des adresses électroniques
Le validateur d'email inclus dans Struts 2 peut être utilisé pour valider ce
que l'utilisateur tape dans le champ email. Dans le fichier EditAction-
[Link], vous trouverez ce nœud de validateur :
<validator type="requiredstring">
<param name="fieldname">[Link]</param>
<message>L'adresse électronique est requise.</message>
</validator>
<validator type="email">
<param name="fieldname">[Link]</param>
<message>L'adresse électronique n'est pas valide.</message>
</validator>
Dans notre exemple d'application, nous avons besoin que l'utilisateur
saisisse son adresse électronique, puis nous pouvons la valider.
Utilisation d'expressions régulières pour valider les entrées des
utilisateurs
Struts 2 nous offre un excellent moyen de valider les entrées d'un champ de
formulaire - le validateur regex. Dans notre exemple, nous voulons que
l'utilisateur entre son numéro de téléphone dans un format spécifique - 999-
999-9999. Cette règle peut être appliquée à l'aide d'une expression régulière
et du validateur regex.
<validator type="requiredstring">
<param
name="fieldname">[Link]</param>
<message>Le numéro de téléphone est obligatoire.</message>
</validator>
<validator type="regex">
<param
name="fieldname">[Link]</param>
<param name="regex"><![CDATA[\d{3}-\d{3}-\d{4}]]>
</param>
<message>Le numéro de téléphone doit être saisi sous la forme
999-999-9999.</message>
</validator>
Le nœud appelé param name= "regex" spécifie l'expression régulière à
appliquer à l'entrée - notez que l'expression se trouve à l'intérieur d'une
section CDATA.
Utilisation d'une expression OGNL pour valider les données de
l'utilisateur
Notre exemple d'application doit s'assurer que l'utilisateur coche la case à
côté d'au moins un modèle de voiture. Le validateur fieldexpression est
utilisé pour appliquer la règle et le nœud XML du validateur est :
<validator type="fieldexpression">
<param name="fieldname">[Link]</param>
<param name="expression">< !
[CDATA[[Link] > 0]]></param>
 <message>Vous devez sélectionner au moins un modèle de
voiture.</message>
</validator>
Le nœud appelé param name= "expression" possède une expression OGNL
évaluant true ou false. OGNL signifie Object-Graph Navigation Language,
et ces expressions sont évaluées comme des instructions Java par le
framework.
Dans le XML ci-dessus, le nœud param name= "expression", qui est
[Link] > 0, a une valeur que le framework évalue
comme une instruction Java. Le noeud [Link] informe le
framework que la méthode getCarModels de la classe Person doit être
appelée. Un tableau est renvoyé, et comme la classe Array contient un
attribut length, la valeur donnée au framework est l'attribut length pour le
tableau de la méthode getCarModels.
Si aucune des cases n'est cochée, le tableau retourné a une longueur de 0.
Comme l'expression OGNL n'évalue vrai que si la valeur est supérieure à 0,
la validation échoue et l'utilisateur voit ce qui suit :

Le validateur d'expression de champ est très utile lorsque vous souhaitez

effectuer une validation conditionnelle des données saisies par l'utilisateur.
Si l'expression OGNL évalue faux, la saisie de l'utilisateur n'est pas
autorisée.
Tags de contrôle
Vous trouverez l'exemple d'application et le code associé à l'adresse
suivante : [Link]
Struts 2 contient quelques balises de contrôle à utiliser dans la vue. Nous
allons voir quelques exemples d'utilisation des balises iterator et if.
si Tag
Dans le fichier [Link], vous trouverez la balise suivante :
<s:if test="personBean.over21">
</p> <p>Vous avez l'âge de voter!</p> <p>L'âge de voter a été
fixé par la Commission européenne.
</s:if>
<s:else>
</p> <p>Vous n'avez PAS l'âge de voter.
</s:else>
La balise if comporte un attribut test dont la valeur doit être true ou false.
S'il évalue true, les instructions entre la balise d'ouverture s : if et la balise
de fermeture s : if sont exécutées. S'il évalue false, les instructions situées
entre les balises s : else d'ouverture et s : else de fermeture sont exécutées.
Rappelez-vous qu'une balise s : else doit se trouver après une balise s : if
fermante et que vous n'avez pas besoin de balises s : else.
Dans l'exemple ci-dessus, le cadre appelle la méthode getPersonBean que la
classe Action, [Link], expose. Cette méthode renvoie un objet
Person que le cadre utilise pour appeler la méthode isOver21 de la classe
Person. Cette méthode renvoie un booléen permettant de déterminer si le
test est vrai ou faux.
La valeur de l'attribut test doit être une expression avec une évaluation true
ou false, mais il n'est pas nécessaire que ce soit une méthode renvoyant un
booléen. Par exemple, la balise s : if de [Link] a une expression
beaucoup plus complexe :
<s:if test="[Link] > 1">
<p>Modèles de voitures
</s:if>
<s:else>
<p>Modèle de voiture
 </s:else>
Cette balise n'a qu'un seul but : utiliser les modèles de voiture ou le modèle
de voiture. Cela dépend du nombre de modèles sélectionnés par l'utilisateur
dans la vue d'édition. Cette balise itérateur aura pour valeur la longueur du
tableau de chaînes carModels, qu'elle comparera ensuite à 1. Si cette valeur
est supérieure à 1, la grammaire devra être Car models, tandis que si elle est
inférieure à 1, la grammaire devra être Car model.
itérateur Tag
La balise iterator génère des boucles. Celles-ci itèrent sur les différents
éléments d'une collection. Regardez dans le fichier [Link] et vous
verrez la balise suivante.
<table style="margin-left:15px">
<s:iterator value="[Link]">
<tr><td><s:propriété /></td></tr>
</s:iterator>
</tableau>
Ce code vise à créer un tableau HTML contenant une ligne affichant le
modèle de voiture sélectionné par l'utilisateur. Les modèles de voiture
choisis sur la page d'édition sont stockés dans un tableau de chaînes appelé
carModels provenant de l'objet personBean issu de la classe Person.
L'attribut value de la balise iterator doit correspondre à une liste, un tableau,
une carte ou un autre type de collection.
La balise iterator contient une balise s : property imbriquée. Chaque fois
que l'itérateur passe en boucle sur un élément de la collection, la balise s :
property affiche la valeur de la collection. Comme nous travaillons avec un
tableau d'objets de type chaîne, la balise ne spécifie pas l'attribut value. Au
lieu de cela, nous obtenons la chaîne de caractères de cet élément de
collection.
Si la collection contient des objets avec plusieurs champs, l'attribut de
valeur de la balise de propriété s : doit être utilisé pour déterminer le champ
qui doit être affiché. En voici un exemple :
<table style="margin-left:15px">
<s:iterator value="states" >
<tr><td><s:property value="stateAbbr" /></td> <td>
<s:property value="stateName" /></tr>
</s:iterator>
</tableau>
La balise iterator a pour valeur states, ce qui permet au cadre d'appeler la
méthode getStates de la classe Action. Cette méthode renvoie une liste
contenant des objets state. Il y a deux champs - stateAbbr et stateName - et
tous deux ont une méthode get appropriée dans la classe State. L'itérateur
parcourt en boucle les différents objets State et, à chaque boucle, le
framework obtient une référence à l'objet State actuel. Les deux méthodes
seront appelées pour cet objet.
Attributs supplémentaires de l'itérateur
La balise iterator possède également d'autres attributs utiles pour contrôler
les valeurs de début et de fin qui spécifient que la balise doit boucler sur
une partie seulement de la collection.
Sélection de la méthode Wildcard
Vous trouverez l'exemple d'application et le code associé à l'adresse
suivante : [Link]
Nous allons voir comment configurer les nœuds d'action dans notre fichier
[Link]. Ainsi, un seul nœud pourra relier plusieurs URL d'action à des
méthodes particulières de la classe d'action. Cela permet de réduire le
nombre de nœuds d'action à écrire dans le fichier de configuration.
Voici notre exemple d'application :
L'exemple d'application que nous utilisons dans cette section montre
comment la méthode de sélection par caractères génériques est utilisée. Il
s'agit d'une simple application qui dresse une liste de personnes, vous
permettant de la modifier, de la supprimer ou d'en ajouter de nouvelles à la
liste. La classe de support d'action PersonAction contrôle tout ce qui doit
être fait avec la classe de modèle appelée aPerson, et elle possède quelques
méthodes que nous pouvons utiliser, chacune dépendant de ce que fait
l'utilisateur.
Si nous n'utilisions pas la méthode de sélection par caractères génériques,
nous devrions ajouter un nœud de mappage d'action pour chaque action
individuelle dans le fichier de configuration. Par exemple, nous pourrions
ajouter un nœud de correspondance d'action pour chaque action individuelle
dans le fichier de configuration :
<action name="createPerson"
class="[Link]
ion" method="create">
<result name="input">[Link]</result>
<result name="success">[Link]</result>
</action>

<action name="editPerson"
class="[Link]
 ion" method="edit">
<result name="input">[Link]</result>
<result name="success">[Link]</result>
</action>
Même dans une application simple comme celle-ci, nous aurions besoin de
quatre nœuds de mappage d'actions individuels pour la création, la mise à
jour, l'enregistrement ou la suppression. De cette manière, vous pouvez voir
que le fichier de configuration aurait plusieurs nœuds de mappage d'actions
avec une application plus complexe, et les choses commenceraient à
devenir un peu désordonnées.
La méthode de sélection par joker est utilisée pour sélectionner la bonne
méthode dynamiquement au moment de l'exécution et nous la mettons en
œuvre en utilisant le symbole de joker, *. Ce symbole est utilisé dans la
valeur du nom et la valeur de l'attribut pour la valeur de la méthode. Par
exemple :
<action name="*Person"
class="[Link]
ion" method="{1}">
<result name="success">[Link]</result>
<result name="input">[Link]</result>
</action>
Le mappage d'action traite tous les noms d'action contenant "Person" à la
fin. La valeur qui précède "Person" est la valeur que nous utilisons pour
l'attribut de méthode et remplace le caractère générique {1}.
Voici un exemple d'URL :
[Link]
Dans l'exemple ci-dessus, le nœud de mappage d'action traite cette
information et la méthode de création de la classe PersonAction est appelée.
Dans cette URL :
[Link]
La méthode de suppression est appelée.
Que se passerait-il si notre URL ne comportait aucun élément précédant
"Personne", comme ceci :
[Link]
Si une valeur ne précède pas " Person ", le cadre appelle la méthode execute
de la classe PersonAction.
Spring et Struts 2
Vous trouverez l'exemple d'application et le code associé à l'adresse
suivante : [Link]
Dans de nombreuses méthodes d'exécution de la classe ActionSupport, il y
a des instructions pour créer des objets et demander à ces objets d'exécuter
les méthodes requises pour des tâches spécifiques. Lorsqu'un objet d'une
classe est créé par une autre classe, cet objet introduit une dépendance entre
les classes. Le cadre Spring aide le développeur à mieux gérer les
dépendances et à garantir la maintenance et la flexibilité de l'application.
Cette section examine l'utilisation de Spring et de Struts 2 pour gérer les
dépendances entre l'Action Support et d'autres classes de l'application.
Si vous regardez l'exemple d'application, le code suivant se trouve dans la
classe EditAction :
private EditService editService = new EditServiceInMemory() ;
Cette déclaration est utilisée pour coder en dur les dépendances entre deux
classes - EditAction et EditServiceInMemory. Il y a deux raisons pour
lesquelles cela est considéré comme une mauvaise conception.
Tout d'abord, si EditServiceInMemory devait être remplacé par une classe
différente implémentant l'interface EditService, nous devrions trouver
toutes les déclarations où la dépendance est codée en dur et les remplacer
toutes.
Deuxièmement, EditAction ne peut pas être testé sans que la classe
EditServiceInMemory soit utilisée. Lorsque nous écrivons nos cas de test,
nous ne pouvons pas utiliser une implémentation de EditService pour isoler
EditService parce que l'utilisation de EditServiceInMemory est codée en
dur.
Dans Spring, il existe un mécanisme de gestion des dépendances basé sur
l'injection des dépendances au moment de l'exécution. Comme les classes
Java, le cadre Spring peut injecter des objets de dépendance dans les classes
ActionSupport de Struts 2. Au lieu d'avoir besoin du code précédent, nous
pourrions utiliser une déclaration comme la suivante dans EditAction :
private EditService ;
Ensuite, au moment de l'exécution, le cadre fournit les objets de la classe
qui implémentent EditService.
Plugin Spring
Struts 2 fournit également un plugin permettant à Spring d'injecter dans les
classes ActionSupport les objets dépendants spécifiés dans le fichier de
configuration.
Si votre application est construite sur Maven, une dépendance doit être
ajoutée au fichier jar struts-2-spring-plugin. Le fichier [Link] du plugin
contient des dépendances transitives relatives aux fichiers jar.
Note
Si vous utilisez la dernière version de Spring, les dépendances transitives
doivent être exclues du fichier [Link] du plugin Spring. Les nœuds de
dépendance doivent alors être déclarés dans les fichiers jar de la version
actuelle de Spring.
Votre classe ActionSupport doit contenir une méthode set pour chaque objet
indépendant et respecter les conventions de dénomination standard pour les
beans Java. Si vous examinez la classe EditAction de l'application, vous
devriez voir la méthode suivante :
public void setEditService(EditService editService) {
[Link] = editService ;
}
Spring l'utilise pour fournir un type d'objet EditService à EditAction au
moment de l'exécution.
Pour s'assurer que notre application est compatible avec Spring, il faut
ajouter ce qui suit au fichier [Link] :
<listener>
<listener-
class>[Link]</li
stener-class>
</listener>
Le cadre Spring est activé par ce code lorsque le conteneur Servlet démarre
l'application. Spring recherche le fichier de configuration
[Link] dans WEB-INF.
Fichier de configuration Spring
Nous avons besoin d'un nœud de haricot créé dans le fichier de
configuration Spring pour les objets Spring dont nous avons créé une
instance et à injecter dans ActionSupport. L'application d'exemple contient
un fichier appelé [Link] :
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="[Link]
xmlns:xsi="[Link]
xsi:schemaLocation="
[Link]
[Link]
[Link]">

<bean id="editService"
class="[Link]" />

</beans>
Notez qu'il y a une valeur id. Le plugin Spring et Spring travaillent
ensemble pour câbler automatiquement les dépendances des classes d'action
par nom. Spring crée un objet de classe EditServiceMemory et le fournit à
toutes les classes ActionSupport qui contiennent des méthodes EditService
avec des arguments de type EditService.
Lorsque Spring crée editService, il lui donne un scope singleton, ce qui est
son cas par défaut.
Comme alternative, Spring pourrait également gérer la création de la classe
ActionSupport, en utilisant la même méthodologie pour configurer la classe
d'application. Pour ce faire, vous avez besoin d'un noeud ActionSupport
class bean dans le fichier de configuration de Spring :
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="[Link]
xmlns:xsi="[Link]
xsi:schemaLocation="
[Link]
[Link]
[Link]">

<bean id="editService"
class="[Link]" />

<bean id="editAction"
class="[Link]"
scope="prototype">
<property name="editService" ref="editService" />
</bean>

</beans>
Ici, nous avons un bean editAction dont la propriété editService est définie
comme editService. Comme Spring va gérer la classe EditAction, toutes les
propriétés EditAction que Spring va injecter doivent être spécifiées.
N'oubliez pas que les actions doivent être créées pour chaque requête, et
non en tant que singletons. Singleton est la portée par défaut et doit être
remplacé par prototype.
Votre fichier [Link] doit être modifié pour afficher la valeur Spring id
pour l'attribut class du nœud action. Cela permet à Struts de savoir qu'un
bean est nécessaire pour la classe Action, avec la valeur Spring id.
<action name="edit" class="editAction" method="input">
<result name="input">/[Link]</result>
</action>
Annotations
Vous trouverez l'exemple d'application et le code associé à l'adresse
suivante : [Link]
Précédemment, nous avons configuré nos applications à l'aide d'un fichier
XML. Ce fichier associe le nom de l'action aux classes ActionSupport, et
rend le résultat au navigateur. Dans Struts 2, il existe une autre façon de
configurer votre application - des annotations et des conventions de
nommage standard pour les classes ActionSupport, les noms d'action et les
résultats.
Si vous ne savez pas comment les annotations sont appliquées aux classes
et aux méthodes Java, allez en ligne et rafraîchissez votre mémoire.
Plugin Convention
Les annotations relatives aux conventions de nommage standard sont
activées lorsque le plugin Convention est ajouté au chemin de la classe
d'application. Si vous utilisez Maven, une dépendance doit être ajoutée :
<dépendance>
<groupId>[Link]</groupId>
<artifactId>struts2-convention-plugin</artifactId>
 <version>X.X.X.X</version>
</dependency>
Ce plugin nous donne quelques moyens de configurer une application sans
avoir besoin d'utiliser XML. Nous allons examiner une façon de suivre les
conventions fournies par le plugin.
Lancez l'application d'exemple de cette section et regardez la page
[Link]. Vous verrez un lien qui vous permet d'obtenir votre bonjour. Ce
lien a une URL de [Link], et lorsque vous cliquez dessus, la méthode
execute de la classe [Link], également une classe ActionSupport,
s'exécute. La page d'affichage rendue une fois que la méthode a renvoyé un
succès est la page [Link].
Rien de tout cela n'utilise XML. Au lieu de cela, cela se produit parce que
les conventions de nommage standard attendues par le plugin Convention
sont respectées. La première convention est que la classe ActionSupport de
[Link] est stockée dans le paquetage appelé
[Link],[Link]. Un plugin par défaut consiste à
rechercher toute classe ActionSupport dans les structures de paquetage se
terminant par "action". La seconde convention est que la classe
ActionSupport est étendue par [Link], définissant une méthode
execute.
[Link] est le lien, et lorsque le filtre rencontre une demande pour ce
lien, il l'associe à la méthode execute de la classe HelloAction - cela se
produit parce que le plugin a été utilisé.
Ainsi, le lien [Link] entraîne l'exécution de la méthode d'exécution
HelloAction et renvoie un résultat de réussite. Étant donné que le plugin
Convention est utilisé, la page de vue [Link] est affichée dans le
navigateur. Cette page se trouve dans WEB-INF/content, où le plugin
s'attend à ce que toutes les pages de vue soient situées. Si le résultat renvoyé
était "error" ou "input", la page rendue aurait été [Link] ou hello-
[Link].
Plugin de configuration
Précédemment, nous avons vu comment le plugin Configuration pouvait
nous aider à voir les détails de la configuration de notre application.
Lorsque vous utilisez le plugin Convention, il est également utile d'utiliser
le plugin Configuration lorsque votre application est en cours de
développement.
Ouvrez l'application d'exemple et regardez la page d'accueil, où vous verrez
un lien vers la configuration. Cliquez sur ce lien, puis sur le lien hello - sous
Actions dans le menu de gauche. Vous verrez la configuration de l'action
hello, sa classe d'action, le résultat et la page de visualisation
correspondante.

Vous pouvez aller au-delà des conventions de nommage fournies par le

plugin Convention en utilisant des annotations, également fournies par le
plugin. Par exemple, dans une application Struts 2 courante, la méthode
input de la classe ActionSupport est exécutée en premier. Cette méthode
définit les valeurs par défaut du champ du formulaire, puis la classe execute
de la classe ActionSupport est exécutée à nouveau lorsque le formulaire a
été soumis, ce qui valide les données saisies par l'utilisateur et les
enregistre.
Sur la page d'accueil de l'application se trouve un lien vers Register - qui
suit le flux de travail. Le lien a une valeur de [Link], et si vous
regardez la classe [Link], vous pouvez voir la méthode
d'entrée accompagnée d'une annotation Action.
@Action("register-input")
public String input() throws Exception {
 [Link]("Dans la méthode d'entrée de la classe Register") ;

retour INPUT ;
}
L'annotation Action informe Struts que la méthode annotée doit être
exécutée lorsque la valeur du lien d'action est égale à la valeur de
l'annotation Action - [Link]. Ainsi, lorsque [Link] est le
lien, il appelle la méthode input de la classe RegisterAction.
De nouveau, sur la page d'accueil de l'application, il y a un lien pour
s'inscrire au dessin, dont l'URL est [Link]. Le résultat
renvoyé est "input" et, selon les normes du plugin Convention, la page
affichée est [Link], qui se trouve dans WEB-INF/content. Cette
page affiche une balise de formulaire dont la valeur de l'attribut action est
register. Lorsque le formulaire est soumis, la méthode execute de
RegisterAction est exécutée, et comme elle renvoie un résultat de succès, la
page de vue rendue est [Link].
Valeurs de configuration
Précédemment, nous avons inclus les valeurs des paramètres de
configuration dans le fichier [Link].
<constant name="[Link]" value="true" />
Lorsqu'un fichier [Link] n'est pas utilisé, les valeurs des paramètres
peuvent être définies dans [Link], à l'aide de paramètres de filtre.
<filtre>
<nom du filtre>struts2</filtre-name>
<filter-
class>[Link]
Filter</filter-class>
<init-param>
<param-name>[Link]</param-name>
<param-value>vrai</param-value>
 </init-param>
</filter>
Nous n'avons examiné ici qu'une petite partie de ce que le module
d'extension Convention peut nous apporter pour réduire ou éliminer la
nécessité de configurer les applications à l'aide d'un fichier XML. Le
module d'extension Convention offre de nombreuses autres façons de faire
correspondre de nombreuses actions à une méthode, ce qui permet d'obtenir
de nombreuses pages de vue différentes, des erreurs dans les vues, et bien
d'autres choses encore.
Présentation des intercepteurs
Vous trouverez l'exemple d'application et le code associé à l'adresse
suivante : [Link]
Pour terminer ce chapitre, nous allons nous plonger un peu plus dans le
fonctionnement du framework Struts 2. Nous allons examiner certaines
classes sur lesquelles le framework s'appuie fortement pour réaliser
l'essentiel de ce qui est nécessaire lors de l'exécution d'une action. Dans
l'exemple de projet, vous pouvez voir un lien d'enregistrement. Celui-ci est
associé à la méthode execute de la classe Register dans le fichier de
configuration XML. Cependant, avant que la méthode execute puisse être
exécutée, le framework effectue un grand nombre de travaux sous le capot.
Ce travail comprend

Gestion des exceptions générées

En cas de correspondance avec les valeurs des noms, les
paramètres de requête sous forme de chaîne sont convertis en
champs d'instance dans la classe Registre.
Appel de la validation XML externe et/ou de la méthode
validate
Lorsque la méthode d'exécution est terminée, il reste encore du travail à
faire :

Là encore, toute exception générée doit être traitée

Les champs d'instance de la classe Registre doivent être
convertis en valeurs de type chaîne de caractères afin de
 pouvoir être affichés sur la page de visualisation.
La page d'affichage correcte doit être transmise, en fonction de
la chaîne de caractères résultant de l'exécution de la méthode.
Cette liste de tâches n'est en aucun cas exhaustive - de nombreuses autres
tâches sont effectuées avant et après l'exécution de l'action.
L'utilisation de Struts 2 pour réaliser tout cela présente un avantage majeur :
tout est fait automatiquement. Cela signifie que le développeur peut se
concentrer sur tout le reste - la logique du contrôleur, les couches d'accès
aux services et aux données, les modèles de domaine, etc.
Les tâches effectuées par le framework avant l'exécution d'une action et par
la suite sont toutes réalisées par des intercepteurs. Il s'agit de classes
standard en Java, incluses dans le core jar et exécutées dans un ordre
déterminé.
Notre application d'exemple contient un nœud de package dans le fichier
[Link]. L'attribut du nœud de package est "extends" et sa valeur est
struts-default. Cette valeur indique au framework quelle pile d'intercepteurs
doit être exécutée avant et après les actions du package.
Parfois, la pile d'intercepteurs par défaut ne convient pas à vos besoins.
Vous pouvez alors utiliser des intercepteurs qui ne font pas partie de la pile
par défaut. Pour une action ou l'ensemble du paquet, une pile d'intercepteurs
différente peut être spécifiée pour le paquet ou l'action à utiliser.
Ci-dessous, vous pouvez voir comment indiquer au registre que l'action doit
utiliser les intercepteurs timer et logger en plus de ceux fournis par la pile
par défaut.
<action name="register"
class="[Link]"
method="execute">
<interceptor-ref name="timer" />
<interceptor-ref name="logger" />
<interceptor-ref name="defaultStack">
<param name="[Link]">true</param>
 <param name="[Link]">ERROR</param>
</interceptor-ref>
<result name="success">[Link]</result>
<result name="input">[Link]</result>
</action>
L'intercepteur logger enregistre le début et la fin de l'exécution de l'action,
tandis que l'intercepteur timer enregistre le temps en millisecondes que
prend l'exécution de l'action. Utilisés ensemble, ces intercepteurs
fournissent un bon retour d'information au développeur.
Dans le code ci-dessus, nous avons inclus trois nœuds interceptor-ref,
chacun avec une valeur d'attribut name. Nous indiquons au framework
d'utiliser les intercepteurs defaultStack, logger et timer pour l'action
register. Dans defaultStack se trouvent les intercepteurs qui seraient
normalement exécutés pour les actions.
Alors, comment avons-nous su que nous avions besoin de la valeur timer
pour l'attribut name ? En fait, comment savions-nous qu'il existait un
intercepteur timer ? Si vous consultez la documentation de Struts 2 à la
page Intercepteurs, vous pouvez voir tous les intercepteurs qui font partie
de Struts 2, ainsi que la valeur du nom de chaque intercepteur. Cette page
indique également tous les intercepteurs qui appartiennent à la pile
defaultStack et ceux qui lui sont extérieurs.
Une autre chose à noter dans le code est la présence des nœuds param.
Ceux-ci fournissent des valeurs aux méthodes de l'intercepteur d'exception,
setLogEnabled et setLogLevel. Lorsque les valeurs ERROR et true sont
fournies, le framework enregistre toutes les exceptions que le code n'attrape
pas et s'assure qu'elles sont enregistrées au niveau ERROR.
Ouvrez l'application d'exemple, puis les instructions du README. Suivez-
les pour construire l'application, la déployer et l'exécuter. Regardez la sortie
qui va dans la console de la JVM et voyez les messages du logger et du
timer interceptors. Ils devraient ressembler à ceci :
INFO : Démarrage de la pile d'exécution pour l'action //enregistrer
 Nov 20, 2010 9:55:48 AM
[Link] info
INFO : Fin de la pile d'exécution de l'action //register
Nov 20, 2010 9:55:48 AM
[Link] info
INFO : L'exécution de l'action /register!execute a pris 177 ms.
Si vous voulez que les intercepteurs timer et logger soient exécutés pour
toutes les actions d'un paquet, vous devez insérer le code suivant dans le
fichier [Link] :
<package name="basicstruts2" extends="struts-default" >
<intercepteurs>
<interceptor-stack name="appDefault">
<interceptor-ref name="timer" />
<interceptor-ref name="logger" />
<interceptor-ref name="defaultStack" />
</interceptor-stack>
</interceptors>

<default-interceptor-ref name="appDefault" />

<!-- le reste du paquet est omis -->

</package>
Dans ce code, le nœud de l'intercepteur est utilisé pour définir une nouvelle
pile d'intercepteurs, comprenant cette fois les intercepteurs defaultStack,
logger et timer, que nous nommons alors appDefault. Le nœud default-
interceptor-ref est ensuite utilisé pour spécifier que la pile appDefault doit
être utilisée pour toutes les actions du nœud package. Ainsi, les
intercepteurs de logger et de timer sont exécutés pour toutes les actions du
paquet.
Tous les autres intercepteurs sont toujours exécutés dans ces deux exemples
parce que nous avons inclus defaultStack en tant que nœud interceptor-ref.
Lorsque les intercepteurs spécifiques que vous souhaitez pour un paquet ou
une action sont spécifiés, ils sont les seuls à être exécutés. Ainsi, dans
l'exemple, si nous omettons le nœud intercepteur-ref defaultStack, les seuls
intercepteurs exécutés seront les intercepteurs timer et logger.
Chapitre 8 : Comment apprendre le
développement web backend
Alors que le développement du front-end concerne ce que les utilisateurs
voient sur leur écran lorsqu'ils ouvrent un site web, le développement du
back-end va beaucoup plus loin. Lorsque vous ouvrez un site web, un
serveur répond à votre demande quelque part dans le monde, en vous
fournissant des fichiers HTML et CSS. Ce serveur n'est rien d'autre qu'un
ordinateur, mais il s'agit d'un ordinateur très perfectionné dépourvu de tous
les périphériques d'un ordinateur standard - un clavier, une souris, etc.
Le développement du backend est l'endroit où les ordinateurs sont
programmés. Il n'est pas nommé ainsi parce qu'il fonctionne dans votre dos
- les utilisateurs du site web n'ont jamais vraiment accès au backend. Tout
ce qu'ils font, c'est communiquer avec le serveur, directement ou
indirectement.
Faut-il connaître le Frontend pour apprendre le développement du
Backend ?
Non, mais il est utile d'avoir quelques connaissances. En tant que
développeur backend, vous n'avez pas à vous préoccuper de ce qui se passe
dans les fichiers JavaScript, CSS ou HTML que l'utilisateur voit sur son
navigateur. Votre tâche consiste plutôt à vous concentrer sur les
performances du serveur, le débit et le code du serveur.
Qu'est-ce que le développement backend ?
Certains pensent que les développeurs backend sont ceux qui codent des
applications capables de répondre à une requête HTTP. Mais cela va
beaucoup plus loin. Les développeurs backend peuvent faire bien plus
qu'écrire un script de serveur. Ils peuvent mettre en place des serveurs proxy
inversés et développer des moyens d'accélérer un site web, comme la
compression, et ils peuvent également mettre en place des environnements
docker de production.
Quelles sont les compétences requises ?
Au minimum, les compétences requises sont les suivantes :
 Solide connaissance du langage de programmation dans lequel
vous écrirez les serveurs HTTP, tel que Java.
Utilisation de cPanel ou d'un terminal bash pour gérer l'hôte
Savoir travailler avec des systèmes de contrôle de versions
(VCS) tels que git pour gérer les constructions et les déployer.
Tout comme un logiciel a des spécifications minimales recommandées, les
développeurs de backend ont les mêmes exigences :

Vous devez savoir comment utiliser NGiNX pour la gestion

des serveurs et des fichiers statiques.
Compétences en gestion de bases de données telles que
SQL/NoSQL
Savoir comment écrire un code robuste et sûr, exécuter des
applications avec des privilèges limités dans un conteneur
Docker et assurer une protection contre les attaques DoS.
Connaissance de l'équilibrage de charge et de l'autoscaling
Les exigences minimales
Les exigences minimales pour être un développeur backend sont les
suivantes :

Apprendre un langage de backend - Il existe de nombreux

choix de langages de programmation de backend, le plus
populaire étant Java.
Apprendre à gérer l'hébergement - Il n'est plus nécessaire
d'acheter manuellement des serveurs, de les installer, de les
connecter, etc. Avec l'informatique en nuage, deux options
s'offrent à vous : l'hébergement géré ou l'hébergement en
nuage. La différence est que, bien que les deux soient détenus
et exploités par leurs sociétés, l'hébergement géré est convivial,
offrant des outils pour vous aider à surveiller l'utilisation, voir
le système de fichiers, gérer les courriels du domaine, charger
et télécharger des fichiers via le serveur, etc. Lorsque vous
aurez acquis de l'expérience, vous pourrez envisager de passer
à un fournisseur d'hébergement en nuage, ce qui vous
permettra de vous mettre davantage à l'épreuve.
 Apprendre ce que sont les systèmes de contrôle de version -
Git n'est pas la seule solution de contrôle de version, mais c'est
la plus facile à utiliser et à comprendre.
Principes de programmation
Il existe certains principes que tous les développeurs devraient respecter :

KISS - Keep It Simple, Stupid (rester simple, stupide) - cela se

passe d'explications, mais il faut éviter d'écrire des codes
ambigus et compliqués.
DRY - Don't Repeat Yourself - ne dupliquez pas votre code. Si
vous devez réutiliser du code à plusieurs endroits, écrivez-le
dans des méthodes
YAGNI - You Ain't Gonna Need It - si vous vous demandez si
vous avez besoin de fonctions ou de codes supplémentaires,
vous devez repenser le code.
Un code propre plutôt qu'intelligent - gardez votre code
propre et oubliez d'essayer d'être intelligent
N'optimisez pas prématurément - vous ne savez pas où se
situent vos problèmes tant que le code n'est pas écrit, alors
oubliez l'optimisation jusqu'à ce qu'elle soit terminée.
Responsabilité unique - veillez à ce que vos modules et vos
classes soient responsables d'une seule fonctionnalité.
Composition plutôt qu'héritage - lorsque les objets ont un
comportement complexe, celui-ci doit provenir d'instances
d'objets du comportement plutôt que de l'héritage et de l'ajout
de comportements.
Fail Fast, Fail Hard - arrêtez une opération dès qu'une erreur
inattendue se produit, et votre solution sera plus stable.
Emballages

Essayez d'utiliser des domaines pour structurer vos paquets, et

non des couches techniques.
Essayez d'adopter des dispositions qui utilisent le masquage
d'informations et l'encapsulation plutôt que d'utiliser des
préoccupations techniques pour organiser votre code - cela
permet d'éviter les utilisations abusives.
 N'exposez jamais les classes (fonctionnement interne) de vos
paquets - elles sont uniquement destinées à un traitement
interne.
Lorsqu'une classe n'est destinée à être utilisée qu'à l'intérieur
d'un paquetage, ne lui donnez pas un accès public.
Classes

Ne jamais autoriser l'instanciation d'une classe statique ; il faut

plutôt utiliser des constructeurs privés.
Les classes statiques doivent être sûres pour les threads,
immuables, sans état et ne doivent jamais être sous-classées.
Vous devez fournir vos classes statiques sans effets secondaires
et en tant qu'utilitaires, par exemple pour le filtrage des listes.
Héritage

La composition doit être préférée à l'héritage

Les champs protégés ne doivent jamais être exposés. Il faut
plutôt prévoir des accesseurs protégés
Si vous pouvez marquer une variable de classe comme finale,
faites-le
Si une classe n'attend pas d'héritage, marquez-la comme finale.
Une méthode doit être marquée comme finale à moins qu'une
sous-classe ne s'attende à la surcharger.
Ne créez pas de constructeurs par défaut sans logique
d'implémentation lorsque vous n'en avez pas besoin. Si vous
n'en spécifiez pas, Java fournit automatiquement un
constructeur par défaut
Général

Les caractères génériques étendus ne doivent être utilisés que

lorsqu'une structure fournit une valeur. Les supercaractères
génériques doivent être utilisés lorsque des valeurs sont
introduites dans une structure - un caractère générique ne doit
jamais être utilisé dans les deux cas.
Ne jamais écrire de singletons dans le style des Design Patterns
- cela peut être valable dans le langage C++ mais n'est pas
approprié pour Java.
Les exceptions contrôlées doivent être utilisées pour les
conditions récupérables, et les exceptions d'exécution doivent
être utilisées pour les erreurs de programmation.
Les exceptions doivent être traitées au niveau du domaine
N'enregistrez pas les exceptions à l'endroit où elles sont
lancées. Elles doivent être enregistrées à l'endroit où elles sont
gérées afin d'éviter de remplir les fichiers journaux de bruits
inutiles.
Conclusion
Tout d'abord, je tiens à vous remercier d'avoir pris le temps de lire mon
guide. J'espère sincèrement qu'il vous a aidé.
J'aurais pu approfondir ce sujet ; Java pour le développement de backend
est un sujet sans fin. Au lieu de cela, j'ai choisi de vous donner les bases,
quelque chose sur lequel vous pourrez vous appuyer lorsque vous écrirez
vos propres applications. Ce n'est pas facile, et c'est incroyablement
complexe, mais c'est quelque chose que vous pouvez apprendre avec le
temps et beaucoup de pratique.
Il est évident que la première étape consiste à se familiariser avec le codage
en langage Java. Ce n'est qu'ensuite que vous pourrez envisager de passer
au développement, en particulier au développement backend. Je vous
recommande également d'apprendre les bases du développement frontal, car
dans de nombreux cas, vous ne pouvez pas faire un travail sans connaître
l'autre. En effet, dans de nombreux endroits, les développements frontend et
backend se chevauchent dans une certaine mesure.
À partir de là, plusieurs options s'offrent à vous. Tout d'abord, mettez en
pratique tout ce que vous avez appris dans ce livre. Deuxièmement,
cherchez en ligne - il existe de nombreux tutoriels en ligne, payants ou
gratuits, qui vous permettront d'aller plus loin dans votre parcours de
développement. Troisièmement, ne vous arrêtez pas. La pratique n'est qu'un
aspect de la question. Lorsque vous entamez une carrière dans le
développement, ou même que vous l'abordez comme un hobby, il est
impératif que vous restiez au courant des derniers développements et
changements - si vous ne le faites pas, vous serez rapidement distancé.
Enfin, permettez-moi de profiter de cette occasion pour vous souhaiter le
meilleur dans votre parcours de développement de backend.
Références
"Building Java Web Application Using Hibernate with Spring - My Experiments with Technology"
(Construire une application Web Java en utilisant Hibernate et Spring - Mes expériences
avec la technologie). [Link], [Link]/blog/2013/11/21/student-
enrollment-using-hibernate-with-spring/.

"Comment créer une application Web Struts 2". [Link], [Link]/getting-

started/[Link].
"Comment installer Eclipse pour la programmation Java (sur Windows, Mac OS et Ubuntu)".
[Link],
[Link]/home/ehchua/programming/howto/EclipseJava_HowTo.html.
"Comment installer le JDK 8 (sur Windows, Mac OS, Ubuntu) et commencer à programmer en
Java". [Link],
[Link]/home/ehchua/programming/howto/JDK_Howto.html.
Rose, Scarlett. "Java vs JavaScript : Tout ce que vous devez savoir !" Medium, 6 déc. 2019,
[Link]/@scarlett8285/java-vs-javascript-tout-ce-qu'il-faut-savoir-
3362b5fa4128#:~:text=Java%20is%20a%20compiling%20language.
"Spring | Guides". [Link], [Link]/guides.
"Qu'est-ce qu'un développeur backend ? Skills to Become a Web Developer" (Compétences pour
devenir développeur Web). [Link], 23 oct. 2019, [Link]/what-is-backend-
[Link].
"Pourquoi et quand choisir Java pour le développement d'applications dorsales ? SCAND,
[Link]/company/blog/why-use-java-for-backend-development/.
Wittpohl, Milan. "Le backend avec Java et Spring Boot - Tutoriel : Full Stack Web App -
[Link]". [Link], [Link]/projects/tutorials/Full-Stack-
Web-App/the-backend-with-java-and-spring.