Applications réparties et middleware

(Systèmes distribués)
Introduction aux Partons de conception

Khaled Barbaria
[Link]@[Link]

Faculté des Sciences de Bizerte

CI1

2023-2024

Khaled Barbaria (FSB) Introduction aux Partons de conception 2023-2024 1 / 55

 Plan

Plan
1 Introduction
Définitions
Quand utiliser les patrons de conception ?
2 Exemples nativement implémentés dans certains langages
Encapsulation
Héritage
Iterator
Exceptions
3 Patrons de conceptions créationnels
Patron de conception Factory
Patron de conception Abstract Factory
Patron de conception Builder
Patron de conception Prototype

Khaled Barbaria (FSB) Introduction aux Partons de conception 2023-2024 2 / 55

 Introduction Définitions

Définitions I

Un patron de conception est :

Une solution réutilisable à un problème de
conception/programmation récurrent
Un modèle pour résoudre certains problèmes de manière efficace
et prouvée.
Un raccourci pour décrire certains aspects d’organisation d’un
logiciel
Aide les développeurs à écrire un code plus propre et plus
maintenable
En promouvant les bonnes pratiques
En standardisant les solutions aux problèmes récurrents.

Khaled Barbaria (FSB) Introduction aux Partons de conception 2023-2024 3 / 55

 Introduction Définitions

Définitions II

Présentation d’un patron de conception

Nom du patron
Description problème de conception ou d’implémentation à
résoudre
Description de la solution : les éléments de la solution, avec leurs
relations. La solution est appelée patron de conception
Conséquences : résultats issus de la solution.

Khaled Barbaria (FSB) Introduction aux Partons de conception 2023-2024 4 / 55

 Introduction Définitions

Définitions III

Orthogonalité
Chaque patron doit correspondre à une approche différente, qui
ne répète pas les idées ou stratégies présentes dans d’autres
patrons.
Permet de résoudre les différents aspects d’un problème à part
Permet de combiner les patrons pour construire une solution.

Khaled Barbaria (FSB) Introduction aux Partons de conception 2023-2024 5 / 55

 Introduction Définitions

Définitions IV

Patrons de conception du GoF

Patrons de conception : formellement reconnus en 1994 à la suite
de la parution du livre Design Patterns : Elements of Reusable
Software, Gamma, Helm, Johnson et Vlissides (Gang of Four -
GoF).
Les vingt-trois « patrons GoF » peuvent être classés en trois
familles :
Partons de construction : traitent l’instanciation et la configuration
des classes et des objets
Patrons structuraux : définissent comment organiser les classes
d’un programme dans des structures plus larges
Patrons comportementaux : définissent comment organiser les
objets et comment distribuer les responsabilités entre eux pour
qu’ils puissnet collaborer efficacement.

Khaled Barbaria (FSB) Introduction aux Partons de conception 2023-2024 6 / 55

 Quand utiliser les patrons de
Introduction conception ?

Quand utiliser les patrons de conception ? I

Utiliser comme une optimisation de la conception

Si certains aspects de la conception et/ou de l’implémentation ne
sont pas maitrisés : retarder l’application des patrons de
conception. S’assurer que l’application est fonctionnelle avant
d’ptimiser.
Si le domaine et le problème sont maitrisés, il est possible
d’utiliser les partons de conception dès le début (tout comme le
choix d’un algorithme efficace).

Khaled Barbaria (FSB) Introduction aux Partons de conception 2023-2024 7 / 55

 Quand utiliser les patrons de
Introduction conception ?

Quand utiliser les patrons de conception ? II

Les patrons peuvent augmenter ou diminuer la compréhension

diminuer la compréhension : en ajoutant des indirections ou des
composants.
augmenter la compréhension : en améliorant la modularité, la
séparation des préoccupations et en facilitant la description
Si un patron de conception est maitrisé, il est plus facile et plus
rapide de communiquer avec les autres personnes qui
connaissent ce patron

Khaled Barbaria (FSB) Introduction aux Partons de conception 2023-2024 8 / 55

 Quand utiliser les patrons de
Introduction conception ?

Quand utiliser les patrons de conception ? III

Conculsion
Les patrons de conception peuvent être utilisés lorsqu’on
remarque un problème de conception, d’implémentation, de
performances.
Examiner la conception ou le code problématique : quels sont les
problème ?
Qu’est ce que vous voulez faire et qui semble difficile ?
Chercher dans une référence de patrons de conception : quels
patrons permetent de répondre à votre problème ?

