dans ce cours, vous apprendrez les principes fondamentaux de framework spring boot

1. Spring Boot, Spring Data JPA – Rest API
Spring Boot est un framework open source basé sur
Java utilisé pour créer un micro service. Il est
développé par Pivotal Team et est utilisé pour créer
des applications autonomes et prêtes pour la
production. Ce chapitre vous donnera une introduction
à Spring Boot et vous familiarisera avec ses concepts
de base.
Qu'est-ce qu'un micro-service ?
Micro Service est une architecture qui permet aux développeurs de
développer et de déployer des services de manière indépendante. Chaque
service en cours d'exécution a son propre processus, ce qui permet
d'obtenir le modèle léger pour prendre en charge les applications métier.
Avantages
Les micro services offrent les avantages suivants à ses développeurs :
Déploiement facile
Évolutivité simple
Compatible avec les conteneurs
Configuration minimale
Moins de temps de production
Jaouad assabbour

2. Qu'est-ce que Spring Boot ?
Spring Boot fournit une bonne plate-forme aux développeurs Java
pour développer une application Spring autonome et de qualité
production que vous pouvez simplement exécuter. Vous pouvez
commencer avec des configurations minimales sans avoir besoin
d'une configuration complète de Spring.
Avantages
Spring Boot offre les avantages suivants à ses développeurs -
Applications de spring faciles à comprendre et à développer
Augmente la productivité
Réduit le temps de développement
Buts
Spring Boot est conçu avec les objectifs suivants
-Pour éviter une configuration XML complexe dans Spring
-Pour développer plus facilement des applications Spring prêtes pour la
production
-Pour réduire le temps de développement et exécuter l'application en
toute autonomie
-Offrir un moyen plus simple de démarrer avec l'application
Jaouad assabbour

3. Pourquoi Spring Boot ?
Vous pouvez choisir Spring Boot en raison des fonctionnalités et
des avantages qu'il offre, comme indiqué ici -
-Il offre un moyen flexible de configurer les Java Beans, les
configurations XML et les transactions de base de données.
-Il fournit un traitement par lots puissant et gère les terminaux
REST.
Dans Spring Boot, tout est configuré automatiquement. aucune
configuration manuelle n'est nécessaire.
-Il offre une application basée sur des annotations
-Facilite la gestion des dépendances
Il comprend un conteneur de servlet intégré
Comment ça marche?
Spring Boot configure automatiquement votre application en fonction des
dépendances que vous avez ajoutées au projet en utilisant l'annotation
@EnableAutoConfiguration.
Par exemple, si la base de données MySQL se trouve sur votre chemin de
classe, mais que vous n'avez configuré aucune connexion à la base de
données, Spring Boot configure automatiquement une base de données en
mémoire.
Le point d'entrée de l'application Spring Boot est la classe contient
l'annotation @SpringBootApplication et la méthode principale.
Spring Boot analyse automatiquement tous les composants inclus dans le
projet en utilisant l'annotation @ComponentScan.
Jaouad assabbour

4. Démarreurs de démarrage de spring
Gérer la gestion des dépendances est une tâche difficile pour les grands
projets. Spring Boot résout ce problème en fournissant un ensemble de
dépendances pour la commodité des développeurs.
Par exemple, si vous souhaitez utiliser Spring et JPA pour accéder à la base
de données, il suffit d'inclure la dépendance spring-boot-starter-data-jpa
dans votre projet.
Notez que tous les démarreurs Spring Boot suivent le même modèle de
nommage spring-boot-starter- *, où * indique qu'il s'agit d'un type de
l'application.
Exemples
Regardez les démarreurs Spring Boot suivants expliqués ci-dessous pour
une meilleure compréhension -
La dépendance Spring Boot Starter Actuator est utilisée pour surveiller
et gérer votre application. Son code est indiqué ci-dessous -
La dépendance de Spring Boot Starter Security est utilisée pour Spring
Security. Son code est indiqué ci-dessous -
Jaouad assabbour

5. La dépendance Web Spring Boot Starter est utilisée pour écrire un Rest
Endpoints. Son code est indiqué ci-dessous -
Configuration automatique
Spring Boot AutoConfiguration configure automatiquement votre
application Spring en fonction des dépendances JAR que vous avez
ajoutées dans le projet.
Par exemple, si la base de données MySQL se trouve sur votre chemin de
classe, mais que vous n'avez configuré aucune connexion à la base de
données, alors Spring Boot configure automatiquement une base de
données en mémoire.
À cette fin, vous devez ajouter l'annotation @EnableAutoConfiguration
ou l'annotation @SpringBootApplication à votre fichier de classe
principal. Ensuite, votre application Spring Boot sera automatiquement
configurée.
Jaouad assabbour

