Java设计模式 备忘录模式

模式定义

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

备忘录模式结构图

备忘录模式主要包含入下几个角色：
Originator: 原发器： 负责创建一个备忘录，用以记录当前对象的内部状态，通过也可以使用它来利用备忘录恢复内部状态。同时原发器还可以根据需要决定Memento存储Originator的那些内部状态。
代码如下

package 备忘录模式;

public class Originator {//发起人类
	private String state;//需要保存的属性，需要有多个
	public Memento createMemento() {//创建备忘录，将当前需要保存的信息导入并实例化除一个Memento对象
		return (new Memento(state));
	}
	public void  setMemento(Memento memento) {//回复备忘录，将Memento导入并将相关数据恢复
		state =memento.getState();
	}
	public void show() {
		System.out.println(state);//显示数据
	}
	public String getState() {
		return state;
	}
	public void setState(String state) {
		this.state = state;
	}
	
}

Memento: 备忘录： 用于存储Originator的内部状态，并且可以防止Originator以外的对象访问Memento。在备忘录Memento中有两个接口，其中Caretaker只能看到备忘录中的窄接口，它只能将备忘录传递给其他对象。Originator可以看到宽接口，允许它访问返回到先前状态的所有数据。
代码如下：

package 备忘录模式;

public class Memento {//备忘录类 很安静
  private String state;

public Memento(String state) {//构造方法，将相关数据导入
	this.state = state;
}

public String getState() {
	return state;
}

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

Caretaker: 负责人： 负责保存好备忘录，不能对备忘录的内容进行操作和访问，只能够将备忘录传递给其他对象。

package 备忘录模式;

public class Caretaker {//管理者类
	private Memento memento;

	public Memento getMemento() {
		return memento;
	}

	public void setMemento(Memento memento) {//得到或设置备忘录
		this.memento = memento;
	}
}

客户端：

package 备忘录模式;

public class Main {
	public static void main(String[] args) {
		Originator ori =new Originator();
		ori.setState("On");//Originator初始状态，状态属性为“On”
		ori.show();
		
		Caretaker c = new Caretaker();
		c.setMemento(ori.createMemento());//保存状态是，由于有了很好的封装，可以隐藏Originator的实现细节
		 
		ori.setState("Off");//Originator改变了状态属性为“Off”
		ori.show();
		
		c.setMemento(ori.createMemento());//恢复为原来的状态
		
	}
}

在备忘录模式中，最重要的就是备忘录Memento了。我们都是备忘录中存储的就是原发器的部分或者所有的状态信息，而这些状态信息是不能够被其他对象所访问了，也就是说我们是不可能在备忘录之外的对象来存储这些状态信息，如果暴漏了内部状态信息就违反了封装的原则，故备忘录是除了原发器外其他对象都是不可以访问的。

模式的实例实现（游戏备忘录）

实现场景：我们就以游戏挑战BOSS为实现场景，在挑战BOSS之前，角色的血量、蓝量都是满值，然后存档，在大战BOSS时，由于操作失误导致血量和蓝量大量损耗，所以只好恢复到刚刚开始的存档点，继续进行大战BOSS了。这里使用备忘录模式来实现

package 备忘录模式;

class Role{
	private int bloodFlow;
    private int magicPoint;
    
    public Role(int bloodFlow,int magicPoint){
        this.bloodFlow = bloodFlow;
        this.magicPoint = magicPoint;
    }

    public int getBloodFlow() {
        return bloodFlow;
    }

    public void setBloodFlow(int bloodFlow) {
        this.bloodFlow = bloodFlow;
    }

    public int getMagicPoint() {
        return magicPoint;
    }

    public void setMagicPoint(int magicPoint) {
        this.magicPoint = magicPoint;
    }
    
    /**
     * @desc 展示角色当前状态
     * @return void
     */
    public void display(){
        System.out.println("用户当前状态:");
        System.out.println("血量:" + getBloodFlow() + ";蓝量:" + getMagicPoint());
    }
    
    /**
     * @desc 保持存档、当前状态
     * @return
     * @return Memento
     */
    public MementoRole saveMemento(){
        return new MementoRole(getBloodFlow(), getMagicPoint());
    }
    
    /**
     * @desc 恢复存档
     * @param memento
     * @return void
     */
    public void restoreMemento(MementoRole mementoRole){
        this.bloodFlow = mementoRole.getBloodFlow();
        this.magicPoint = mementoRole.getMagicPoint();
    }
}
class MementoRole{
	private int bloodFlow;
    private int magicPoint;

    public int getBloodFlow() {
        return bloodFlow;
    }

    public void setBloodFlow(int bloodFlow) {
        this.bloodFlow = bloodFlow;
    }

    public int getMagicPoint() {
        return magicPoint;
    }

    public void setMagicPoint(int magicPoint) {
        this.magicPoint = magicPoint;
    }
    
    public MementoRole(int bloodFlow,int magicPoint){
        this.bloodFlow = bloodFlow;
        this.magicPoint = magicPoint;
    }
}
class CaretakerRole{
	MementoRole mementoRole;
	
    public MementoRole getMementoRole() {
        return mementoRole;
    }

    public void setMemento(MementoRole mementoRole) {
        this.mementoRole = mementoRole;
    }
}
public class Test {
	public static void main(String[] args) {
		//打BOSS之前：血、蓝全部满值
        Role role = new Role(100, 100);
        System.out.println("----------大战BOSS之前----------");
        role.display();
        
        //保持进度
        CaretakerRole caretaker = new CaretakerRole();
        caretaker.mementoRole = role.saveMemento();
        
        //大战BOSS，快come Over了
        role.setBloodFlow(20);
        role.setMagicPoint(20);
        System.out.println("----------大战BOSS----------");
        role.display();
        
        //恢复存档
        role.restoreMemento(caretaker.getMementoRole());
        System.out.println("----------恢复----------");
        role.display();
	}
}

代码运行结果

模式的优缺点

优点：

• 有时一些发起人对象的内部信息必须保存在发起 人对象以外的地方，但是必须要由发起人对象自 起人内部信息对其他的对象屏蔽起来，从而可以悟当地保持封装的边界。实现了信息的封装。使得用户不需要关心状态的保存细节。
• 本模式简化了发起人类。发起人不再需要管理和保存其内部状态的一个个版本，客户端可以自行管理他们所需要的这些状态的版本。
• 当发起人角色的状态改变的时候，有可能这个状态无效，这时候就可以使用暂时存储起来的备忘录将状态复原。

缺点

• 如果发起人角色的状态需要完整地存储到备 忘录对象中，那么在资源消耗_上面备忘录对 象会很大。
• 当管理者角色将-一个备忘录存储起来的时候, 管理者可能并不知道这个状态会占用多大的 存储空间，从而无法提醒用户一个操作是否 很大。
  本质是：保存和恢复内部状态

试用的场所

如果必须保存-一个对象在某-一个时刻的全部 或者部分状态，方便在以后需要的时侯，可 以把该对象恢复到先前的状态，可以使用备 忘录模式管理者可能并不知道这个状态会占用多大的 存储空间，从而无法提醒用户一个操作是否很大。
部分内容转载自http://www.cnblogs.com/chenssy/