Khaled Barbaria (FSB) Introduction aux Partons de conception 2023-2024 9 / 55

 Exemples nativement implémentés
dans certains langages Encapsulation

Encapsulation I

Encapsulation
Cacher l’état interne et les détails d’implémentation d’un package
ou d’un type du reste du monde extérieur tout en autoraisant un
accès controlé.
Problème : l’accès à certains attributs/méthodes exposés pet
causer la violation des invariants de représentation, dépendances
indésirables.
Solution : cacher certains composants et autoriser uniquement
des accès controlés à l’objet ou a certains de ces attributs
(exemple à travers les getters, setters).

Khaled Barbaria (FSB) Introduction aux Partons de conception 2023-2024 10 / 55

 Exemples nativement implémentés
dans certains langages Encapsulation

Encapsulation II

Invariant de représentation
Propriété d’un objet ou d’une structure de données qui doit
toujours être vraie pendant la durée de vie de cet objet ou de cette
structure.
Condition qui ne doit jamais être violée par les opérations ou les
modifications effectuées sur l’objet.
Souvant associés à des classes (POO) ou à des structures de
données et décrivent les conditions que les instances de cette
classe ou de la structure doivent respecter

Khaled Barbaria (FSB) Introduction aux Partons de conception 2023-2024 11 / 55

 Exemples nativement implémentés
dans certains langages Encapsulation

Encapsulation III

Invariant de représentation : Exemple

Un invariant de représentation associé à une classe "Compte"
pourrait être que le solde du compte ne peut jamais être négatif.
Chaque fois qu’une opération est effectuée sur ce compte (par
exemple, un dépôt ou un retrait), l’application doit garantir que
cette condition est respectée.
La violation d’un invariant de représentation peut entraîner des
comportements indésirables ou des résultats incorrects

Khaled Barbaria (FSB) Introduction aux Partons de conception 2023-2024 12 / 55

 Exemples nativement implémentés
dans certains langages Encapsulation

Encapsulation IV

Encpasulation
Avantages : Aide à gérer la complexité des grandes bases de
code, à améliorer la maintenabilité et à empêcher l’accès non
intentionnel aux détails internes.
Inconvénients : performances (dûes aux indirections).

Khaled Barbaria (FSB) Introduction aux Partons de conception 2023-2024 13 / 55

 Exemples nativement implémentés
dans certains langages Encapsulation

Encapsulation V

En Go
Go ne dispose pas des fonctionnalités orientées objet
traditionnelles telles que les classes et les modificateurs d’accès
Encapsulation grâce à son système de packages et à l’utilisation
du concept d’identifiants exportés et non exportés.
Un identifiant (variable, fonction, struct, etc.) qui commence par
une lettre majuscule est considéré comme exporté, ce qui signifie
qu’il est accessible depuis l’extérieur de son package. En
revanche, les identifiants commençant par une lettre minuscule
sont non exportés, et ils ne sont accessibles que dans le même
package.

Khaled Barbaria (FSB) Introduction aux Partons de conception 2023-2024 14 / 55

 Exemples nativement implémentés
dans certains langages Encapsulation

Encapsulation VI
1 // Exemple pour illustrer l’encapsulation en Go : la structure Animal
2 // possède un champ non exporté name, qui ne peut être accédé ou
3 // modifié que par les méthodes définies dans le même package (dans ce
4 // cas, le package main). La méthode GetName() est exportée, donc elle
5 // peut être accessible depuis l’extérieur du package pour récupérer
6 // le nom de l’animal.
7
8
9 package main
10
11 import ("fmt")
12
13 // Animal est une structure représentant un animal.
14 type Animal struct {
15 name string // champ non exporté
16 }
17
18 // NewAnimal crée un nouvel Animal avec le nom donné.
19 func NewAnimal(name string) Animal {
20 return Animal{name: name}
21 }
22
23 // GetName renvoie le nom de l’animal.
24 func (a Animal) GetName() string {
25 return [Link]
26 }
27

Khaled Barbaria (FSB) Introduction aux Partons de conception 2023-2024 15 / 55

 Exemples nativement implémentés
dans certains langages Encapsulation