6. Observez le code suivant pour une meilleure compréhension -
Application de démarrage de spring
Le point d'entrée de l'application Spring Boot est la classe contient
l'annotation @SpringBootApplication. Cette classe doit avoir la méthode
principale pour exécuter l'application Spring Boot. L'annotation
@SpringBootApplication inclut la configuration automatique, l'analyse
des composants et la configuration de Spring Boot.
Si vous avez ajouté l'annotation @SpringBootApplication à la classe,
vous n'avez pas besoin d'ajouter l'annotation
@EnableAutoConfiguration, @ComponentScan et
@SpringBootConfiguration. L'annotation @SpringBootApplication
inclut toutes les autres annotations.
Observez le code suivant pour une meilleure compréhension -
Jaouad assabbour

7. Component Scan
L'application Spring Boot analyse tous les beans et déclarations de
package lors de l'initialisation de l'application. Vous devez ajouter
l'annotation @ComponentScan pour votre fichier de classe afin d'analyser
vos composants ajoutés dans votre projet.
le code suivant pour une meilleure compréhension -
Jaouad assabbour

8. Création d’un projet
Pour créer un nouveau projet Spring Boot :
• Vous pouvez générer un projet Spring Boot facilement et rapidement à l’aide
d’un formulaire via une interface web ergonomique sur http://start.spring.io.
• Vous pouvez également vous rendre sur Eclipse STS, faire un «New »,
«Spring Starter Project ».
Dans les 2 cas, vous devrez configurez les informations de l’artifact, donnez un nom
à votre projet et choisir les starters correspondant aux fonctionnalités que vous voulez
mettre en place dans votre projet. Les autres paramètres peuvent être laissez par
défaut.
Prérequis
• Connaissances :
• API REST
• Installation : JDK, Maven 3.2
• Outils : IntelliJIDEA ou Eclipse
•
Architecture d’un projet
- /src
- /main
- /java : contenant tous les fichiers java de votre projet
- /ressources
- /static : contenant les fichiers web statiques (css,
js...)
- /templates : contenant les vues (html, php, jsp...)
- application.properties : fichier de configuration de votre
application
- /test
- /java : contenant vos classes de tests (unitaire,
intégration...)
- /target : contenant les différents fichiers générés après un
build maven
- pom.xml : fichier de configuration Maven de votre projet
Jaouad assabbour

9. Lancement d’un projet
Pour tester votre application, il suffit de lancer un simple « Run as Java
Application » sur le fichier contenant la méthode main de votre projet.
Exemple d’application Spring Boot
L’application que nous allons développer présentera les caractéristiques
suivantes :
• ce sera une application web
• elle exposera une API REST
• elle stockera les données dans une base de données H2
• elle persistera les données stockées
• elle proposera un accès sécurisé aux opérations REST
Jaouad assabbour

10. Les entités JPA
JPA permet de définir des entités (entities). Une entité est simplement une instance
d’une classe qui sera persistante (que l’on pourra sauvegarder dans / charger depuis
une base de données relationnelle). Une entité est signalée par l’annotation @Entity
sur la classe.
De plus, une entité JPA doit disposer d’un ou plusieurs attributs définissant un
identifiant grâce à l’annotation @Id. Cet identifiant correspondra à la clé primaire
dans la table associée.
Jaouad assabbour

11. Il existe un grand nombre d’annotations JPA servant à préciser comment la
correspondance doit être faite entre le modèle objet et le modèle
relationnel de base de données. Il est possible de déclarer cette
correspondance à l’aide du fichier XML orm.xml. Cependant, la plupart
de développeurs préfèrent utiliser des annotations.
La liste ci-dessous résume les annotations les plus simples et les plus utiles
pour définir une entité et ses attributs :
@Entity
Définit qu’une classe est une entité. Le nom de l’entité est donné par
l’attribut name (en son absence le nom de l’entité correspond au nom
de la classe).
@Id
Définit l’attribut qui sert de clé primaire dans la table. Il est recommandé
au départ d’utiliser un type primitif, un wrapper de type primitif ou une
String pour représenter un id. Pour les clés composites, la mise en œuvre
est plus compliquée. Afin de ne pas se compliquer inutilement la tâche, il
vaut mieux prévoir une clé simple pour chaque entité.
@Basic
Définit un mapping simple pour un attribut (par exemple VARCHAR
pour String). Si on ne souhaite pas changer la valeur des attributs par
défaut de cette annotation, alors il est possible de ne pas la spécifier
puisqu’elle représente le mapping par défaut.
@Temporal
Pour un attribut de type java.util.Date et java.util.Calendar, cette annotation
permet de préciser le type de mapping vers le type SQL (DATE, TIME
ou TIMESTAMP).
Jaouad assabbour

