Atelier 1 Spring boot

Les couches Modèle, Persistance et

Service d'une application Web MVC
CRUD
Emna KALLEL

emna.kallel@enetcom.usf.tn
L’architecture Microservices

Les micro services sont une approche d’architecture et de développement

d’une application composées de petits services.
L’idée étant de découper un grand problème en petites unités implémentées
sous forme de micro-services.
Chaque service est responsable d’une fonctionnalité.
Chaque micro-service est développé, testé et déployé séparément des autres.
Chaque micro-service est développé en utilisant une technologie qui peut être
différente des autres. (Java, C++, PHP, Python, …).
Chaque service tourne dans un processus séparé.
Utilisant des mécanisme de communication légers (REST).
La seule relation entre les différents micro-services est l’échange de données
effectué à travers les différentes APIs qu’ils exposent.
Lorsqu’on les combinent, ces micro-services peuvent réaliser des opérations
très complexes.
2
L’architecture Microservices

3
L’architecture Microservices

Le développement d’une application autour de l'architecture

Microservices en Java exige l’utilisation d’un framework qui facilite

le développement d‘une application totalement autonome.

 Le framework Spring Boot.

4
Spring Boot Qu’est-ce que c’est ?

Une technologie de développement d’application WEB

(framework) qui dispense d’écrire du code Java dans les
interfaces

Spring Boot est un framework qui facilite le développement

d'applications fondées sur Spring en offrant des outils
permettant d'obtenir une application packagée en jar,
totalement autonome.

5
Utilisations possibles de spring boot

1. Seulement pour le développement de la partie Backend

 Partie Backend sous forme de web services/api REST

 Pour le web: Partie Frontend développé avec Angular ou

React ou autres

 Pour le Mobile: Développement native iOS ou Android

ou développement hybride (Flutter)

2. Pour le développement du Backend et du Frontend

 Développement Web MVC rendu coté Serveur en
utilisant Thymeleaf et Bootstrap

6
Les couches de Spring boot

Emna KALLEL 7
 Outils à installer
• 1- Jdk 8
• 2- Spring tools 4 for eclipse (sts)
• 3- Xamp
• 4- Postman
Tous ces outils sont dans disponibles dans ce
lien drive: outils for spring boot - Google Drive

Emna KALLEL 8
 objectifs
• Création d’un premier projet Spring boot,
• Création de l’entité Produit et de son interface
Repository,
• Configuration du fichier application.properties,
• Tester les opérations CRUD sur l’entité Produit,
• Création de la couche Service,

Emna KALLEL 9
1. Création d’un premier projet Spring boot,
2. Création de l’entité Produit et de son interface
Repository,
3. Configuration du fichier application.properties,
4. Tester les opérations CRUD sur l’entité Produit,
5. Création de la couche Service,

Emna KALLEL 10
 Création d’un premier projet Spring
boot
• Lancer sts et Créer un projet « Spring Strarter Project » (si vous ne le
trouvez pas cherchez dans Others)

Emna KALLEL 11
 Création d’un premier projet Spring
boot
• Next Séléctionner les dépendances nécessaires

Emna KALLEL 12
Emna KALLEL 13
1. Création d’un premier projet Spring boot,
2. Création de l’entité Produit et de son interface
Repository,
3. Configuration du fichier application.properties,
4. Tester les opérations CRUD sur l’entité Produit,
5. Création de la couche Service,

Emna KALLEL 14
 Création de l’entité Produit et de son
interface Repository
• Créer une nouvelle classe java dans com.gt.produits (main)

Emna KALLEL 15
Créer une classe java bean

Emna KALLEL 16
 Une classe java bean
• Contient:
– Des attributs privés
– Un constructeur par défaut
– Un constructeur avec arguments
– Les getters et les setters
– toString

Emna KALLEL 17
Définition des arguments

Emna KALLEL 18
Générer un constructeur par défaut,
Getters and Setters, toString

Emna KALLEL 19
Générer un constructeur avec
argument

Emna KALLEL 20
Produit.java

Emna KALLEL 21
Ajouter les annotations de persistance

Emna KALLEL 22
 Créer l’interface repository
• Pour pouvoir enregistrer, modifier et de
supprimer les objets du produit au niveau de
la DB, spring nous donne un mécanisme très
puissant  Repository
• Pour chaque entité crée je dois créer son
interface repository pour pouvoir faire les
opérations CRUD

Emna KALLEL 23
 Créer l’interface repository
• Créer une nouvelle interface java dans
com.gt.produits (main)

Emna KALLEL 24
 Créer l’interface repository
Par convention le nom de l’interface doit se composer
du nom de l’entité suivi du mot Repository

Emna KALLEL 25
L’interface « ProduitRepository »

La classe entité Type de l’id

Emna KALLEL 26
1. Création d’un premier projet Spring boot,
2. Création de l’entité Produit et de son interface
Repository,
3. Configuration du fichier application.properties,
4. Tester les opérations CRUD sur l’entité Produit,
5. Création de la couche Service,

Emna KALLEL 27
Configuration du fichier application.properties

• Modifier le fichier src/main/resources/application.properties

comme suit :