Encapsulation VII

28 func main() {
29 // Créer une nouvelle instance d’Animal
30 chien := NewAnimal("Max")
31
32 // Récupérer le nom de l’animal en utilisant la méthode exportée GetName()
33 [Link]("Nom de l’animal :", [Link]())
34
35 // [Link]("Nom de l’animal :", [Link]) // Erreur de compilation
36 }

Khaled Barbaria (FSB) Introduction aux Partons de conception 2023-2024 16 / 55

 Exemples nativement implémentés
dans certains langages Héritage

Héritage I

Héritage
Problème : Les abstractions similaires ont des membres (attributs
et méthodes) similaires. Les répétitions est fastidieuse, peut
causer des erreurs de programmation et des problèmes de
maintenance
Solution : hériter les membres par défaut d’une super-classe,
selectionner l’implémentation adéquate pendant l’exécution
(polymorphisme)
Inconvénients : le code est divisé entre les classe. Coût du
polymorphisme.

Khaled Barbaria (FSB) Introduction aux Partons de conception 2023-2024 17 / 55

 Exemples nativement implémentés
dans certains langages Héritage

Héritage II

En Go
Une approche différente pour la réutilisation du code et la
composition de types :
Composition de types
Interfaces
Composition de types : inclure un type structuré dans un autre
pour réutiliser ses attributs et son comportement.
Implémentation d’interfaces : les types qui implémentent toutes
les méthodes déclarées dans une interface satisfont implicitement
cette interface. Cela permet le polymorphisme sans héritage de
classe.

Khaled Barbaria (FSB) Introduction aux Partons de conception 2023-2024 18 / 55

 Exemples nativement implémentés
dans certains langages Héritage

Héritage III
1 package main
2
3 import "fmt"
4 type Person struct {
5 Name string
6 Age int
7 }
8 type Employee struct {
9 Person // Incorporation de la structure Person
10 EmployeeID int
11 }
12
13 // Fonction pour afficher les détails de l’employé, les attributs de
14 // Person sont directement accessibles
15 func (e Employee) PrintDetails() {
16 [Link]("Name: %s, Age: %d, EmployeeID: %d\n", [Link], [Link], [Link])
17 [Link]([Link])
18 [Link]([Link])
19 }
20
21 func main() {
22 // Création d’une instance de Employee
23 emp := Employee{
24 Person: Person{Name: "Ali Mosbah", Age: 30},
25 EmployeeID: 1001,
26 }
27

Khaled Barbaria (FSB) Introduction aux Partons de conception 2023-2024 19 / 55

 Exemples nativement implémentés
dans certains langages Héritage

Héritage IV
28 // Affichage des détails de l’employé
29 [Link]()
30 }

1 go run [Link]
2 Name: Ali Mosbah, Age: 30, EmployeeID: 1001
3 Ali Mosbah
4 Ali Mosbah

1 package main
2 import ("fmt";"math")
3
4 type Shape interface {
5 Area() float64
6 }
7
8 type Square struct {
9 SideLength float64
10 }
11
12 // Méthode pour calculer l’aire du carré
13 func (s Square) Area() float64 {
14 return [Link] * [Link]
15 }
16

Khaled Barbaria (FSB) Introduction aux Partons de conception 2023-2024 20 / 55

 Exemples nativement implémentés
dans certains langages Héritage

Héritage V

17 // Définition de la structure Circle

18 type Circle struct {
19 Radius float64
20 }
21
22 // Méthode pour calculer l’aire du cercle
23 func (c Circle) Area() float64 {
24 return [Link] * [Link] * [Link]
25 }
26
27 func main() {
28 // Création d’instances de Square et Circle
29
30 // Utilisation polymorphique de l’interface Shape
31 shapes := []Shape{
32 Square{SideLength:5},
33 Circle{Radius: 3},
34 Circle{Radius: 2},
35 }
36
37 // Affichage de l’aire de chaque forme
38 for i, shape := range shapes {
39 [Link]("Area of shape %d : %.2f\n", i, [Link]())
40 }
41 }

Khaled Barbaria (FSB) Introduction aux Partons de conception 2023-2024 21 / 55

 Exemples nativement implémentés
dans certains langages Héritage

Héritage VI

1 $ go run [Link]
2 Area of shape 0 : 25.00
3 Area of shape 1 : 28.27
4 Area of shape 2 : 12.57

