设计模式-备忘录模式

Posted on | In
Words count in article: 792 | Reading time ≈ 3

备忘录模式

定义

备忘录模式（Memento Pattern）保存一个对象的某个状态，以便在适当的时候恢复对象。在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。

类图

备忘录模式类图

Originator（生成者）

会在保存自己的最新状态时生成Memento角色。当把以前保存的Memento角色传递给Originator角色时，它会将自己恢复至生产该Memento角色时的状态。

Memento（纪念品、备忘录）

会将Originator角色的内部信息整合在一起。在Memento角色中虽然保存了Originator角色的信息，但它不会像外部公开这些信息。

Memento有以下两种接口（API）

  • wide interface-宽接口

Memento提供的“宽接口”是指所有用于获取恢复对象状态信息的方法的集合。由于宽接口会暴露所有Memento的内部信息，因此能够使用款接口的只有Originator角色

  • narrow interface-窄接口

Memento为外部的CareTaker提供了“窄接口”。可以通过窄接口获取的Memento的内部信息非常有限，因此可以有效地防止信息泄露

CareTaker

当CareTaker想要保存当前的Originator的状态时，会通知Originator。Originator在接收到通知后会生成Memento的实例并将其返回给CareTake。由于后面可能会用Memento实例来将Originator恢复至原来的状态，因此CareTaker会一直保存Memento实例。

不过CareTaker只能使用Memento两种接口的窄接口，也就是说它无法访问Memento内部的所有信息。它只是将Originator生成的Memento当做一个黑盒子保存起来。

示例

类图

备忘录模式示例类图

Gamer

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
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
public class Gamer {
    private int money;                          
    private List fruits = new ArrayList();     
    private Random random = new Random();       
    private static String[] fruitsname = {      
        "1", "2", "3", "4",
    };
    public Gamer(int money) {                   
        this.money = money;
    }
    public int getMoney() {                     
        return money;
    }
    public void bet() {                         
        int dice = random.nextInt(6) + 1;           
        if (dice == 1) {                            
            money += 100;
            System.out.println("7");
        } else if (dice == 2) {                     
            money /= 2;
            System.out.println("6");
        } else if (dice == 6) {                     
            String f = getFruit();
            System.out.println("4" + f + "5");
            fruits.add(f);
        } else {                                    
            System.out.println("3");
        }
    }
    public Memento createMemento() {                
        Memento m = new Memento(money);
        Iterator it = fruits.iterator();
        while (it.hasNext()) {
            String f = (String)it.next();
            if (f.startsWith("2")) {         
                m.addFruit(f);
            }
        }
        return m;
    }
    public void restoreMemento(Memento memento) {   
        this.money = memento.money;
        this.fruits = memento.getFruits();
    }
    public String toString() {                      
        return "[money = " + money + ", fruits = " + fruits + "]";
    }
    private String getFruit() {                     
        String prefix = "";
        if (random.nextBoolean()) {
            prefix = "1";
        }
        return prefix + fruitsname[random.nextInt(fruitsname.length)];
    }
}

Memento

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class Memento {
    int money;                              
    ArrayList fruits;                       
    public int getMoney() {                 
        return money;
    }
    Memento(int money) {                    
        this.money = money;
        this.fruits = new ArrayList();
    }
    void addFruit(String fruit) {           
        fruits.add(fruit);
    }
    List getFruits() {                      
         return (List)fruits.clone();
    }
}

Main

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
27
28
public class Main {
    public static void main(String[] args) {
        Gamer gamer = new Gamer(100);               
        Memento memento = gamer.createMemento();    
        for (int i = 0; i < 100; i++) {
            System.out.println("==== " + i);        
            System.out.println("0" + gamer);    


            System.out.println("1" + gamer.getMoney() + "2");

            if (gamer.getMoney() > memento.getMoney()) {
                System.out.println("3");
                memento = gamer.createMemento();
            } else if (gamer.getMoney() < memento.getMoney() / 2) {
                System.out.println("4");
                gamer.restoreMemento(memento);
            }

            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
            }
            System.out.println("");
        }
    }
}

0%