Memento (patrón de diseño)

Memento es un patrón de diseño cuya finalidad es almacenar el estado de un objeto (o del sistema completo) en un momento dado de manera que se pueda restaurar en ese punto de manera sencilla. Para ello se mantiene almacenado el estado del objeto para un instante de tiempo en una clase independiente de aquella a la que pertenece el objeto (pero sin romper la encapsulación), de forma que ese recuerdo permita que el objeto sea modificado y pueda volver a su estado anterior.

Motivación

Se usa este patrón cuando se quiere poder restaurar el sistema desde estados pasados y por otra parte, es usado cuando se desea facilitar el hacer y deshacer de determinadas operaciones, para lo que habrá que guardar los estados anteriores de los objetos sobre los que se opere (o bien recordar los cambios de forma incremental).

Ejemplo

Java

El siguiente programa Java ilustra el uso de "undo" con el patrón Memento. Intervienen tres clases: la clase Originator (Originador) es una clase que cambia de estado; la clase Caretaker (Portero) se encarga de registrar los cambios del Originador; Memento (Recuerdo) guarda el objeto a salvaguardar.

import java.util.*;
 
class Memento 
{
    private String state;
 
    public Memento(String stateToSave)
    {
        state = stateToSave; 
    }

    public String getSavedState()
    {
        return state; 
    }
}
 
class Originator 
{
    private String state;
    /* lots of memory consumptive private data that is not necessary to define the 
     * state and should thus not be saved. Hence the small memento object. */

    public void set(String state) 
    { 
       System.out.println("Originator: Setting state to "+state);
       this.state = state; 
    }

    public Memento saveToMemento() 
    { 
        System.out.println("Originator: Saving to Memento.");
        return new Memento(state); 
    }

    public void restoreFromMemento(Memento m) 
    {
        state = m.getSavedState(); 
        System.out.println("Originator: State after restoring from Memento: "+state);
    }
}   
 
class Caretaker {
   private ArrayList<Memento> savedStates = new ArrayList<Memento>();
 
   public void addMemento(Memento m) { savedStates.add(m); }
   public Memento getMemento(int index) { return savedStates.get(index); }
}   
 
class MementoExample {
   public static void main(String[] args) {
       Caretaker caretaker = new Caretaker();

       Originator originator = new Originator();
       originator.set("State1");
       originator.set("State2");
       caretaker.addMemento( originator.saveToMemento() );
       originator.set("State3");
       caretaker.addMemento( originator.saveToMemento() );
       originator.set("State4");

       originator.restoreFromMemento( caretaker.getMemento(1) );
   }
}

La salida en pantalla es:

Originator: Setting state to State1
Originator: Setting state to State2
Originator: Saving to Memento.
Originator: Setting state to State3
Originator: Saving to Memento.
Originator: Setting state to State4
Originator: State after restoring from Memento: State3

/**
 * Memento pattern: Copy the information into a another class for recovery in the future if necessary
 * @author Asenior
 *
 */

public class MementoPattern {
	public void main(String args[]){
		RegularClass regularClass = new RegularClass();
		regularClass.setData("First Report");
		System.out.println(regularClass.data);
		regularClass.makeBackup();
		regularClass.setData("Second Report");
		System.out.println(regularClass.data);
		regularClass.recoverBackup();
		System.out.println(regularClass.data);
	}
	
	public class Memento{
		public String memoryData;
		
		public Memento(String data){
			this.memoryData=data;
		}
		
		public String recoverOldInformation(){
			return memoryData;
		}
	}
	
	public class RegularClass{
		Memento memento;
		String data;
		public RegularClass(){
			
		}
		public void setData(String data){
			this.data = data;
		}
		public void makeBackup(){
			 memento = new Memento(data);
		}
		public void recoverBackup(){
			data = memento.recoverOldInformation();
		}
	}
}

Véase también

• Command (patrón de diseño), para implementar (Undo - Redo).

Enlaces externos

• Descripción del patrón Memento en Ada. (en inglés)
• Diagrama UML del patrón Memento con ejemplos en C# y .NET. (en inglés)
• Tutorial en sourcemaking.com. (en inglés)