Khaled Barbaria (FSB) Introduction aux Partons de conception 2023-2024 22 / 55

 Exemples nativement implémentés
dans certains langages Iterator

Iterator I

Iterator
Problème : les clients qui souhaitent accéder aux membres d’une
collection (liste, ensemble, tableau, table de hachage, etc) doivent
effectuer une traversée adaptée à chaque structure de données.
Ceci introduit des dépendances et cause un problème
d’extensibilité et de configurabilité. (tout changement de la
collection cause un changement du code).
Solution : Les implémentations qui ont connaissance de la
représentation effectue la traversée et enregistre l’état actuel du
parcours. Les résultats sont communiqués aux client via une
interface standard.
Inconvénients : l’ordre du parcours est fixé par l’implémentation et
n’est plus sous le contrôle du client.

Khaled Barbaria (FSB) Introduction aux Partons de conception 2023-2024 23 / 55

 Exemples nativement implémentés
dans certains langages Iterator

Iterator II
1 package main
2
3 import "fmt"
4
5 // Define an Iterator interface
6 type Iterator interface {
7 HasNext() bool
8 Next() interface{}
9 }
10
11 // Define a concrete implementation of Iterator for a slice
12 type SliceIterator struct {
13 slice []interface{}
14 index int
15 }
16
17 func NewSliceIterator(slice []interface{}) *SliceIterator {
18 return &SliceIterator{
19 slice: slice,
20 index: 0,
21 }
22 }
23
24 func (it *SliceIterator) HasNext() bool {
25 return [Link] < len([Link])
26 }
27

Khaled Barbaria (FSB) Introduction aux Partons de conception 2023-2024 24 / 55

 Exemples nativement implémentés
dans certains langages Iterator

Iterator III

28 func (it *SliceIterator) Next() interface{} {

29 item := [Link][[Link]]
30 [Link]++
31 return item
32 }
33
34 func main() {
35 // Create a slice of integers
36 numbers := []interface{}{1, 2, 3, 4, 5}
37
38 // Create an iterator for the slice
39 iterator := NewSliceIterator(numbers)
40
41 // Iterate over the elements using the iterator
42 for [Link]() {
43 [Link]([Link](), " ")
44 }
45 }

1 $ go run [Link]
2 1 2 3 4 5

Khaled Barbaria (FSB) Introduction aux Partons de conception 2023-2024 25 / 55

 Exemples nativement implémentés
dans certains langages Exceptions

Exceptions I

Exceptions
Problème : les erreurs causées par l’exécution d’une partie du
code doivent souvent être traitées dans une partie de l’application,
le code applicatif ne doit pas être désorganisé par le code de
gestion d’erreurs et son exécution ne doit pas être interrompue
par les erreurs.
Solution : introduire des structures pour générer et capter les
exceptions afin de les prendre en charge.
Inconvénients : Le code peut rester déorganisé, il est parfois
difficile de savoir où est ce qu’une exception doit être gérée.
Certains développeurs peuvent être tentés d’utiliserles exceptions
dans des exécutions normales ce qui introduit des confusions et
des pertes de performances.

Khaled Barbaria (FSB) Introduction aux Partons de conception 2023-2024 26 / 55

 Exemples nativement implémentés
dans certains langages Exceptions

Exceptions II

En Go
Des principes similaires à C++/Java qpour gérer les erreurs de
manière efficace.
Les erreurs sont généralement gérées à l’aide de valeurs d’erreur
explicites renvoyées par les fonctions.
Pssible de définir des types d’erreurs personnalisés pour :
Représenter différents types d’erreurs
Définir des stratégies de gestion des erreurs en conséquence.

Khaled Barbaria (FSB) Introduction aux Partons de conception 2023-2024 27 / 55

 Exemples nativement implémentés
dans certains langages Exceptions

Exceptions III
1 // CustomError représente une erreur personnalisée
2 type CustomError struct {
3 message string
4 }
5 // Méthode Error() de CustomError
6 func (e *CustomError) Error() string {
7 return [Link]
8 }
9
10 func PerformOperation() error {
11 // Simulons une erreur
12 return &CustomError{"Une erreur s’est produite lors de l’opération."}
13 }
14
15 func main() {
16 err := PerformOperation()
17 if err != nil {
18 [Link]("Erreur:", [Link]())
19 } else {
20 [Link]("Opération réussie.")
21 }
22 }

