备忘录模式（Memento Pattern）

备忘录模式

说明

备忘录模式（Memento Pattern）属于行为型模式，又称为快照模式（Snapshot Pattern）或令牌模式（Token Pattern），是指在不破坏封装的前提下，捕获一个对象的内部状态，并在对象之外保存这个状态。这样以后就可将该对象恢复到原先保存的状态。
平时工作中各种编辑器的撤回，开发中的版本控制工具的回滚等等，其实都是备忘录模式的体现。备忘录模式不是像原型模式一样简单的克隆一个对象，备忘录保存的对象会交给一个单独的管理者管理，对外部来说是安全的。

结构

备忘录模式的主要角色如下：
Originator（发起人）：需要保存状态的对象，实现创建Memento对象的方法，并且可以根据Memento对象进行恢复；
Memento（备忘录）：负责存储Originator需要保存的对象，该对象只能通过Originator创建时赋值，其他对象不能改变它的值；
Caretaker（管理者）：负责保存好Originator创建的Memento对象。

代码案例

Originator（发起人）

/**
 * @program: memento
 * @description: 茅山道人
 *              Originator（发起人）
 * @author: wxw
 * @create: 2024-03-12 16:01
 **/
@Data
@ToString
public class TaoistPriest {

    private String name;
    private String sect;
    private Integer hp;

    // 保存元神
    public PrimordialSpirit saveSpirit(){
        return new PrimordialSpirit(hp);
    }

    // 利用元神重生
    public void rebirth(PrimordialSpirit spirit){
        this.hp = spirit.getHp();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

Memento（备忘录）

/**
 * @program: memento
 * @description: 元神
 *              Memento（备忘录）
 * @author: wxw
 * @create: 2024-03-12 16:07
 **/
public class PrimordialSpirit {

    private Integer hp;

    public PrimordialSpirit(Integer hp) {
        this.hp = hp;
    }

    public Integer getHp() {
        return hp;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

Caretaker（管理者）

/**
 * @program: memento
 * @description: 道士徒弟，管理师父的元神
 *              Caretaker（管理者）
 * @author: wxw
 * @create: 2024-03-12 16:11
 **/
public class TaoistPriestDisciple {

    private PrimordialSpirit primordialSpirit;

    public void setPrimordialSpirit(PrimordialSpirit primordialSpirit) {
        this.primordialSpirit = primordialSpirit;
    }

    public PrimordialSpirit getPrimordialSpirit() {
        return primordialSpirit;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

客户端

public class Test {
    public static void main(String[] args) {
        System.out.println("=========== 茅山传人-毛小方大战大魔头 ==========");
        TaoistPriest maoxiaofang = new TaoistPriest();
        maoxiaofang.setName("毛小方");
        maoxiaofang.setSect("茅山派传人");
        maoxiaofang.setHp(100);

        System.out.println("大战之前毛小方的状态：" + maoxiaofang);
        System.out.println("毛小方知道不是大魔头的对手，大战之前将元神交给了徒弟管理，等死后利用元神复活...");
        TaoistPriestDisciple disciple = new TaoistPriestDisciple();
        PrimordialSpirit primordialSpirit = maoxiaofang.saveSpirit();
        disciple.setPrimordialSpirit(primordialSpirit);

        System.out.println("大战开始...");
        System.out.println("大战结束...毛小方牺牲...");
        maoxiaofang.setHp(0);
        System.out.println("当前毛小方的状态：" + maoxiaofang);
        System.out.println("徒弟利用毛小方告诉的方法，用元神将毛小方复活...");
        PrimordialSpirit spirit = disciple.getPrimordialSpirit();
        maoxiaofang.setHp(spirit.getHp());
        System.out.println("复活成功，毛小方的状态：" + maoxiaofang);
        System.out.println("毛小方复活让大魔头出其不意，毛小方战胜大魔头....");

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

输出

=========== 茅山传人-毛小方大战大魔头 ==========
大战之前毛小方的状态：TaoistPriest(name=毛小方, sect=茅山派传人, hp=100)
毛小方知道不是大魔头的对手，大战之前将元神交给了徒弟管理，等死后利用元神复活...
大战开始...
大战结束...毛小方牺牲...
当前毛小方的状态：TaoistPriest(name=毛小方, sect=茅山派传人, hp=0)
徒弟利用毛小方告诉的方法，用元神将毛小方复活...
复活成功，毛小方的状态：TaoistPriest(name=毛小方, sect=茅山派传人, hp=100)
毛小方复活让大魔头出其不意，毛小方战胜大魔头....
1
2
3
4
5
6
7
8
9