Architecture Logicielle

Cours 1

Introduction aux
Architectures en couche
(JEE)
Année universitaire 2020/2021

1
IEEE1471

o Doit être fermée à la modification et ouverte à

l’extension

o Doit communiquer avec d’autres applications

distantes.

o Doit fournir le service à différents type de

clients (Desk TOP, Mobile, SMS, http…)

2
Comment assurer?

o Doit fournir le service à différents type de

clients (Desk TOP, Mobile, SMS, http…)

3
Architecture Multi-couches

4
Architecture Multi-couches
Couche Données: Cette couche présente la gestion
des données, tel qu’elle contient le modèle de la base
de données.

Couche Accès aux données: Cette couche s’occupe

de la persistance des données, Pour transformer les
objets métiers en données sérialisées et inversement.

Couche Métier: Prend en charge les traitements en

fonction des processus métiers.

5
Architecture Multi-couches

Couche Service La couche Service regroupe tous

les services. L'idée est d'exposer ces services pour
différentes applications clientes.

Couche Présentation: Cette couche est

l'apparence visuelle de l'application, telle qu'elle sera
perçue par l'utilisateur final.

6
Architectures distribuées

7
ARCHITECTURE JAVA ENTREPRISE
EDITION : JEE

8
9
SERVICES D’INFRASTRUCTURES

10
JDBC
JDBC (Java Data Base Connectivity) : Pilotes java
pour permettre ’accès aux bases de données.
Chaque SGBD possède ses propores pilotes JDBC.

11
Gestion des données

Ajouter des données ?

Consulter les données?

Modifier les données ?

Supprimer les données

12
JPA (Java Persistence API)
On stocke l'état d'un objet dans une base de donnée.
– Ex : la classe Personne possède deux attributs nom et
prenom. on associe cette classe à une table qui possède
deux colonnes : nom et prenom.

On décompose chaque objet en une suite de

variables dont on stockera la valeur dans une ou
plusieurs tables.

Permet des requêtes complexes.

13
JPA (Java Persistence API)

14
JPA (Java Persistence API)
JPA 2 propose un modèle standard de persistance à
l’aide des Entity beans

Ce sont des objets qui savent se mapper dans une base de

donnée. Ils servent à représenter sous forme d'objets des
données situées dans une base de donnée

Les outils (framworks) qui assureront la persistance

(Toplink, Hibernate, EclipseLink, etc.) sont intégrés
au serveur d’application et devront être compatibles
avec la norme JPA 2.

15
JPA (Java Persistence API)

Les applications ont besoin d’une couche de

persistance accès à des données persistantes
stockées dans un SGBD gestion des données
persistantes dans le SGBD

ORM résout la différence entre modèle Objet et

modèle Relationnel les données sont dans la BDD
relationnelle: orientée tables, nuplets, colonnes

16
JPA (Java Persistence API)
Interface qui permet de gérer la persistance des Entity
d’une application
définit un ensemble d’annotations qui permettent
d’effectuer le Mapping objet relationnel (ORM).
définit également une interface de gestion de la
persistance des entités, dans un context
transactionnel, appelée EntityManager.
Le serveur d’application fournie un Framework
implémentant la spécification JPA pour assurer le
mapping objet relationnel (Pour JBOSS c’est Hibernate
qui est utilisé)

17
JPA (Java Persistence API)

Ensemble d’annotations permettant de définir

les entités, relations, attributs, clé, associations.

Deux possibilités pour définir le mapping

o annotations
o fichier de mapping

18
Exemple
package metier.entities;
import java.io.Serializable;
import java.util.Date;
import javax.persistence.*;
@Entity
@Table(name="COMPTES")
public class Compte implements Serializable {
@Id
@GeneratedValue(strategy=GenerationType.IDENTITY)
@Column(name="CODE")
private Long code;
@Column(name="SOLDE")
private double solde;
@Temporal(TemporalType.TIMESTAMP)
@Column(name="DATE_CREATION")
private Date dateCreation;}

19
Application.properties

spring.datasource.url=jdbc:mysql://localhost:3306/db_banque
spring.datasource.username=root
spring.datasource.password=
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.jpa.database=MYSQL
spring.jpa.show-sql=true
spring.jpa.hibernate.ddl-auto=update
spring.jpa.hibernate.naming.strategy=org.hibernet.cfg.ImprovedNamingStr
ategy
spring.jpa.properties.hibernet.dialect=org.hibernet.dialect.MySQL5Dialect

20
JPA (Java Persistence API)
Pour qu’une classe puisse être persistante, il faut

o qu’elle soit identifiée comme une entité (entity) en

utilisant l’annotation @java.persistence.Entity

o qu’elle possède un attribut identifiant en utilisant