1 $ go run [Link]
2 Erreur: Une erreur s’est produite lors de l’opération.

Khaled Barbaria (FSB) Introduction aux Partons de conception 2023-2024 28 / 55

 Patrons de conceptions
créationnels

Patrons de conception créationnels I

Patrons de conception créationnels

Classe de patrons de conception qui se concentrent sur la
manière dont les objets et les instances de classes sont créés.
Séparent les détails de création des autres parties du système
Fournissent des mécanismes pour instancier des objets de
différentes manières tout en cachant les détails de création
Flexibilité et réutilisabilité du code améliorées.

Khaled Barbaria (FSB) Introduction aux Partons de conception 2023-2024 29 / 55

 Patrons de conceptions
créationnels

Patrons de conception créationnels II

patrons de conception les plus couramment utilisés
Singleton : Garantit qu’une classe n’a qu’une seule instance et
fournit un moyen global d’y accéder.
Factory Method : Définit une interface pour créer un objet, mais
laisse les sous-classes décider quelle classe instancier. Permet
de déléguer la création d’objets aux sous-classes.
Abstract Factory : Fournit une interface pour créer des familles
d’objets liés ou dépendants sans spécifier leurs classes
concrètes. Permet de créer des familles d’objets sans préciser les
classes exactes à utiliser.
Builder : Sépare la construction d’un objet complexe de sa
représentation, permettant au même processus de construction
de créer différentes représentations.
Prototype : Utilise un objet existant comme prototype pour créer
de nouveaux objets en copiant cet objet. Évite de recourir à des
sous-classes
Khaled Barbaria (FSB) pour créer des
Introduction auxobjets.
Partons de conception 2023-2024 30 / 55
 Patrons de conceptions
créationnels

Patron de conception Singleton I

Patron de conception singleton

Garantit qu’une classe n’a qu’une seule instance et fournit un
point d’accès global à cette instance.
Utilisé en cas de besoin d’une seule instance d’une classe pour
coordonner des opérations à travers un système.
Largement utilisé pour le partage de ressources, le contrôle
d’accès concurrent et la configuration des paramètres.

Khaled Barbaria (FSB) Introduction aux Partons de conception 2023-2024 31 / 55

 Patrons de conceptions
créationnels

Patron de conception Singleton II

Caractéristiques (1/2)
Instance unique & Point d’accès global : Le Singleton garantit
qu’une seule instance de la classe est créée. L’accès a cette
instance est assuré de manière cohérente à partir de n’importe
quel endroit dans le programme à travers le point d’accès global.
Initialisation paresseuse (Lazy initialization) : Dans de nombreux
cas, l’instance unique n’est créée que lors de la première
demande (initialisation paresseuse).
Private constructor : Pour empêcher la création d’instances
supplémentaires de la classe en dehors de la classe elle-même,
le constructeur de la classe Singleton est généralement déclaré
comme privé.

Khaled Barbaria (FSB) Introduction aux Partons de conception 2023-2024 32 / 55

 Patrons de conceptions
créationnels

Patron de conception Singleton III

Caractéristiques (2/2)
Thread-safety : Il est important de prendre en compte la
concurrence lors de l’implémentation du Singleton dans des
environnements multithreadés. Des mécanismes de
synchronisation comme les mutex peuvent être utilisés pour
garantir l’accès thread-safe à l’instance unique.

Khaled Barbaria (FSB) Introduction aux Partons de conception 2023-2024 33 / 55

 Patrons de conceptions
créationnels

Patron de conception Singleton IV

Khaled Barbaria (FSB) Introduction aux Partons de conception 2023-2024 34 / 55

 Patrons de conceptions
créationnels

Patron de conception Singleton V

1 // Counter représente un compteur utilisant le patron Singleton

2 type Counter struct {
3 count int
4 }
5
6 var instance *Counter
7
8 // GetInstance retourne le compteur
9 func GetInstance() *Counter {
10 if instance == nil {
11 instance = &Counter{count: 0}
12 }
13 return instance
14 }

Khaled Barbaria (FSB) Introduction aux Partons de conception 2023-2024 35 / 55

 Patrons de conceptions
créationnels Patron de conception Factory

Patron de conception Factory I

