Memento(备忘录模式)

备忘录模式

备忘录模式（Memento Pattern）保存一个对象的某个状态，以便在适当的时候恢复对象。备忘录模式属于行为型模式。

UML结构图

• 源发起类Originator：负责创建一个备忘录，用于记录当前对象的内部状态，也可以使用它来利用备忘录恢复内部状态，同时原发器还可以根据需要决定 Memento 存储 Originator 的哪些内部状态。
• 备忘录类Memento：用于存储 Originator 的内部状态，并且可以防止 Originator 以外的对象访问Memento。在备忘录 Memento 中有两个接口，其中 Caretaker 只能看到备忘录中的窄接口，它只能将备忘录传递给其他对象。Originator可以看到宽接口，允许它访问返回到先前状态的所有数据。
• 负责人类CareTaker:对备忘录 Memento 进行管理，保存和提供备忘录，但不能对备忘录的内容进行操作和访问，只能够将备忘录传递给其他对象。

具体代码实现

负责人类CareTaker.class

	/**
	 * @author lq
	 * @PACKAGE_NAME: com.lq.memento
	 * @CLASS_NAME: CareTaker
	 * @date 2022/11/14 20:57
	 * @Description: 负责人类CareTaker:对备忘录 Memento进行管理，保存和提供备忘录，
	 *                               但不能对备忘录的内容进行操作和访问，只能够将备忘录传递给其他对象。
	 */
	public class CareTaker {
	
	    private Memento memento;
	    //备忘点较多时,将备忘录压栈,将多个备忘录对象，序列化和持久化 实现撤回多步的操作
	
	    // private Stack<Memento> stack = new Stack<Memento>();
	    //	private List<Memento> list = new ArrayList<Memento>();
	
	    public Memento getMemento() {
	        return memento;
	    }
	
	    public void setMemento(Memento memento) {
	        this.memento = memento;
	    }
	}

备忘录类

	/**
	 * @author lq
	 * @PACKAGE_NAME: com.lq.memento
	 * @CLASS_NAME: Memento
	 * @date 2022/11/14 20:57
	 * @Description:    备忘录类： 用于存储 Originator 的内部状态，并且可以防止 Originator 以外的对象访问Memento。
	 *                  在备忘录 Memento 中有两个接口，其中 Caretaker 只能看到备忘录中的窄接口，
	 *                  它只能将备忘录传递给其他对象。Originator可以看到宽接口，允许它访问返回到先前状态的所有数据。
	 */
	public class Memento {
	    private String name;
	    private Integer age;
	
	    public Memento(Originator e) {
	        this.name = e.getName();
	        this.age = e.getAge();
	    }
	
	    public String getName() {
	        return name;
	    }
	
	    public void setName(String name) {
	        this.name = name;
	    }
	
	    public int getAge() {
	        return age;
	    }
	
	    public void setAge(int age) {
	        this.age = age;
	    }
	
	}

源发起类Originator.class

	/**
	 * @author lq
	 * @PACKAGE_NAME: com.lq.memento
	 * @CLASS_NAME: Originator
	 * @date 2022/11/14 20:57
	 * @Description:   源发起类Originator：负责创建一个备忘录，用于记录当前对象的内部状态，
	 *                                   也可以使用它来利用备忘录恢复内部状态，同时原发器还可以根据需要决定
	 *                                   Memento 存储 Originator 的哪些内部状态。
	 */
	public class Originator {
	    private String name;
	    private Integer age;
	
	
	    //进行备忘操作，并返回备忘录对象
	    public Memento  memento(){
	        return new Memento(this);
	    }
	
	    //进行数据恢复，恢复成制定备忘录对象的值
	    public void recovery(Memento mmt){
	        this.name = mmt.getName();
	        this.age = mmt.getAge();
	    }
	
	    public Originator(String name, int age) {
	        super();
	        this.name = name;
	        this.age = age;
	    }
	    public String getName() {
	        return name;
	    }
	    public void setName(String name) {
	        this.name = name;
	    }
	    public int getAge() {
	        return age;
	    }
	    public void setAge(int age) {
	        this.age = age;
	    }
	}

/**
 * @author lq
 * @PACKAGE_NAME: com.lq.memento
 * @CLASS_NAME: Main
 * @date 2022/11/14 20:59
 * @Description:
 */
public class Main {
    public static void main(String[] args) {
        CareTaker taker = new CareTaker();

        Originator originator = new Originator("张三", 18);
        System.out.println("第一次打印对象：" + originator.getName() + "---" + originator.getAge());

        //备忘一次
        taker.setMemento(originator.memento());

        originator.setAge(28);
        originator.setName("王五");
        System.out.println("第二次打印对象：" + originator.getName() + "---" + originator.getAge());

        //恢复到备忘录对象保存的状态
        originator.recovery(taker.getMemento());
        System.out.println("第三次打印对象：" + originator.getName() + "---" + originator.getAge());
    }
}

输出结果

	第一次打印对象：张三---18
	第二次打印对象：王五---28
	第三次打印对象：张三---18

备忘录模式小结

优点：

（1）实现了信息的封装，用户不需要关心状态的保存细节，窄接口保证了只有发起者才能访问备忘录对象的状态；

（2）简化了原发器，把备忘录对象保存到原发器对象之外，这样原发器角色就不需要对各个备份的状态进行管理。

缺点：

在实际应用中，备忘录模式都是多状态和多备份的，每保存一次对象状态都需要消耗一定的系统资源，如果需要保存的原发器类的成员变量太多，就不可避免需要占用大量的内存存储空间，消耗资源。

适用场景：

（1）如果有需要提供回滚操作的需求，使用备忘录模式非常适合，比如jdbc的事务操作，文本编辑器的Ctrl+Z恢复等。

（2）保存一个对象在某一个时刻的全部状态或部分状态，这样以后需要时它能够恢复到先前的状态，实现撤销操作。防止外界对象破坏一个对象历史状态的封装性。