（18）Java设计模式 - 备忘录模式（Memento Pattern）

桃扇骨 2022-05-19 10:43 108阅读 0赞

# 备忘录模式 #

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

## 介绍 ##

**意图：**在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。  
**主要解决：**所谓备忘录模式就是在不破坏封装的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态，这样可以在以后将对象恢复到原先保存的状态。  
**何时使用：**很多时候我们总是需要记录一个对象的内部状态，这样做的目的就是为了允许用户取消不确定或者错误的操作，能够恢复到他原先的状态，使得他有"后悔药"可吃。  
**如何解决：**通过一个备忘录类专门存储对象状态。  
**关键代码：**客户不与备忘录类耦合，与备忘录管理类耦合。  
**应用实例：** 1、后悔药。 2、打游戏时的存档。 3、Windows 里的 ctri + z。 4、IE 中的后退。 4、数据库的事务管理。  
**优点：** 1、给用户提供了一种可以恢复状态的机制，可以使用户能够比较方便地回到某个历史的状态。 2、实现了信息的封装，使得用户不需要关心状态的保存细节。  
**缺点：**消耗资源。如果类的成员变量过多，势必会占用比较大的资源，而且每一次保存都会消耗一定的内存。  
**使用场景：** 1、需要保存/恢复数据的相关状态场景。 2、提供一个可回滚的操作。  
**注意事项：** 1、为了符合迪米特原则，还要增加一个管理备忘录的类。 2、为了节约内存，可使用原型模式+备忘录模式。

## 结构 ##

![SouthEast][]

备忘录模式主要包含入下几个角色：

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

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

## 实现 ##

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

![SouthEast 1][]

首先是游戏角色类：Role.java

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 Memento saveMemento(){
            return new Memento(getBloodFlow(), getMagicPoint());
        }
        
        /**
         * @desc 恢复存档
         * @param memento
         * @return void
         */
        public void restoreMemento(Memento memento){
            this.bloodFlow = memento.getBloodFlow();
            this.magicPoint = memento.getMagicPoint();
        }
    }

备忘录：Memento.java

class Memento {
        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 Memento(int bloodFlow,int magicPoint){
            this.bloodFlow = bloodFlow;
            this.magicPoint = magicPoint;
        }
    }

负责人：Caretaker.java

public class Caretaker {
        Memento memento;
     
        public Memento getMemento() {
            return memento;
        }
     
        public void setMemento(Memento memento) {
            this.memento = memento;
        }
     
    }

客户端：Client.java

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

运行结果

![SouthEast 2][]

# **模式的优缺点** #

##        优点 ##

1.  给用户提供了一种可以恢复状态的机制。可以是用户能够比较方便地回到某个历史的状态。
2.  实现了信息的封装。使得用户不需要关心状态的保存细节。

##        缺点 ##

消耗资源。如果类的成员变量过多，势必会占用比较大的资源，而且每一次保存都会消耗一定的内存。

# 模式适用场景 #

1.  需要保存一个对象在某一个时刻的状态或部分状态。
2.  如果用一个接口来让其他对象得到这些状态，将会暴露对象的实现细节并破坏对象的封装性，一个对象不希望外界直接访问其内部状态，通过负责人可以间接访问其内部状态。

# 模式总结 #

1.  备忘录模式可以实现在不破坏封装的前提下，捕获一个类的内部状态，并且在该对象之外保存该对象的状态，保证该对象能够恢复到历史的某个状态。
2.  备忘录模式实现了内部状态的封装，除了创建它的原发器之外其他对象都不能够访问它。
3.  备忘录模式会占用较多的内存，消耗资源。

[SouthEast]: /images/20220519/8b98dc2f4e4d46e0bb1b15bbfd66f7e2.png
[SouthEast 1]: /images/20220519/eae124b9add049bb85b9e42d011459ef.png
[SouthEast 2]: /images/20220519/64c19ecd01a54e8f868b3f2a32e4314e.png