l’annotation@javax.persistence.Id

o qu’elle ait un constructeur sans argument

21
JPA (Java Persistence API)
Une entité doit avoir un attribut qui correspond à la
clé primaire de la table associée
La valeur de cet attribut ne doit jamais être modifiée
L’attribut clé primaire est désigné par l’annotation
@Id
Le type de la clé primaire doit être d’un des types
suivants:
o type primitif Java
o java.lang.String
o java.util.Date
o java.sql.Date

22
JPA (Java Persistence API)
Possibilité de générer automatiquement les clés
Si la clé est de type numérique
o @GeneratedValue indique que la clé sera
automatiquement générée par le SGBD
l’annotation peut avoir un attribut strategy qui
indique comment la clé sera générée
o AUTO: le SGBD choisit (valeur par défaut)
o SEQUENCE: il utilise une séquence SQL
o IDENTITY: il utilise un générateur de type
IDENTITY (auto increment dans MySQL par
exemple)
o TABLE: il utilise une table qui contient la
prochaine valeur de l’identificateur 23
JPA (Java Persistence API)
Paramétrage en utilisant l’annotation @Column
Attributs de @Column
o name(): nom de l’attribut
o unique(): la valeur est-elle unique ?
o nullable(): accepte une valeur nulle ?
o insertable(): autorise ou non l’attribut à être mis à
jour
o columnDefinition(): définition DDL de l’attribut
o table(): lorsque l’attribut est utilisé dans plusieurs
tables
o length(): longueur max
o precision(): précision pour les valeurs numériques
24
JPA (Java Persistence API)

25
JPA (Java Persistence API)
Annotations supplémentaires

o @Temporal: on peut ajouter l’annotation pour

préciser le type d’un attribut
@Temporal(TemporalType.DATE) private Date dateNaissance;
on a le choix entre DATE, TIME, TIMESTAMP

o @Transient: toutes les informations d’une classe

n’ont pas besoin d’être persistantes
par exemple, l’âge
@Transient private Integer age;

26
JPA (Java Persistence API)
Clé composite
Relation existante avec clé multi-attributs
Relation avec association N-M (Many-to-Many)
2 possibilités
o @IdClass: correspond à plusieurs attributs Id dans la
classe entité
o @EmbeddedId et @Embeddable: un seul attribut Id dans la
classe entité
Dans les 2 cas, la clé doit être représentée par une
classe Java
o les attributs correspondent aux composants de la clé
o la classe doit être publique
o la classe doit avoir un constructeur sans paramètre
27
JPA (Java Persistence API)
@EmbeddedId
Correspond au cas où la classe entité comprend un
seul attribut annoté @EmbeddedId
La classe clé primaire est annotée par @Embeddable

28
Exemple

29
JPA (Java Persistence API)
@IdClass
Correspond au cas où la classe entité comprend
plusieurs attributs annotés par @Id
La classe entité est annotée par @IdClass qui prend
en paramètre le nom de la classe clé primaire
La classe clé primaire n’est pas annotée ses
attributs ont les mêmes noms et mêmes types que
les attributs annotés @Id dans la classe entité

30
JPA (Java Persistence API)
Associations
o Une association peut être uni- ou bi-directionnelle
o Cardinalités: 1-1, 1-N, N-1, M-N
o Elles sont définies grâce à une annotation sur la
propriété Correspondante

31
JPA (Java Persistence API)
Association 1-1

Annotation @OneToOne
Représente la clé étrangère dans la table

32
JPA (Java Persistence API)
Associations 1-N et N-1
Annotations @OneToMany et @ManyToOne
Représentée par une clé étrangère dans la table qui
correspond au côté propriétaire (obligatoirement le
côté Many)

33
JPA (Java Persistence API)
ManyToOne

34
JPA (Java Persistence API)

Associations M-N

Annotation @ManyToMany Représentée par une table

association
Les valeurs par défaut

o le nom de la table association est la concaténation

des 2 tables, séparées par _
o les noms des attributs clés étrangères sont les
concaténations de la table référencée, de _ et de
l’attribut Id de la table référencée
35
JPA (Java Persistence API)

36
JPA (Java Persistence API)

@JoinTable: donne des informations sur la table

association qui va représenter l’association
o attribut name donne le nom de la table
o attribut joinColumns donne les noms des attributs de la
table qui référencent les clés primaires du côté
propriétaire de l’association
o attribut inverseJoinColumns donne les noms des attributs
de la table qui référencent les clés primaires du côté qui
n’est pas propriétaire de l’association
o L’autre côté doit toujours comporter l’attribut mappedBy

37
JPA (Java Persistence API)
Collections de types simples

38
JPA (Java Persistence API)
Collections de types embeddables

