TP : Déploiement d’une application avec Spring Boot
1. Présentation de SpringBoot
1.1. Un projet Javaclassique
Une application Java est de nos jours principalement une application standalone (par
exemple un traitement de données en tâche de fond), ou une application Web (sur un
Tomcat, ou un serveur d’application).
Javaesttrèsbienoutillépourlamiseenœuvredetellesapplications:MavenetGradle pour la
gestion du cycle de vie, tests unitaires, une multitude de frameworks divers et variés, des
conteneurs pour exécuter les programmes.
Souvent, le démarrage d’un projet Java consiste à faire de la tuyauterie : mettre en place
les différentes librairies communément utilisées, faire attention aux différentes versions,
préparer la configuration d’accès aux bases de données.
Puis vient la phase de déploiement : dépôt d’un war dans un conteneur ? Ce war
contient-il des jars embarqués, ou faut-il mettre à jour les jars partagés du Tomcat ?
Comment gérer les fichiers de propriétés ? Et la supervision : y a-t-il des points d’entrées
pour surveiller la santé de notre application ?
1.2. SpringBoot
Spring Boot apporte des solutions à ces problèmes. Avant de voir comment, voyons déjà
ce que Spring Boot n’est pas :
• ce n’est pas un framework, du moins pas comme un Spring Security, Guava, ou autre
• un générateur de code ; autrement dit, Spring Boot fait partie intégrante du projet, y
compris lors de l’exécution de l’application
• un outil de maquettage ; il sert à faire des applications complètes
Spring Boot simplifie la vie du développeur en :
• utilisant des librairies souvent utilisées, dans des versions cohérentes
• auto-configurantlescomposantsquisontdétectéssurleclasspath(parexemple,si Spring
Boot détecte le driver Java de Mongo, ou un driver JDBC, ou Tomcat, etc., alors il
configure automatiquement un ensemble de Bean (au sens Spring) pour utiliser ces
composants)
• permemttant de personnaliser les composants, pour passer outre l’auto- configuration
• simplifiant la gestion des propriétés provenant de sources différentes
• exposant des points d’entrées pour la surveillance de l’application
• simplifiant le déploiement (un jar unique, ou un war pour Tomcat)
Cenesontlàqu’[Link],consulter les
références suivantes :
Références
• Guide de référence Spring Boot
• La plupart des exemples sur [Link] utilisent SpringBoot
2. Déroulement de l’atelier
Nous allons créer une application en partant de zéro. Cette application permettra de
générer les étudiants, les données seront stockées dans une base de données MySQL,
puis exposer des services web REST pour interroger ces données.
3. Première partie : introduction à Spring Boot
3.1. Création initiale de l’application
Pour toutes les applications Spring, vous devez commencer par Spring Initializr. Initializr
offre un moyen rapide d'extraire toutes les dépendances dont vous avez besoin pour une
application et fait une grande partie de la configuration pour vous. Cet exemple n'a
besoin que de la dépendance Web, JPA, REST Repository, Devtools et MySQL Driver.
L'image suivante montre le Initializr configuré pour cet exemple de projet:
1. Après la création de projet :
• Lancer la commande : mvn eclipse :eclipse pour rendre le projet un projet eclipse,
• Importer le sous Eclipse.
2. Analyse le contenu de [Link] :
Pour utiliser Spring Boot, le plus simple est de faire dépendre son pom du pom
[Link]’hériterdepropriétés,deversionscohérentesde librairies,
etc.
Projet parent dans le pom
<parent>
<groupId>[Link]</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>[Link]</version>
</parent>
Ensuite,onpeututiliserdesstartersproposésparSpringBootquicorrespondentàun
typed’[Link]écessaires,etlaconfigurationqui va avec.
Voici quelques starters :
• batch
• websocket
• mail
• security
A noter que pour les starters, on n’a pas spécifié de version. En effet, le projet parent
possède un bloc dependencyManagementqui définit les versions préconisées (et
cohérentes entre-elles).
Pour indiquer que nous utilisons Java 8, il faut en général le préciser à plusieurs endroits
dans le pom (version source, version target). Ici, il suffit de positionner la propriété
[Link]:
Version de Java
<properties>
<[Link]>1.8</[Link]>
</properties>
Dans lecode
Une application Spring Boot est une application normale, avec unmain, et des
annotations :
[Link]
package [Link];
import [Link];
import [Link];
@SpringBootApplication
public class DemoApplication {
public static void main(String[] args) {
[Link]([Link], args);
}
L’annotation @SpringBootApplicationest une méta-annotation qui déclenche
l’auto-configuration et le scan de composants (au sens Spring classique)
Pour démarrer l’application, [Link]
Sionexécutel’application,quinefaitrienpourlemoment,onpeutnéanmoinsvoirque les logs et
JMX sont en place :
3. Lancer le projet : $ mvn spring-boot:run
3.2. Configuration de la base de données et le Framework de persistance
Spring Boot est livré avec un mécanisme intégré pour la configuration des applications à l'aide d'un
fichier appelé [Link]. Il se trouve dans le dossier src / main / resources,
comme illustré dans la figure suivante.
4. Dansle fichier [Link], configurer les paramètres de connexion à la base de
données et quelques paramètres liés au Framework de persistance :
# ===============================
# = DATA SOURCE
# ===============================
# Connection url for the database "boot"
[Link] =
jdbc:mysql://localhost:3306/boot?useUnicode=true&useJDBCCompliantTimezoneShift=true&useLegacyDatetimeCode=fa
lse&serverTimezone=UTC
# Username and password
[Link] = root
[Link] =
# ===============================
# = JPA / HIBERNATE
# ===============================
# Use [Link].* for Hibernate native properties (the prefix is
# stripped before adding them to the entity manager).
# Show or not log for each sql query
[Link]-sql = true
# Hibernate ddl auto (create, create-drop, update): with "update" the database
# schema will be automatically updated accordingly to java entities found in
# the project
[Link]-auto = update
5. Créer la base de données “boot” sous MySQL.
3.3. Création des classes métiers
6. Créer la classe « Student » dans un sous package du package principal (ici : [Link]):
package [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
@Entity
public class Student {
@Id
@GeneratedValue(strategy=[Link])
private int id;
private String nom;
private String prenom;
@Temporal([Link])
private Date dateNaissance;
public Student() {
super();
}
public int getId() {
return id;
}
public void setId(int id) {
[Link] = id;
}
public String getNom() {
return nom;
}
public void setNom(String nom) {
[Link] = nom;
}
public String getPrenom() {
return prenom;
}
public void setPrenom(String prenom) {
[Link] = prenom;
}
public Date getDateNaissance() {
return dateNaissance;
}
public void setDateNaissance(Date dateNaissance) {
[Link] = dateNaissance;
}
7. Lancer le projet et vérifier si la table « student » est créé.
3.4. Création des repository
Spring Data JPA fournit une implémentation de la couche d’accès aux données pour une application
Spring.
C’est une brique très pratique car elle permet de ne pas réinventer la roue de l’accès aux données à
chaque nouvelle application et donc de se concentrer sur la partie métier.
8. Créer l’interface « StudentRepository » dans un sous package de package principal :
package [Link];
import [Link];
import [Link];
publicinterface StudentRepository extends JpaRepository<Student, Integer> {
Dans l’interface ajouter les méthodes :
Student findById(intid);
@Query("select year([Link]) as annee, count(*) as nbr from Student s group by year([Link])
order by year([Link])")
Collection<?>findNbrStudentByYear();
3.5. Création des contrôleurs REST
REST signifie REpresentational State Transfer. Il est développé par Roy Thomas Fielding, qui a
également développé HTTP. Le principal objectif des services Web RESTful est de rendre les
services Web plus efficaces. Les services Web RESTful tentent de définir des services à l'aide des
différents concepts déjà présents dans HTTP. REST est une approche architecturale, pas un
protocole.
Il ne définit pas le format d'échange de messages standard. Nous pouvons créer des services REST
avec XML et JSON. JSON est un format plus populaire avec REST. L'abstraction de clé est une
ressource dans REST. Une ressource peut être n'importe quoi. Il est accessible via un identificateur
de ressource uniforme (URI).
9. Créer la classe « StudentController » dans un sous package de package principal :
@RestController
@RequestMapping("students")
publicclassStudentController {
@Autowired
private StudentRepository studentRepository;
@PostMapping("/save")
publicvoid save(@RequestBody Student student){
[Link](student);
}
@DeleteMapping("/delete/{id}")
publicvoid delete(@PathVariable (required = true) String id){
Student s = [Link]([Link](id));
[Link](s);
}
@GetMapping("/all")
public List<Student>findAll(){
return [Link]();
}
@GetMapping(value = "/count")
publiclongcountStudent() {
[Link]();
}
@GetMapping(value = "/byYear")
public Collection<?>findByYear() {
[Link]();
}
}
3.6. Tester les contrôleurs
Afin de tester les différents services, installer l’extension « Advanced Rest Client » ou « Postman ».
Création :
Liste des étudiants :
10. Tester les autres services.