备忘录模式

在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保持这个状态。这样以后就可以将该对象恢复到原先保存的状态.

使用场景

很多时候我们总是需要记录一个对象的内部状态，这样做的目的就是为了允许用户取消不确定或者错误的操作，能够恢复到他原先的状态，使得他有"后悔药"可吃。

uml

角色说明：

1. originator（发起人）:负责创建一个备忘录Memento，用以记录当前时刻的内部状态，并可以使用备忘录恢复内部状态。Originator可根据需要决定Memento存储Originator的哪些状态----------------理解为原有角色所拥有的状态
2. Memento（备忘录）:负责存储Originator对象的内部状态，并可防止Originator以外的其他对象访问备忘录Memento。备忘录有两个接口，Caretaker只能看到备忘录的窄接口，它只能将备忘录传递给其他对象。Originator能够看到一个宽接口，允许它访问返回到先前状态所需的所有数据-------------原有角色的其中一个快照，拥有和originator相同的状态
3. Caretaker（管理者）：负责保存好备忘录Memento，不能对备忘录的内容进行操作或检查-------------备忘录类保存的地方，使用其set方法保存备忘录，使用get获取快照恢复

基本代码

1. Memento备忘录类： 包含了要被恢复的对象的状态

public class Memento {

	private String state;

	public Memento(String state) {
		this.state = state;
	}

	public String getState() {
		return state;
	}
}

2. Originator发起人类： 创建并在 Memento 对象中存储状态

public class Originator {

	private String state;

	public void setState(String state) {
		this.state = state;
	}

	public String getState() {
		return state;
	}

	public Memento saveStateToMemento() {
		return new Memento(state);
	}

	public void getStateFromMemento(Memento memento) {
		state = memento.getState();
	}
}

3. Caretaker管理者类：负责从 Memento 中恢复对象的状态

public class CareTaker {

	private List<Memento> mementoList = new ArrayList<>();

	public void add(Memento memento) {
		mementoList.add(memento);
	}

	public Memento get(int index) {
		return mementoList.get(index);
	}
}

4. 测试类

public class MementoPatternDemo {

	public static void main(String[] args) {

		Originator originator = new Originator();
		CareTaker careTaker = new CareTaker();
		originator.setState("State #1");
		originator.setState("State #2");
		careTaker.add(originator.saveStateToMemento());
		originator.setState("State #3");
		careTaker.add(originator.saveStateToMemento());
		originator.setState("State #4");

		System.out.println("Current State: " + originator.getState());
		originator.getStateFromMemento(careTaker.get(0));
		System.out.println("First saved State: " + originator.getState());
		originator.getStateFromMemento(careTaker.get(1));
		System.out.println("Second saved State: " + originator.getState());
	}
}

另一个例子

游戏进度保存，在玩“鬼泣”游戏时，中间往往可以保存游戏的进度，在闯关之前保存一下，如果没能通过，则恢复到上一次保存的状态.

1. originator：游戏的原有角色，保存角色当前的战斗值等属性，提供创建快照、通过快照恢复属性的方法

/**游戏角色发起人，负责创建并恢复备忘录
 * @author: 10191192
 * @date: 2019/9/17
 */
@Data
public class GameRoleOriginator {

	/** 描述游戏角色相关属性 */
	private int vit;
	private int attack;
	private int defence;

	public GameRoleOriginator(int vit, int attack, int defence) {
		this.vit = vit;
		this.attack = attack;
		this.defence = defence;
	}

	/**
	 * 展示自己的状态
	 * */
	public void show() {
		System.out.println("生命值：" + vit);
		System.out.println("攻击力：" + attack);
		System.out.println("防御力:" + defence);
	}

	/** 闯关之后，角色的状态*/
	public void fight() {
		this.attack = 0;
		this.defence = 0;
		this.vit = 0;
	}

	public RoleStateMemento saveRoleStateMemento() {
		return new RoleStateMemento(vit, attack, defence);
	}

	/**恢复角色状态*/
	public void recoveryState(RoleStateMemento memento) {
		this.vit = memento.getVit();
		this.attack = memento.getAttack();
		this.defence = memento.getDefence();
	}
}

2. memento：originator的一个快照，拥有与发起者一样的属性

/**游戏角色备忘录类，用来记录角色的状态
 * @author: 10191192
 * @date: 2019/9/17
 */
@Data
@AllArgsConstructor
public class RoleStateMemento {

	/** 游戏角色具有以下几种状态*/
	private int vit;
	private int attack;
	private int defence;
}

3. caretaker：负责保存备忘录,memento作为其中的私有属性封装，不允许修改其数据

/** 游戏角色管理者，负责备忘录类保存，不允许做任何修改操作
 * @author: 10191192
 * @date: 2019/9/17
 */
public class GameRoleCaretaker {

	private RoleStateMemento roleStateMemento;

	public RoleStateMemento getRoleStateMemento() {
		return roleStateMemento;
	}

	public void setRoleStateMemento(RoleStateMemento roleStateMemento) {
		this.roleStateMemento = roleStateMemento;
	}
}

4. 测试代码，

public class TestClient {

	public static void main(String[] args) {
		// 大战boss之前
		GameRoleOriginator gameRoleOriginator = new GameRoleOriginator(100, 100, 100);
		gameRoleOriginator.show();
		// 存档
		gameRoleOriginator.setVit(75);
		GameRoleCaretaker gameRoleCaretaker = new GameRoleCaretaker();
		gameRoleCaretaker.setRoleStateMemento(gameRoleOriginator.saveRoleStateMemento());

		// 大战boss之后
		gameRoleOriginator.fight();
		gameRoleOriginator.show();

		System.out.println("恢复保存的状态");
		// 恢复之前的状态
	gameRoleOriginator.recoveryState(gameRoleCaretaker.getRoleStateMemento());
		gameRoleOriginator.show();
	}
}

备忘录模式总结

备忘录模式的主要优点如下：

它提供了一种状态恢复的实现机制，使得用户可以方便地回到一个特定的历史步骤，当新的状态无效或者存在问题时，可以使用暂时存储起来的备忘录将状态复原。

备忘录实现了对信息的封装，一个备忘录对象是一种原发器对象状态的表示，不会被其他代码所改动。备忘录保存了原发器的状态，采用列表、堆栈等集合来存储备忘录对象可以实现多次撤销操作。

备忘录模式的主要缺点如下：

资源消耗过大，如果需要保存的原发器类的成员变量太多，就不可避免需要占用大量的存储空间，每保存一次对象的状态都需要消耗一定的系统资源。

适用场景：

保存一个对象在某一个时刻的全部状态或部分状态，这样以后需要时它能够恢复到先前的状态，实现撤销操作。

防止外界对象破坏一个对象历史状态的封装性，避免将对象历史状态的实现细节暴露给外界对象。