Patron de conception Factory (ou Factory Method)

Encapsule la logique de création d’objets dans une superclasse
Délègue cette responsabilité aux sous-classes
Permet une meilleure flexibilité et extensibilité du code.

Khaled Barbaria (FSB) Introduction aux Partons de conception 2023-2024 36 / 55

 Patrons de conceptions
créationnels Patron de conception Factory

Patron de conception Factory II

Caractéristiques
Interface commune : pour la création des objets.
Méthode de fabrique (Factory Method) : responsable de la
création d’instances spécifiques de classes dérivées,
implémentée dans les sous-classes.
Découplage de la création et de l’utilisation : le code qui utilise les
objets est découplé de celui qui les crée, ce qui rend le code plus
modulaire et facile à étendre.
Flexibilité et extensibilité : Possibilité d’ajouter de nouveaux types
d’objets sans modifier le code existant grace à délégation de la
création d’objets aux sous-classes
Réduction de la complexité : En regroupant la logique de création
d’objets en un seul endroit

Khaled Barbaria (FSB) Introduction aux Partons de conception 2023-2024 37 / 55

 Patrons de conceptions
créationnels Patron de conception Factory

Patron de conception Factory III

Khaled Barbaria (FSB) Introduction aux Partons de conception 2023-2024 38 / 55

 Patrons de conceptions
créationnels Patron de conception Factory

Patron de conception Factory IV

1 package main
2
3 import ("fmt")
4
5 // Polygon représente l’interface commune pour tous les polygones
6 type Polygon interface {
7 GetNumberOfSides() int
8 }
9
10 // Triangle est une implémentation de Polygon pour un triangle
11 type Triangle struct{}
12
13 func (t Triangle) GetNumberOfSides() int {
14 return 3
15 }
16
17 // Square est une implémentation de Polygon pour un carré
18 type Square struct{}
19
20 func (s Square) GetNumberOfSides() int {
21 return 4
22 }
23
24 // Pentagon est une implémentation de Polygon pour un pentagone
25 type Pentagon struct{}
26
27 func (p Pentagon) GetNumberOfSides() int {

Khaled Barbaria (FSB) Introduction aux Partons de conception 2023-2024 39 / 55

 Patrons de conceptions
créationnels Patron de conception Factory

Patron de conception Factory V

28 return 5
29 }
30
31 // PolygonFactory est l’interface commune pour la création de polygones
32 type PolygonFactory interface {
33 CreatePolygon() Polygon
34 }
35
36 // ConcretePolygonFactory est une implémentation de PolygonFactory
37 type ConcretePolygonFactory struct{}
38
39 func (f ConcretePolygonFactory) CreatePolygon(numberOfSides int) Polygon {
40 switch numberOfSides {
41 case 3:
42 return Triangle{}
43 case 4:
44 return Square{}
45 case 5:
46 return Pentagon{}
47 default:
48 return nil // nombres de côtés non pris en charge
49 }
50 }
51
52 func main() {
53 factory := ConcretePolygonFactory{}
54

Khaled Barbaria (FSB) Introduction aux Partons de conception 2023-2024 40 / 55

 Patrons de conceptions
créationnels Patron de conception Factory

Patron de conception Factory VI

55 // Création de polygones en fonction du nombre de côtés

56 for _, sides := range []int{3, 4, 5} {
57 polygon := [Link](sides)
58 if polygon != nil {
59 [Link]("Polygon with %d sides created: %T\n", sides, polygon)
60 } else {
61 [Link]("Unsupported number of sides: %d\n", sides)
62 }
63 }
64 }

1 $ go run [Link]
2 Polygon with 3 sides created: [Link]
3 Polygon with 4 sides created: [Link]
4 Polygon with 5 sides created: [Link]

Khaled Barbaria (FSB) Introduction aux Partons de conception 2023-2024 41 / 55

 Patrons de conceptions Patron de conception Abstract
créationnels Factory

Patron de conception Abstract Factory I

Patron de conception Abstarct Factory

Permet de créer des familles d’objets liés ou dépendants sans
spécifier leurs classes concrètes.
Principaux éléments :
Abstract Factory : interface pour la création de familles d’objets liés
ou dépendants.
Concrete Factory : Implémente l’interface de l’Abstract Factory pour
créer des familles d’objets concrètes.
Abstract Product : Interface pour un type de produit spécifique au
sein d’une famille de produits.
Concrete Product : Implémente l’interface de l’Abstract Product
pour fournir des implémentations concrètes des produits.
Client : Utilise l’Abstract Factory et les produits via leurs interfaces
abstraites, sans connaître les classes concrètes utilisées.