39
JPA (Java Persistence API)
Persistance des entités associées
Lorsqu’un objet o est rendu persistant, les objets
référencés par o devraient être rendus persistants
(persistance par transitivité)
cohérence
par exemple, que se passe-t-il si un objet supprimé
est référencé par un autre objet ?
o JPA n’effectue pas de persistance par transitivité
par défaut
• plus de souplesse
• possibilité d’avoir la persistance par transitivité
avec cascade
40
JPA (Java Persistence API)
Attribut cascade

Permet de propager les effets d’une opération sur

les entités associées, valeurs possibles: PERSIST,
REMOVE, REFRESH, MERGE, ALL

@OneToMany(cascade=CascadeType.PERSIST)

Par défaut, aucune opération n’est appliquée

transitivement

41
JPA (Java Persistence API)
Récupération des entités associées
Lorsqu’une entité est récupérée (requête), est-ce
qu’on récupère aussi les entités associées ?
JPA laisse le choix de récupérer ou non les entités
associées
o on peut choisir le mode de récupération: LAZY ou
EAGER
• EAGER: immédiat
• LAZY: à la demande

42
Exemple
On souhaite créer une application qui permet de
gérer des comptes bancaire.
◦ Chaque compte est défini un numéro, un solde et
une date de création
◦ Un compte courant est un compte qui possède en
plus un découvert
◦ Un compte épargne est un compte qui possède en
plus un taux d’intérêt.
◦ Chaque compte appartient à un client et créé par
un employé.
◦ Chaque client est défini par son code et son solde
◦ Un employé est défini par son code et son nom.

43
Exemple
◦ Chaque employé possède un supérieur hiérarchique.
◦ Chaque employé peut appartenir à plusieurs groupes
◦ Chaque groupe, défini par un code et un nom, peut
contenir plusieurs employés.
◦ Chaque compte peut subir plusieurs opérations.
◦ Il existe deux types d’opérations : Versement et
Retrait
◦ Chaque opération est effectuée par un employé.
◦ Une opération est définie par un numéro, une date et
un montant.

44
Exemple

45
Client
@Entity
public class Client implements Serializable{
@Id
@GeneratedValue(strategy=GenerationType.IDENTITY)
private Long codeClient;
private String nomClient;
@OneToMany (mappedBy="client",
fetch=FetchType.LAZY, cascade=cascadeType.ALL)
private Collection<Compte> comptes;

46
Compte
@Entity
@Inheritance(strategy=InheritanceType.SINGLE_TABLE)
@DiscriminatorColumn(name="Type_CPT",
discriminatorType=DiscriminatorType.STRING, length=2)
public abstract class Compte implements Serializable{
@Id
private String codeCompte;
private Date dateCreation;
private double solde;
@ManyToOne
@JoinColumn(name="Code_Cli")
private Client client;
@ManyToOne
@JoinColumn(name="Code_Emp")
private Employes employe;
@OneToMany( mappedBy="compte")
private Collection <Operation> operations; 47
CompteCC
@Entity
@DiscriminatorValue("CC")

public class CompteCC extends Compte{

private double decouvert;

48
CompteEP
@Entity
@DiscriminatorValue("CE")
public class CompteEP extends Compte{

private double taux;

49
Employees

@Entity
public class Employes implements Serializable{
@Id
@GeneratedValue(strategy=GenerationType.IDENTITY)
private Long codeEmploye;
private String nomEmploye;

@ManyToOne
@JoinColumn(name="Code_emp_sup« )
private Employes EmployesSup;
@ManyToMany
@JoinTable(name="Emp_Gr", joinColumns=
@JoinColumn(name="Num_EMP", inverseJoinColumn=
@JoinColumn (name="Num_Groupe")))
private Collection<Groupe> groupes;
50
Groupe

@Entity
@Table(name="Groupes")
public class Groupe implements Serializable {

@Id
@GeneratedValue(strategy=GenerationType.IDENTITY)
private Long codeGroupe;

private String nomGroupe;

@ManyToMany(mappedBy="groupes")
private Collection<Employes> employes;

51
Operation
@Entity
@Inheritance(strategy=InheritanceType.SINGLE_TABLE)
@DiscriminatorColumn(length=1)
public class Operation implements Serializable {
@Id
@GeneratedValue(strategy=GenerationType.IDENTITY)
private Long numeroOperation;
private Date dateOperation;
private double montant;
@ManyToOne
@JoinColumn(name="Code_CPT")
private Compte compte;
@ManyToOne
@JoinColumn(name="Code_Employe")
private Employes employe;
52
Retrait

@Entity
@DiscriminatorValue("R")
public class Retrait extends Operation {

53
Versement
@Entity
@DiscriminatorValue("V")
public class Versement extends Operation {

54