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

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

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

类型:行为类

类图:

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

备忘录模式的结构

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

通用代码实现

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容器才存储所有的备份。下面我们给出一个多状态多备份的例子:

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恢复等。

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

您可能感兴趣的文章:

  • Java设计模式之备忘录模式_动力节点Java学院
  • JAVA设计模式之备忘录模式原理与用法详解
  • 轻松掌握Java备忘录模式
  • 详解备忘录模式及其在Java设计模式编程中的实现
  • 详解Java设计模式之备忘录模式的使用
  • Java设计模式之备忘录模式(Memento模式)介绍
(0)

相关推荐

  • 详解Java设计模式之备忘录模式的使用

    定义与结构     备忘录(Memento)模式又称标记(Token)模式.GOF给备忘录模式的定义为:在不破坏封装性的前提下,捕获一个对象的内部状态,并在该对象之外保存这个状态.这样以后就可将该对象恢复到原先保存的状态. 在讲命令模式的时候,我们曾经提到利用中间的命令角色可以实现undo.redo的功能.从定义可以看出备忘录模式是专门来存放对象历史状态的,这对于很好的实现undo.redo功能有很大的帮助.所以在命令模式中undo.redo功能可以配合备忘录模式来实现. 其实单就实现保存一个对

  • Java设计模式之备忘录模式_动力节点Java学院

    定义:在不破坏封装性的前提下,捕获一个对象的内部状态,并在该对象之外保存这个状态.这样就可以将该对象恢复到原先保存的状态 类型:行为类 类图: 我们在编程的时候,经常需要保存对象的中间状态,当需要的时候,可以恢复到这个状态.比如,我们使用Eclipse进行编程时,假如编写失误(例如不小心误删除了几行代码),我们希望返回删除前的状态,便可以使用Ctrl+Z来进行返回.这时我们便可以使用备忘录模式来实现. 备忘录模式的结构 发起人:记录当前时刻的内部状态,负责定义哪些属于备份范围的状态,负责创建和

  • 详解备忘录模式及其在Java设计模式编程中的实现

    1. 定义 在不破坏封装性的前提下,捕获一个对象的内部状态,并在该对象之外保存这个状态.这样以后就可将该对象恢复到原先保存的状态. 2. 使用的原因 想要恢复对象某时的原有状态. 3. 适用的情况举例 有很多备忘录模式的应用,只是我们已经见过,却没细想这是备忘录模式的使用罢了,略略举几例: eg1. 备忘录在jsp+javabean的使用: 在一系统中新增帐户时,在表单中需要填写用户名.密码.联系电话.地址等信息,如果有些字段没有填写或填写错误,当用户点击"提交"按钮时,需要在新增页面

  • Java设计模式之备忘录模式(Memento模式)介绍

    Memento定义:memento是一个保存另外一个对象内部状态拷贝的对象,这样以后就可以将该对象恢复到原先保存的状态. Memento模式相对也比较好理解,我们看下列代码: 复制代码 代码如下: public class Originator { private int number; private File file = null; public Originator(){} // 创建一个Memento public Memento getMemento(){ return new Me

  • JAVA设计模式之备忘录模式原理与用法详解

    本文实例讲述了JAVA设计模式之备忘录模式.分享给大家供大家参考,具体如下: 备忘录模式:又叫做快照模式,指在不破坏封装性的前提下,获取到一个对象的内部状态,并在对象之外记录或保存这个状态.在有需要的时候可将该对象恢复到原先保存的状态.我们相当于把对象原始状备份保留,所以叫备忘录模式. *模式 角色对象组成: 1.发起者对象:负责创建一个备忘录来记录当前对象的内部状态,并可使用备忘录恢复内部状态. 2.备忘录对象:负责存储发起者对象的内部状态,并防止其他对象访问备忘录. 3.管理者对象:负责备忘

  • 轻松掌握Java备忘录模式

    定义:保存一个对象的某个状态,以便在适当的时候恢复对象 特点: 1.给用户提供了一种可以恢复状态的机制,可以使用户能够比较方便地回到某个历史的状态. 2.实现了信息的封装,使得用户不需要关心状态的保存细节. 企业级应用和常用框架中的应用:常见文本编辑器使用了该模式 实例: 注意:该实例中只有撤销操作,没有向前还原操作 /** * 目标对象:将要被备忘的对象 */ class Word { private String content; private String image; private

  • Java设计模式之java备忘录模式详解

    目录 引言 备忘录模式(Memento Pattern) 角色 为什么会出现守护者对象(负责人)? 备忘录模式实现框架 下棋案例 备忘录模式总结 优点 缺点 适用场景 注意细节 参考文章 总结 引言 备忘录模式经常可以遇到,譬如下面这些场景: 浏览器回退:浏览器一般有浏览记录,当我们在一个网页上点击几次链接之后,可在左上角点击左箭头回退到上一次的页面,然后也可以点击右箭头重新回到当前页面 数据库备份与还原:一般的数据库都支持备份与还原操作,备份即将当前已有的数据或者记录保留,还原即将已经保留的数

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

    23种设计模式第十八篇:java备忘录模式 定义:在不破坏封装性的前提下,捕获一个对象的内部状态,并在该对象之外保存这个状态.这样就可以将该对象恢复到原先保存的状态. 类型:行为类 类图: 我们在编程的时候,经常需要保存对象的中间状态,当需要的时候,可以恢复到这个状态.比如,我们使用Eclipse进行编程时,假如编写失误(例如不小心误删除了几行代码),我们希望返回删除前的状态,便可以使用Ctrl+Z来进行返回.这时我们便可以使用备忘录模式来实现. 备忘录模式的结构 发起人:记录当前时刻的内部状态

  • 23种设计模式(7) java代理模式

    23种设计模式第七篇:java代理模式 定义: 为其他对象提供一种代理以控制对这个对象的访问.在某些情况下,一个对象不适合或者不能直接引用另一个对象,而代理对象可以在客户端和目标对象之间起到中介的作用 角色: 1.抽象角色:声明真实对象和代理对象的共同接口. 2.代理角色:代理对象角色内部含有对真实对象的引用,从而可以操作真实对象,同时代理对象提供与真实对象相同的接口以便在任何时刻都能代替真实对象.同时,代理对象可以在执行真实对象操作时,附加其他的操作,相当于对真实对象进行封装. 3.真实角色:

  • 23种设计模式(4) java生成器模式

    23种设计模式第四篇:java生成器模式 定义: 将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示.生成器模式利用一个导演者对象和具体建造者对象一个一个地建造出所有的零件,从而建造出完整的对象. 四个要素: Builder:生成器接口,定义创建一个Product对象所需要的各个部件的操作.         ConcreteBuilder:具体的生成器实现,实现各个部件的创建,并负责组装Product对象的各个部件,同时还提供一个让用户获取组装完成后的产品对象的方法.   

  • 23种设计模式(3) java原型模式

    23种设计模式第三篇:java原型模式 定义: 通过复制现有的对象实例来创建新的对象实例. 实现: 实现Cloneable接口: Cloneable接口的作用是在运行时通知虚拟机可以安全地在实现了此接口的类上使用clone方法.在java虚拟机中,只有实现了这个接口的类才可以被拷贝,否则在运行时会抛出CloneNotSupportedException异常. 重写Object类中的clone方法: Java中,所有类的父类都是Object类,Object类中有一个clone方法,作用是返回对象的

  • 23种设计模式(6) java装饰者模式

    23种设计模式第六篇:java装饰者模式 定义: 在不必改变原类文件和原类使用的继承的情况下,动态地扩展一个对象的功能.     它是通过创建一个包装对象,也就是用装饰来包裹真实的对象来实现. 角色: 抽象构件角色(Project):给出一个接口,以规范准备接收附加责任的对象.     具体构件角色(Employe):定义一个将要接收附加责任的类.     装饰角色(Manager):持有一个构件对象的实例,并定义一个与抽象构件接口一致的接口.     具体装饰角色(ManagerA.Manag

  • 23种设计模式(8) java外观模式

    23种设计模式第八篇:java外观模式 定义: 为子系统中的一组接口提供一个一致的界面,Facade模式定义了一个高层接口,这个接口使得这一子系统更加容易使用. 角色: 1.外观(Facade)角色 :客户端可以调用这个角色的方法.此角色知晓相关子系统的功能和责任.在正常情况下,本角色会将所有从客户端发来的请求委派到相应的子系统去. 2.子系统(SubSystem)角色 :可以同时有一个或者多个子系统.每个子系统都不是一个单独的类,而是一个类的集合.每个子系统都可以被客户端直接调用,或者被外观角

  • 23种设计模式(2) java工厂模式

    23种设计模式第二篇:java工厂模式 定义: 工厂模式是 Java 中最常用的设计模式之一.这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式. 工厂模式主要是为创建对象提供过渡接口,以便将创建对象的具体过程屏蔽隔离起来,达到提高灵活性的目的. 工厂模式根据抽象程度的不同分为三种: 简单工厂模式(也叫静态工厂模式) 工厂方法模式(也叫多形性工厂) 抽象工厂模式(也叫工具箱) 简单工厂模式 实质是由一个工厂类根据传入的参数,动态决定应该创建哪一个产品类(这些产品类继承自一个父类或接

  • 23种设计模式(10)java组合模式

    23种设计模式第四篇:java组合模式 介绍 组合模式又叫做部分-整体模式,它使我们树型结构的问题中,模糊了简单元素和复杂元素的概念,客户程序可以向处理简单元素一样来处理复杂元素,从而使得客户程序与复杂元素的内部结构解藕. 组合模式可以优化处理递归或分级数据结构.有许多关于分级数据结构的例子,使得组合模式非常有用武之地. 类图 组成部分: Component: 为参加组合的对象声明一个公共接口, 不管是组合还是叶结点. Leaf: 在组合中表示叶子结点对象,叶子结点没有子结点. Composit

  • 23种设计模式(12)java模版方法模式

    23种设计模式第四篇:java模版方法模式 定义:定义一个操作中算法的框架,而将一些步骤延迟到子类中,使得子类可以不改变算法的结构即可重定义该算法中的某些特定步骤. 类型:行为类模式 类图: 事实上,模版方法是编程中一个经常用到的模式.先来看一个例子,某日,程序员A拿到一个任务:给定一个整数数组,把数组中的数由小到大排序,然后把排序之后的结果打印出来.经过分析之后,这个任务大体上可分为两部分,排序和打印,打印功能好实现,排序就有点麻烦了.但是A有办法,先把打印功能完成,排序功能另找人做. abs

随机推荐