23种设计模式(18)java备忘录模式

时间:2022-03-20 05:55:51

23种设计模式第十八篇:java备忘录模式

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

类型:行为类

类图:

23种设计模式(18)java备忘录模式

我们在编程的时候,经常需要保存对象的中间状态,当需要的时候,可以恢复到这个状态。比如,我们使用eclipse进行编程时,假如编写失误(例如不小心误删除了几行代码),我们希望返回删除前的状态,便可以使用ctrl+z来进行返回。这时我们便可以使用备忘录模式来实现。

备忘录模式的结构

发起人:记录当前时刻的内部状态,负责定义哪些属于备份范围的状态,负责创建和恢复备忘录数据。
备忘录:负责存储发起人对象的内部状态,在需要的时候提供发起人需要的内部状态。
管理角色:对备忘录进行管理,保存和提供备忘录。

通用代码实现

 

?
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
class originator {
    private string state = "";
     
    public string getstate() {
      return state;
    }
    public void setstate(string state) {
      this.state = state;
    }
    public memento creatememento(){
      return new memento(this.state);
    }
    public void restorememento(memento memento){
      this.setstate(memento.getstate());
    }
  }
   
  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;
    }
  }
  class caretaker {
    private memento memento;
    public memento getmemento(){
      return memento;
    }
    public void setmemento(memento memento){
      this.memento = memento;
    }
  }
  public class client {
    public static void main(string[] args){
      originator originator = new originator();
      originator.setstate("状态1");
      system.out.println("初始状态:"+originator.getstate());
      caretaker caretaker = new caretaker();
      caretaker.setmemento(originator.creatememento());
      originator.setstate("状态2");
      system.out.println("改变后状态:"+originator.getstate());
      originator.restorememento(caretaker.getmemento());
      system.out.println("恢复后状态:"+originator.getstate());
    }
  }

        代码演示了一个单状态单备份的例子,逻辑非常简单:originator类中的state变量需要备份,以便在需要的时候恢复;memento类中,也有一个state变量,用来存储originator类中state变量的临时状态;而caretaker类就是用来管理备忘录类的,用来向备忘录对象中写入状态或者取回状态。

多状态多备份备忘录

       通用代码演示的例子中,originator类只有一个state变量需要备份,而通常情况下,发起人角色通常是一个javabean,对象中需要备份的变量不止一个,需要备份的状态也不止一个,这就是多状态多备份备忘录。
        实现备忘录的方法很多,备忘录模式有很多变形和处理方式,像通用代码那样的方式一般不会用到,多数情况下的备忘录模式,是多状态多备份的。其实实现多状态多备份也很简单,最常用的方法是,我们在memento中增加一个map容器来存储所有的状态,在caretaker类中同样使用一个map容器才存储所有的备份。下面我们给出一个多状态多备份的例子:

?
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
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
class originator {
    private string state1 = "";
    private string state2 = "";
    private string state3 = "";
   
    public string getstate1() {
      return state1;
    }
    public void setstate1(string state1) {
      this.state1 = state1;
    }
    public string getstate2() {
      return state2;
    }
    public void setstate2(string state2) {
      this.state2 = state2;
    }
    public string getstate3() {
      return state3;
    }
    public void setstate3(string state3) {
      this.state3 = state3;
    }
    public memento creatememento(){
      return new memento(beanutils.backupprop(this));
    }
     
    public void restorememento(memento memento){
      beanutils.restoreprop(this, memento.getstatemap());
    }
    public string tostring(){
      return "state1="+state1+"state2="+state2+"state3="+state3;
    }
  }
  class memento {
    private map<string, object> statemap;
     
    public memento(map<string, object> map){
      this.statemap = map;
    }
   
    public map<string, object> getstatemap() {
      return statemap;
    }
   
    public void setstatemap(map<string, object> statemap) {
      this.statemap = statemap;
    }
  }
  class beanutils {
    public static map<string, object> backupprop(object bean){
      map<string, object> result = new hashmap<string, object>();
      try{
        beaninfo beaninfo = introspector.getbeaninfo(bean.getclass());
        propertydescriptor[] descriptors = beaninfo.getpropertydescriptors();
        for(propertydescriptor des: descriptors){
          string fieldname = des.getname();
          method getter = des.getreadmethod();
          object fieldvalue = getter.invoke(bean, new object[]{});
          if(!fieldname.equalsignorecase("class")){
            result.put(fieldname, fieldvalue);
          }
        }
         
      }catch(exception e){
        e.printstacktrace();
      }
      return result;
    }
     
    public static void restoreprop(object bean, map<string, object> propmap){
      try {
        beaninfo beaninfo = introspector.getbeaninfo(bean.getclass());
        propertydescriptor[] descriptors = beaninfo.getpropertydescriptors();
        for(propertydescriptor des: descriptors){
          string fieldname = des.getname();
          if(propmap.containskey(fieldname)){
            method setter = des.getwritemethod();
            setter.invoke(bean, new object[]{propmap.get(fieldname)});
          }
        }
      } catch (exception e) {
        e.printstacktrace();
      }
    }
  }
  class caretaker {
    private map<string, memento> memmap = new hashmap<string, memento>();
    public memento getmemento(string index){
      return memmap.get(index);
    }
     
    public void setmemento(string index, memento memento){
      this.memmap.put(index, memento);
    }
  }
  class client {
    public static void main(string[] args){
      originator ori = new originator();
      caretaker caretaker = new caretaker();
      ori.setstate1("中国");
      ori.setstate2("强盛");
      ori.setstate3("繁荣");
      system.out.println("===初始化状态===\n"+ori);
       
      caretaker.setmemento("001",ori.creatememento());
      ori.setstate1("软件");
      ori.setstate2("架构");
      ori.setstate3("优秀");
      system.out.println("===修改后状态===\n"+ori);
       
      ori.restorememento(caretaker.getmemento("001"));
      system.out.println("===恢复后状态===\n"+ori);
    }
  }

备忘录模式的优缺点和适用场景

备忘录模式的优点有:

        当发起人角色中的状态改变时,有可能这是个错误的改变,我们使用备忘录模式就可以把这个错误的改变还原。
        备份的状态是保存在发起人角色之外的,这样,发起人角色就不需要对各个备份的状态进行管理。

备忘录模式的缺点有:

        在实际应用中,备忘录模式都是多状态和多备份的,发起人角色的状态需要存储到备忘录对象中,对资源的消耗是比较严重的。
        如果有需要提供回滚操作的需求,使用备忘录模式非常适合,比如jdbc的事务操作,文本编辑器的ctrl+z恢复等。

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持服务器之家。