23 Modèles de conception Chapitre 18: Modèle de mémorandum Java
Définition: Capturez l'état interne d'un objet sans détruire l'encapsulation et enregistrer cet état en dehors de l'objet. Cela restaurera l'objet à son état enregistré d'origine.
Type: Classe de comportement
Diagramme de classe:
Lorsque nous programmons, nous devons souvent enregistrer l'état intermédiaire de l'objet et, si nécessaire, nous pouvons le restaurer à cet état. Par exemple, lorsque nous utilisons Eclipse pour programmer, si nous faisons une erreur par écrit (par exemple, supprimé accidentellement quelques lignes de code), nous voulons retourner l'état avant la suppression, afin que nous puissions utiliser Ctrl + Z pour revenir. À l'heure actuelle, nous pouvons utiliser le mode Mémo pour y parvenir.
Structure du mode mémo
Initiateur: Enregistrez l'état interne du moment actuel, soyez responsable de la définition des états appartenant à la portée de sauvegarde et être responsable de la création et de la restauration des données de mémorandum.
Mémorandum: responsable du stockage de l'état interne de l'objet initiateur et de la fourniture de l'état interne requis par l'initiateur en cas de besoin.
Rôle de la gestion: gérer les mémorandums, sauver et fournir des mémorandums.
Implémentation du code général
Class Originator {private String State = ""; public String getState () {return State; } public void setState (String State) {this.state = state; } public memento createMmento () {return new memento (this.state); } public void restoreMmento (memento memento) {this.setState (memento.getState ()); }} classe memento {private String state = ""; public memento (String State) {this.state = state; } public String getState () {return State; } public void setState (String State) {this.state = state; }} class Caretaker {private memento memento; public memento getMmento () {return memento; } public void setMemento (memento memento) {this.Mento = memento; }} public class Client {public static void main (String [] args) {originator originator = new Originator (); Originator.SetState ("Status 1"); System.out.println ("État initial:" + Originator.getState ()); Gardien de gardien = nouveau gardien (); caretaker.setMemento (originateur.CreateMmento ()); Originator.SetState ("Status2"); System.out.println ("Statut après avoir changé:" + Originator.GetState ()); originateur.restoreMmento (caretaker.getMemmento ()); System.out.println ("Statut après la récupération:" + Originator.getState ()); }} Le code démontre un exemple de sauvegarde unique à l'état unique. La logique est très simple: la variable d'état dans la classe d'origine doit être sauvegardée afin qu'elle puisse être restaurée en cas de besoin; Dans la classe de memento, il existe également une variable d'état utilisée pour stocker l'état temporaire de la variable d'état dans la classe d'origine; Et la classe Gardetaker est utilisée pour gérer la classe de mémorandum, qui est utilisée pour écrire des états ou récupérer des états dans l'objet de mémorandum.
Mémo multi-états multiples
Dans l'exemple de la démonstration du code général, la classe d'origine n'a qu'une seule variable d'état qui doit être sauvegardée, tandis que généralement, le rôle d'initiateur est généralement un JavaBean, il existe plus d'une variable qui doit être sauvegardée dans l'objet et plus d'un état qui doit être sauvegardé. Il s'agit d'une note multi-états multiple-backup.
Il existe de nombreuses façons de mettre en œuvre des mémos. Il existe de nombreuses déformations et méthodes de traitement pour les mémos. Des méthodes comme le code général ne sont généralement pas utilisées. Dans la plupart des cas, les mémos sont des sauvegardes multiples et multiples. En fait, il est également très simple d'implémenter plusieurs états et multiples-dos. La méthode la plus couramment utilisée consiste à ajouter un conteneur de carte à Memento pour stocker tous les états et à utiliser un conteneur de carte dans la classe du gardien pour stocker toutes les sauvegardes. Ci-dessous, nous donnons un exemple de multi-États et de multi-backup:
Class Originator {private String State1 = ""; String privé State2 = ""; String privé State3 = ""; public String getState1 () {return State1; } public void setState1 (String State1) {this.state1 = state1; } public String getState2 () {return State2; } public void setState2 (String State2) {this.state2 = state2; } public String getState3 () {return State3; } public void setState3 (String State3) {this.state3 = state3; } public memento CreateMmento () {return new memento (beanutils.backupprop (this)); } public void restoremento (memento memento) {beanutils.restoreprop (this, memento.getStateMap ()); } public String toString () {return "State1 =" + State1 + "State2 =" + State2 + "State3 =" + State3; }} class memento {private map <string, object> statemap; public memento (map <string, objet> map) {this.statemap = map; } public map <string, objet> getStateMap () {return statemap; } public void setStateMap (map <string, object> statemap) {this.statemap = statemap; }} class beanutils {public static map <string, object> backupprop (object bean) {map <string, object> result = new hashmap <string, object> (); essayez {beanInfo beaninfo = introspector.getBeanInfo (bean.getClass ()); PropertyDescriptor [] Descriptors = beanInfo.getPropertyDescriptors (); pour (propriétéDescriptor des: descripteurs) {String fieldName = des.getName (); Méthode getter = des.getReadMethod (); Objet FieldValue = getter.invoke (bean, nouvel objet [] {}); if (! fieldName.EqualSignoreCase ("class")) {result.put (fieldName, fieldValue); }}}} catch (exception e) {e.printStackTrace (); } Retour Résultat; } public static void restoreprop (objet bean, map <string, object> propMap) {try {beaninfo beaninfo = introspector.getBeanInfo (bean.getClass ()); PropertyDescriptor [] Descriptors = beanInfo.getPropertyDescriptors (); pour (propriétéDescriptor des: descripteurs) {String fieldName = des.getName (); if (propMap.ContainsKey (fieldName)) {Method seter = des.getWriteMethod (); seter.invoke (bean, nouvel objet [] {propMap.get (fieldName)}); }}} catch (exception e) {e.printStackTrace (); }}} class Caretaker {Private Map <String, memento> memMap = new HashMap <String, memento> (); public memento getMmento (String index) {return memmap.get (index); } public void setMemento (String index, memento memento) {this.memmap.put (index, memento); }} classe Client {public static void main (String [] args) {Originator ori = new Originator (); Gardien de gardien = nouveau gardien (); ori.setstate1 ("Chine"); ori.setstate2 ("fort"); ori.setstate3 ("prospérité"); System.out.println ("=== Statut d'initialisation === / n" + ori); caretaker.setMemento ("001", ori.createMmento ()); ori.setstate1 ("logiciel"); ori.setstate2 ("structure"); ori.setstate3 ("excellent"); System.out.println ("=== État modifié === / n" + ori); ori.restoreMmento (caretaker.getMmento ("001")); System.out.println ("=== Status restauré === / n" + ori); }} Avantages et inconvénients du mode mémorandum et des scénarios applicables
Les avantages du mode mémo sont:
Lorsque le statut dans le rôle de l'initiateur change, il peut s'agir d'un mauvais changement. Nous pouvons restaurer ce mauvais changement en utilisant le mode mémo.
Le statut de la sauvegarde est enregistré en dehors du rôle d'initiateur, donc le rôle de l'initiateur n'a pas besoin de gérer le statut de chaque sauvegarde.
Les inconvénients du mode mémo sont:
Dans les applications réelles, le mode de mémorandum est multi-États et multi-backup. L'état du rôle d'initiateur doit être stocké dans l'objet de mémorandum, qui consomme des ressources relativement sévèrement.
Si vous avez besoin de fournir des opérations en arrière, l'utilisation du mode Mémo est très appropriée, comme les opérations de transaction JDBC, la récupération Ctrl + Z des éditeurs de texte, etc.
Ce qui précède est tout le contenu de cet article. J'espère que cela sera utile à l'apprentissage de tous et j'espère que tout le monde soutiendra davantage Wulin.com.