PATRON DE CONCEPTION MEMENTO

SOMMAIRE

I. PROBLEME...................................................................................................................3
II. DEFINITION.................................................................................................................4
III. QUANT UTILISER MEMENTO.....................................................................................5
IV. MODELE DE CONCEPTION DE MEMENTO.................................................................5
1. Architecture.........................................................................................................5
2. Participants à la conception................................................................................6
V. PROBLEMES ET CONSEQUENCES...............................................................................7
1. Problèmes............................................................................................................7
2. Conséquences......................................................................................................7
VI. APPLICATION.............................................................................................................7
1. Exemple d’application en Java............................................................................7
2. Exemple d’application en python........................................................................8

1
 PATRON DE CONCEPTION MEMENTO

LISTE DES FIGURES

Image 1 : Diagramme de séquence..................................................................................4

Image 2 : Diagramme de classe........................................................................................4
Image 3 : Interface de l'application java...........................................................................5
Image 4 : Sortie programme python................................................................................6

2
 PATRON DE CONCEPTION MEMENTO

I. PROBLEME

Imaginons que nous sommes en train de créer un éditeur de texte. En plus de

pouvoir écrire du texte, notre éditeur permet de le formater, d’insérer des images
alignées, etc.

Au bout d’un moment, nous décidons d’ajouter une fonctionnalité qui permet aux
utilisateurs d’annuler une action sur le texte. Cette fonctionnalité est devenue si
classique au fil des années, que les utilisateurs s’attendent systématiquement à en
disposer. Nous choisissons une approche directe pour la mettre en place. Avant
d’effectuer une action, l’application enregistre l’état de tous les objets et les
sauvegarde. Plus tard, lorsqu’un utilisateur décide d’annuler une action, l’application
récupère la dernière sauvegarde de l’historique et s’en sert pour restaurer l’état de
tous les objets.

Avant d’effectuer une action, l’application prend un instantané (snapshot) du dernier état des objets. Il
peut être utilisé plus tard pour rétablir les objets dans leur ancien état.

Prenons un moment pour réfléchir à ces photos. Comment va-t-on s’y prendre pour
les créer ? Nous allons probablement devoir parcourir tous les attributs d’un objet et
copier leurs valeurs quelque part. Cependant, cela ne fonctionnera que si le contenu
de l’objet ne possède pas trop de restrictions. Malheureusement, la plupart des
objets ne se laissent pas approcher si facilement et cachent les données importantes
dans des attributs privés.

Laissons de côté ce problème pour le moment et considérons que nos objets

préfèrent avoir des relations ouvertes et garder leur état public. Même si cette
approche nous permet de produire des instantanés de l’état des objets à volonté, de
sérieux problèmes demeurent. Dans le futur, nous pourrions décider de refactoriser
certaines classes de l’éditeur, ou d’ajouter ou de supprimer certains attributs. Cela
semble facile à première vue, mais nous allons devoir également modifier les classes
qui ont la responsabilité de créer la copie de l’état des objets concernés.

3
 PATRON DE CONCEPTION MEMENTO

Comment faire une copie de l’état privé d’un objet ?

Regardons un peu du côté des « photos » de l’état de l’éditeur. Quel genre de

données contiennent-elles ? On doit au moins avoir accès aux coordonnées du
curseur de la souris, à la position de la barre de défilement, etc. Pour prendre une
photo, nous devons récupérer ces valeurs et les mettre dans un conteneur.

Nous allons très certainement stocker un paquet de ces conteneurs dans une liste
qui représente l’historique. Ces conteneurs seront probablement les objets d’une
classe. Cette classe possèdera très peu de méthodes, mais aura beaucoup d’attributs
qui répliquent l’état de l’éditeur. Pour permettre à d’autres objets de lire et d’écrire
les données d’une photo, nous allons devoir rendre ses attributs publics, ce qui
exposerait les états de l’éditeur, qu’ils soient privés ou non. Les autres classes
deviendraient dépendantes au moindre changement apporté à la classe photo. Si
nous rendons ses attributs et méthodes privés, ces changements ne seraient de
toute façon pas répercutés sur les autres classes.

Il semblerait que nous sommes dans une impasse : soit on expose tous les détails
d’une classe, ce qui les rend trop fragiles, soit on restreint l’accès à leur état, ce qui
empêche de prendre des instantanés. Dispose-t-on d’une autre technique pour
implémenter un « annuler » ?

II. DEFINITION

Le modèle de conception de mémento est un modèle comportemental et l'un