12. @Transient
Indique qu’un attribut ne doit pas être persistant. Cet attribut ne sera
donc jamais pris en compte lors de l’exécution des requêtes vers la
base de données.
@Lob
Indique que la colonne correspondante en base de données est un LOB
(large object).
Certaines annotations sont utilisées pour fournir des informations sur la
base de données sous-jacente :
@Table
Permet de définir les informations sur la table représentant cette entité en
base de données. Il est possible de définir le nom de la table grâce à
l’attribut name. Par défaut le nom de la table correspond au nom de
l’entité (qui par défaut correspond au nom de la classe).
@GeneratedValue
Indique la stratégie à appliquer pour la génération de la clé lors de
l’insertion d’une entité en base. Les valeurs possibles sont données par
l’énumération GenerationType. Si vous utilisez MySQL et la propriété
autoincrement sur une colonne, alors vous devez utiliser
GenerationType.IDENTITY (ce sera le cas pour les exemples de ce
cours). Si vous utilisez Oracle et un système de séquence, alors vous devez
utiliser GenerationType.SEQUENCE et préciser le nom de la
séquence dans l’attribut generator de @GeneratedValue.
@Column
Permet de déclarer des informations relatives à la colonne sur laquelle un
attribut doit être mappé. Si cette annotation est absente, le nom de la
colonne correspond au nom de l’attribut. Avec cette annotation, il est
possible de donner le nom de la colonne (l’attribut name) mais également
si l’attribut doit être pris en compte pour des requêtes d’insertion (l’attribut
insertable) ou de mise à jour (l’attribut updatable). Certains outils
Jaouad assabbour

13. sont capables d’exploiter les annotations pour créer les bases de données.
Dans ce cas, d’autres attributs sont disponibles pour ajouter toutes les
contraintes nécessaires (telles que length ou nullable) et donner ainsi
une description complète de la colonne.
Jaouad assabbour

14. JPA avec Spring Data
Spring Data est un projet Spring qui a pour objectif de simplifier
l’interaction avec différents systèmes de stockage de données : qu’il
s’agisse d’une base de données relationnelle, d’une base de données
NoSQL, d’un système Big Data ou encore d’une API Web.
Le principe de Spring Data est d’éviter aux développeurs de coder les
accès à ces systèmes. Pour cela, Spring Data utilise une convention de
nommage des méthodes d’accès pour exprimer la requête à réaliser.
Ajout de Spring Data JPA dans un projet Maven
Spring Data se compose d’un noyau central et de plusieurs sous modules dédiés à un
type de système de stockage et une technologies d’accès. Dans un projet Maven, pour
utiliser Spring Data pour une base de données relationnelles avec JPA, il faut déclarer
la dépendance suivante :
Notion de repository
Spring Data s’organise autour de la notion de repository. Il fournit une interface
marqueur générique Repository<T, ID>. Le type T correspond au type de l’objet géré
par le repository. Le type ID correspond au type de l’objet qui représente la clé d’un
objet.
L’interface CrudRepository<T, ID> hérite de Repository<T, ID> et fournit un ensemble
d’opérations élémentaires pour la manipulation des objets.
Pour une intégration de Spring Data avec JPA, il existe également l’interface
JpaRepository<T, ID> qui hérite indirectement de CrudRepository<T, ID> et qui fournit un
ensemble de méthodes pour interagir avec une base de données.
Pour créer un repository, il suffit de créer une interface qui hérite d’une des interfaces
ci-dessus.
Jaouad assabbour

15. À l’initialisation du contexte d’application, Spring Data JPA va fournir une
implémentation à toutes les interfaces héritant directement ou
indirectement de Repository<T, ID> et qui se trouvent dans le package
fr.epsi.b3.repositories ou un de ses sous-packages. Ainsi, il est possible
d’injecter un bean du type de l’interface d’un repository, l’implémentation
concrète étant à la charge de Spring Data JPA.
Jaouad assabbour

16. Exemple d’injection et d’utilisation d’un repository
Ajout de méthodes dans une interface de repository
L’interface JpaRepository<T, ID> déclare beaucoup de méthodes mais elles
suffisent rarement pour implémenter les fonctionnalités attendues d’une
application. Spring Data utilise une convention de nom pour générer
automatiquement le code sous-jacent et exécuter la requête. La requête est
déduite de la signature de la méthode (on parle de query methods).
La convention est la suivante : Spring Data JPA supprime du début de la
méthode les prefixes find, read, query, count and get et recherche la
présence du mot By pour marquer le début des critères de filtre. Chaque
critère doit correspondre à un paramètre de la méthode dans le même
ordre.
Jaouad assabbour