Khaled Barbaria (FSB) Introduction aux Partons de conception 2023-2024 42 / 55

 Patrons de conceptions Patron de conception Abstract
créationnels Factory

Patron de conception Abstract Factory II

Khaled Barbaria (FSB) Introduction aux Partons de conception 2023-2024 43 / 55

 Patrons de conceptions
créationnels Patron de conception Builder

Patron de conception Builder I

Patron de conception Builder

Permet de construire des objets complexes étape par étape.
Il sépare la construction d’un objet complexe de sa représentation
afin que le même processus de construction puisse créer
différentes représentations.
Utile lorsque la création d’un objet nécessite un processus
complexe avec de nombreuses étapes ou lorsque l’objet final peut
avoir différentes représentations.

Khaled Barbaria (FSB) Introduction aux Partons de conception 2023-2024 44 / 55

 Patrons de conceptions
créationnels Patron de conception Builder

Patron de conception Builder II

Principaux éléments du patron Builder

Builder : Interface pour la création des différentes parties d’un
objet complexe.
ConcreteBuilder : Implémente l’interface Builder pour construire et
assembler les différentes parties de l’objet complexe.
Product : l’objet construit étape par étape par le ConcreteBuilder.
Director : Contrôle le processus de construction en utilisant le
Builder pour construire l’objet complexe.

Khaled Barbaria (FSB) Introduction aux Partons de conception 2023-2024 45 / 55

 Patrons de conceptions
créationnels Patron de conception Builder

Patron de conception Builder III

Khaled Barbaria (FSB) Introduction aux Partons de conception 2023-2024 46 / 55

 Patrons de conceptions
créationnels Patron de conception Builder

Patron de conception Builder IV

Différences entre Builder et Abstract Factory

Builder se concentre sur la construction d’objets complexes étape
par étape.
Abstract Factory se spécialise dans la création de familles d’objets
apparentés.
Abstract Factory renvoie le produit immédiatement, tandis que
Builder vous permet d’exécuter des étapes de construction
supplémentaires avant de récupérer le produit.

Khaled Barbaria (FSB) Introduction aux Partons de conception 2023-2024 47 / 55

 Patrons de conceptions
créationnels Patron de conception Builder

Patron de conception Builder V

1 package main
2
3 import "fmt"
4
5 // Builder définit une interface pour la construction d’un objet
6 type Builder interface {
7 SetWheel(wheel string)
8 SetEngine(engine string)
9 SetBody(body string)
10 GetVehicle() Vehicle
11 }
12
13 // Vehicle représente l’objet complexe à construire
14 type Vehicle struct {
15 Wheel string
16 Engine string
17 Body string
18 }
19
20 // CarBuilder est une implémentation concrète de Builder pour construire des voitures
21 type CarBuilder struct {
22 vehicle Vehicle
23 }
24
25 func (b *CarBuilder) SetWheel(wheel string) {
26 [Link] = wheel
27 }

Khaled Barbaria (FSB) Introduction aux Partons de conception 2023-2024 48 / 55

 Patrons de conceptions
créationnels Patron de conception Builder

Patron de conception Builder VI

28
29 func (b *CarBuilder) SetEngine(engine string) {
30 [Link] = engine
31 }
32
33 func (b *CarBuilder) SetBody(body string) {
34 [Link] = body
35 }
36
37 func (b *CarBuilder) GetVehicle() Vehicle {
38 return [Link]
39 }
40
41 // Director contrôle le processus de construction
42 type Director struct {
43 builder Builder
44 }
45
46 func (d *Director) Construct() {
47 [Link]("4 wheels")
48 [Link]("V8 engine")
49 [Link]("Sedan body")
50 }
51
52 func main() {
53 // Création du constructeur de voitures
54 carBuilder := &CarBuilder{}

Khaled Barbaria (FSB) Introduction aux Partons de conception 2023-2024 49 / 55

 Patrons de conceptions
créationnels Patron de conception Builder

Patron de conception Builder VII

55
56 // Création du directeur avec le constructeur de voitures
57 director := &Director{builder: carBuilder}
58
59 // Construction de la voiture
60 [Link]()
61
62 // Obtention de la voiture construite
63 car := [Link]()
64
65 // Affichage des caractéristiques de la voiture
66 [Link]("Car Wheel:", [Link])
67 [Link]("Car Engine:", [Link])
68 [Link]("Car Body:", [Link])
69 }