des 23 discutés par Gang of Four. Le modèle de mémento est utilisé pour restaurer
l'état d'un objet à un état précédent. Il est également connu sous le nom de modèle
d'instantané .
Un souvenir est comme un point de restauration pendant le cycle de vie de
l'objet, que l'application cliente peut utiliser pour restaurer l'état de l'objet à son
état. Conceptuellement, c'est un peu comme si nous créions des points de
restauration pour les systèmes d'exploitation et que nous les utilisions pour
restaurer le système en cas de panne ou de plantage du système.

4
 PATRON DE CONCEPTION MEMENTO

Remarque : Le but du modèle de mémento est de capturer l'état interne d'un objet sans violer
l'encapsulation et ainsi de fournir un moyen de restaurer l'objet dans son état initial si nécessaire.

III. QUANT UTILISER MEMENTO

Le modèle de mémento doit être utilisé dans toute application dans laquelle l'état de
l'objet change en permanence et l'utilisateur de l'application peut décider
de revenir en arrière ou d'annuler les modifications apportées à tout moment.
Un mémento peut également être utilisé dans des applications qui doivent être
redémarrées à partir de leur dernier état de fonctionnement ou brouillon connu . Un
exemple de ceci peut être un IDE qui redémarre à partir des modifications apportées
par l'utilisateur avant de fermer l'IDE.

Exemples :
 Dans un éditeur d'interface graphique (par exemple MS Paint), nous pouvons
continuer à modifier le dessin et nous pouvons annuler les modifications avec
des commandes simples comme CTRL + Z.
 Dans les éditeurs de code, nous pouvons annuler ou appliquer n'importe quel
changement de code avec des commandes simples pour annuler et refaire.
 Dans les applications de calculatrice, nous pouvons revoir tous les calculs en
mémoire avec une simple pression sur un bouton.
 En programmation, memento peut être utilisé pour créer des points de
contrôle lors des transactions de base de données. Si une opération échoue,
nous ramenons simplement tout au dernier état de base de données stable
connu.
 javax.swing.text.JTextComponent La classe fournit un mécanisme de support
d'annulation. 
javax.swing.undo.UndoManager peut agir en tant que gardien
javax.swing.undo.UndoableEdit peut agir comme un souvenir
javax.swing.text.Documentpeut agir comme un créateur.

IV. MODELE DE CONCEPTION DE MEMENTO

1. Architecture

5
 PATRON DE CONCEPTION MEMENTO

Image 1 : Diagramme de séquence

Image 2 : Diagramme de classe

2. Participants à la conception
Le modèle de mémento a trois participants.
 Originator :
est l'objet qui sait comment créer et enregistrer son état pour le futur. Il fournit
des méthodes createMemento()et restoreMemento(memento).
 Gardien :
effectue une opération sur l'initiateur tout en ayant la possibilité de revenir en
arrière. Il garde une trace de plusieurs souvenirs. La classe Client fait référence à la
classe Originator pour la sauvegarde ( createMemento()) et la restauration
( restoreMemento(memento)) de l'état interne de l'initiateur.

6
 PATRON DE CONCEPTION MEMENTO

 Memento :
la boîte de verrouillage qui est écrite et lue par l'auteur, et dirigée par le
gardien. En principe, un mémento doit être en objet immuable afin que personne ne
puisse changer son état une fois créé.

V. PROBLEMES ET CONSEQUENCES

1. Problèmes
 On veut sauvegarder ou restaurer l’état ou une partie de l’état
d’un objet sans violer le principe d’encapsulation
 L’état interne de l’objet à conserver n’est pas visible par les
autres objets.
2. Conséquences
 Garder les limites de l’encapsulation
 Peut-être coûteux en mémoire et en exécution.

VI. APPLICATION

1. Exemple d’application en Java

Cet éditeur graphique permet de modifier la couleur et la position des formes à
l’écran. Toute modification peut être annulée et rétablie.

L’action « annuler » est basée sur la collaboration entre les patrons de conception
mémento et commande. L’éditeur tient l’historique des commandes effectuées.
Avant d’exécuter une commande, il fait une sauvegarde et la relie avec l’objet
commande. Après l’exécution, il pousse la commande concernée dans l’historique.

Lorsqu’un utilisateur demande une annulation, l’éditeur récupère une commande

récente de l’historique et restaure l’état de la sauvegarde stockée dans cette
commande. Si l’utilisateur demande une autre annulation, l’éditeur prend la
commande suivante de l’historique et ainsi de suite.

Les commandes annulées sont gardées dans l’historique jusqu’à ce que l’utilisateur
fasse de nouvelles modifications sur les formes à l’écran. Ce point est crucial pour
rétablir les commandes annulées.

7
 PATRON DE CONCEPTION MEMENTO

Image 3 : Interface de l'application java

2. Exemple d’application en python

Dans cet exemple nous enregistrons des suites de caractères et revenons à leurs
états.

Image 4 : Sortie programme python