17. Il existe une abstraction PagingAndSortingRepository qui ajoute des
méthodes supplémentaires pour faciliter l'accès paginé aux entités :
Exemple 4. Interface PagingAndSortingRepository
Jaouad assabbour

18. Pour accéder à la deuxième page de User par une taille de page de 20, vous
pourriez faire quelque chose comme ceci :
En plus des méthodes de requête, la dérivation de requête pour les requêtes
de comptage et de suppression est disponible. La liste suivante montre la
définition d'interface pour une requête de comptage dérivé :
Exemple 5. Requête de comptage dérivé
La liste suivante montre la définition d'interface pour une requête de
suppression dérivée :
Exemple 6. Requête de suppression dérivée
Jaouad assabbour

19. Gestion des paramètres spéciaux
Pour gérer les paramètres dans votre requête, définissez les paramètres de
méthode comme déjà vu dans les exemples précédents. En plus de cela,
l'infrastructure reconnaît certains types spécifiques comme Pageable et
Sort, pour appliquer dynamiquement la pagination et le tri à vos requêtes.
L'exemple suivant illustre ces fonctionnalités :
Exemple 14. Utilisation de Pageable, Slice et Sort dans les méthodes de requête
Jaouad assabbour

20. Utilisation de @Query
L’annotation @Query permet de préciser la requête directement sur la
méthode elle-même :
Jaouad assabbour

21. Note
Le comportement par défaut de Spring Data JPA est de chercher la
présence de l’annotation @Query ou la présence d’une requête nommée JPA.
S’il n’en existe pas alors Spring Data JPA analyse la signature de la
méthode pour essayer d’en déduire la requête à exécuter.
Spring MVC
Spring MVC permet de construire des applications Web en Java. Comme son nom le
suggère, il utilise le principe du Modèle/Vue/Contrôleur (MVC) en association avec le
modèle IoC (Inversion of Control) du Spring Framework.
Spring MVC permet de bâtir des applications Web en se basant sur des technologies Java
déjà existantes (comme les JSP pour la création de vues).
Dépendance à Spring MVC
Pour utiliser Spring MVC, il faut tout d’abord déclarer sa dépendance dans
le fichier pom.xml de notre projet Maven :
Les contrôleurs
Un contrôleur est une classe Java portant l’annotation @Controller. De
manière générale, l’objectif d’un contrôleur est de réagir à une interaction
Jaouad assabbour

22. avec l’utilisateur. Pour une application Web, cela signifie que l’utilisateur
envoie une requête HTTP au serveur.
Pour que le contrôleur soit appelé lors du traitement d’une requête, il suffit
d’ajouter l’annotation @RequestMapping sur une méthode publique de la
classe en précisant la méthode HTTP concernée (par défaut GET) et le
chemin d’URI (à partir du contexte de déploiement de l’application) pris
en charge par la méthode.
Dans l’exemple ci-dessus, le contrôleur déclare la méthode getHome qui traite les
requêtes se terminant par / et la méthode addItem qui traite les requêtes se
terminant pas /item. La première n’accepte que les requêtes de type GET et la
seconde que les requêtes de type POST.
Il existe les annotations @GetMapping, @PutMapping,
@PostMapping, @DeleteMapping, @PatchMapping qui
fonctionnent comme l’annotation @RequestMapping sauf qu’il
Jaouad assabbour

23. n’est pas nécessaire de préciser la méthode HTTP concerné
puisqu’elle est mentionnée dans le nom de l’annotation :
L’annotation @RequestMapping peut être utilisée directement sur la
déclaration de classe pour donner des indications pour l’ensemble des
méthodes de cette classe. Par exemple, on peut préciser un chemin de base
pour l’URI :
Jaouad assabbour

24. La signature des méthodes de contrôleur
Spring MVC autorise une très grande diversité de signatures pour les
méthodes d’un contrôleur gérant les requêtes HTTP (appelées handler
methods). Hormis le nom de la méthode elle-même pour laquelle nous
avons toute liberté, il est possible de choisir parmi un choix très large pour
le type et le nombre des paramètres ainsi que le type de la valeur de retour
de la méthode.
Les paramètres
Pour la liste complète des types de paramètre supportés, reportez-
vous à la documentation officielle
À titre d’exemple, un méthode gérant les requêtes HTTP peut
accepter en paramètres :
La valeur d’un paramètre grâce à l’annotation @RequestParam.
Jaouad assabbour

25. La valeur d’un en-tête de la requête HTTP grâce à l’annotation
@RequestHeader
Jaouad assabbour

26. Jaouad assabbour

27. Une valeur dans le chemin de la ressource grâce à l’annotation
@PathVariable. Dans ce cas, il est possible de déclarer entre accolades une
variable dans le chemin de la ressource.
Jaouad assabbour