1 $ go run [Link]
2 Car Wheel: 4 wheels
3 Car Engine: V8 engine
4 Car Body: Sedan body

Khaled Barbaria (FSB) Introduction aux Partons de conception 2023-2024 50 / 55

 Patrons de conceptions
créationnels Patron de conception Prototype

Patron de conception Prototype I

Patron de conception Prototype

Permet de créer de nouveaux objets en copiant un objet existant,
appelé prototype, au lieu de créer un nouvel objet à partir de zéro.
Principaux éléments du patron Prototype :
Prototype : Interface pour la création d’objets en utilisant la
méthode Clone pour copier l’objet existant.
ConcretePrototype : Implémente l’interface Prototype et fournit une
implémentation concrète de la méthode Clone pour copier l’objet.
Client : Utilise l’objet prototype pour créer de nouveaux objets en le
clonant.
Utile lorsque la création d’un nouvel objet est coûteuse en termes
de performances ou de ressources, ou lorsque l’initialisation d’un
objet nécessite une configuration complexe.

Khaled Barbaria (FSB) Introduction aux Partons de conception 2023-2024 51 / 55

 Patrons de conceptions
créationnels Patron de conception Prototype

Patron de conception Prototype II

Khaled Barbaria (FSB) Introduction aux Partons de conception 2023-2024 52 / 55

 Patrons de conceptions
créationnels Patron de conception Prototype

Patron de conception Prototype III

1 package main
2
3 import (
4 "fmt"
5 )
6
7 // Shape définit l’interface pour la création de formes géométriques en utilisant la
méthode Clone
8 type Shape interface {
9 GetName() string
10 Clone() Shape
11 }
12
13 // Circle est une implémentation concrète de Shape pour un cercle
14 type Circle struct {
15 radius float64
16 }
17
18 func (c *Circle) GetName() string {
19 return [Link]("Circle with radius %.2f", [Link])
20 }
21
22 func (c *Circle) Clone() Shape {
23 // Créer une copie du cercle en utilisant une initialisation légère
24 return &Circle{radius: [Link]}
25 }
26

Khaled Barbaria (FSB) Introduction aux Partons de conception 2023-2024 53 / 55

 Patrons de conceptions
créationnels Patron de conception Prototype

Patron de conception Prototype IV

27 // Rectangle est une implémentation concrète de Shape pour un rectangle
28 type Rectangle struct {
29 width float64
30 height float64
31 }
32
33 func (r *Rectangle) GetName() string {
34 return [Link]("Rectangle with width %.2f and height %.2f", [Link], [Link])
35 }
36
37 func (r *Rectangle) Clone() Shape {
38 // Créer une copie du rectangle en utilisant une initialisation légère
39 return &Rectangle{width: [Link], height: [Link]}
40 }
41
42 func main() {
43 // Création d’objets prototypes de cercle et de rectangle
44 circlePrototype := &Circle{radius: 5.0}
45 rectanglePrototype := &Rectangle{width: 10.0, height: 5.0}
46
47 // Clonage des objets prototypes pour créer de nouveaux objets
48 clone1 := [Link]()
49 clone2 := [Link]()
50
51 // Modification des propriétés des objets clonés
52 clone1.(*Circle).radius = 7.0
53 clone2.(*Rectangle).width = 15.0

Khaled Barbaria (FSB) Introduction aux Partons de conception 2023-2024 54 / 55

 Patrons de conceptions
créationnels Patron de conception Prototype

Patron de conception Prototype V

54 clone2.(*Rectangle).height = 7.0
55
56 // Affichage des noms des objets clonés
57 [Link]("Clone 1:", [Link]())
58 [Link]("Clone 2:", [Link]())
59 }

1 $ go run [Link]
2 Clone 1: Circle with radius 7.00
3 Clone 2: Rectangle with width 15.00 and height 7.00

Khaled Barbaria (FSB) Introduction aux Partons de conception 2023-2024 55 / 55