spring.datasource.url=jdbc:mysql://localhost:3306/spring_DB?crea
teDatabaseIfNotExist=true&useSSL=false&serverTimezone=UTC
spring.datasource.username=root
spring.jpa.show-sql=true
spring.jpa.hibernate.ddl-auto=update

Emna KALLEL 28
 Etapes à suivre
• Lancer Xamp
• lancer les serveurs Apache et MySQL
• Lancer PhpMyAdmin
• Vérifier les bases de donnée existants

Emna KALLEL 29
Base de donnée existante avant
l’exécution du projet

Emna KALLEL 30
Exécution du projet

Emna KALLEL 31
Console

Emna KALLEL 32
Base de donnée existante après
l’exécution du projet

Emna KALLEL 33
1. Création d’un premier projet Spring boot,
2. Création de l’entité Produit et de son interface
Repository,
3. Configuration du fichier application.properties,
4. Tester les opérations CRUD sur l’entité Produit,
5. Création de la couche Service,

Emna KALLEL 34
 Interface: Injection de dépendance
Lors de la séparation d'un code en plusieurs classes, nous
avons une dépendance directe d'une classe a une autre.
Nous séparons le code général en une classe A et une
classe B. La classe A doit utiliser une méthode de la classe B.
public class A {
public static void main(String[] args)
B b = new B();
b.someMethod();
}
}

Le java fournit un moyen de simplifier la gestion des

dépendances : l'Interface. Les interfaces en java permettent
de définir des méthodes et leurs paramètres sans en définir
le code. Ces interfaces sont ensuite implémentées par les
Emna KALLEL 35
classes dont on dépend.
 Injection de dépendance: spring IOC
Pour faire de l'injection de dépendance, Spring boot utilise le
framework Spring IoC (inversion of control) qui utilise aussi
des annotations qui permettent de se passer d'une
description en détails dans un fichier XML. Parmis ces
annotations on peut trouver la plus connue @Autowired qui
indique à Spring de chercher une implémentation pour
l'injecter.

Emna KALLEL 36
 Modifier la classe
ProduitsApplicationTests
• Ecrire la méthode pour tester l’ajout d’un produit à la base de données,
modifier la classe src/main/test/com.gt.produits.ProduitsApplicationTests
comme suit :

@SpringBootTest
class ProduitsApplicationTests {
@Autowired
private ProduitRepository produitRepository;
@Test
public void testCreateProduit() {
Produit prod = new Produit("PC Dell",2200.500,new Date());
produitRepository.save(prod);
}
}

Emna KALLEL 37
 Run avec JUnit
Sélectionnez la méthode testCreateProduit puis clic droit/Run as
/JUnit test, puis vérifier l’insertion d’un produit dans la table produit,

Emna KALLEL 38
console

Emna KALLEL 39
 La table de la BD après l’éxecution

De la même manière tester les autres opérations

Emna KALLEL 40
 Chercher un produit

@Test
public void testFindProduit()
{
Produit p = produitRepository.findById(1L).get();
System.out.println(p);
}

Emna KALLEL 41
 Mettre à jour un produit

@Test
public void testUpdateProduit()
{
Produit p = produitRepository.findById(1L).get();
p.setPrixProduit(1000.0);
produitRepository.save(p);
}

Emna KALLEL 42
 Supprimer un produit

@Test
public void testDeleteProduit()
{
produitRepository.deleteById(1L);;
}

Emna KALLEL 43
 Lister tous les produits

@Test
public void testListerTousProduits()
{
List<Produit> prods = produitRepository.findAll();
for (Produit p : prods)
{
System.out.println(p);
}
}

Emna KALLEL 44
1. Création d’un premier projet Spring boot,
2. Création de l’entité Produit et de son interface
Repository,
3. Configuration du fichier application.properties,
4. Tester les opérations CRUD sur l’entité Produit,
5. Création de la couche Service,

Emna KALLEL 45
 L’interface ProduitService
• Créer, dans le package com.gt.produits.service l’interface
ProduitService

package com.gt.produits.service;
import java.util.List;
import com.gt.produits.entities.Produit;
public interface ProduitService {
Produit saveProduit(Produit p);
Produit updateProduit(Produit p);
void deleteProduit(Produit p);
void deleteProduitById(Long id);
Produit getProduit(Long id);
List<Produit> getAllProduits();
}

Emna KALLEL 46
 la classe ProduitServiceImpl
@Service
public class ProduitServiceImpl implements ProduitService {
@Autowired
ProduitRepository produitRepository;
@Override
public Produit saveProduit(Produit p) {
return produitRepository.save(p);
}
@Override
public Produit updateProduit(Produit p) {
return produitRepository.save(p);
}
@Override
public void deleteProduit(Produit p) {
produitRepository.delete(p);
}
Emna KALLEL 47
 la classe ProduitServiceImpl
@Override
public void deleteProduitById(Long id) {
produitRepository.deleteById(id);
}
@Override
public Produit getProduit(Long id) {
return produitRepository.findById(id).get();
}
@Override
public List<Produit> getAllProduits() {
return produitRepository.findAll();
}
}

Emna KALLEL 48