“设计模式系列-原型模式,备忘录模式”


原型模式

定义: 用原型实例指定创建对象的种类,并且通过拷贝这些原型创建新的对象。

    public class PrototypeClass implements Cloneable{

         //覆写父类Object方法
         @Override
         public PrototypeClass clone(){
                 PrototypeClass prototypeClass = null;
                 try {
                        prototypeClass = (PrototypeClass)super.clone();
                 } catch (CloneNotSupportedException e) {
                        //异常处理
                 }
                 return prototypeClass;
         }
    }

原型模式已经与Java融为一体,大家可以随手拿来使用。

资源性能优化场景:
类初始化需要非常繁琐的数据准备,需要消化非常多的资源,这个资源包括数据、硬件资源等。
一个对象多个修改者的场景:
一个对象需要提供给其他对象访问,而且各个调用者可能都需要修改其值时,可以考虑使用原型模式拷贝多个对象供调用者使用。

注意:
clone时构造函数不会被执行,Object类的clone方法的原理是从内存中(具体地说就是堆内存)以二进制流的方式进行拷贝,重新分配一个内存块,那构造函数没有被执行也是非常正常的了。

浅拷贝和深拷贝:
关于浅拷贝:

    public class Thing implements Cloneable{
         //定义一个私有变量
         private ArrayList arrayList = new ArrayList();

         @Override
         public Thing clone(){
                 Thing thing=null;
                 try {
                        thing = (Thing)super.clone();
                 } catch (CloneNotSupportedException e) {
                        e.printStackTrace();
                 }
                 return thing;
         }
         public void setValue(String value){
                 this.arrayList.add(value);
         }
         public ArrayList getValue(){
                 return this.arrayList;
         }
    }

Object类提供的方法clone只是拷贝本对象,其对象内部的数组、引用对象等都不拷贝,还是指向原生对象的内部元素地址,这种拷贝就叫做浅拷贝。
原始类型+装箱类型+String 会被拷贝,但其他的内部成员对象和数组不会拷贝,只会拷贝其引用。

关于深拷贝:

    public class Thing implements Cloneable{
         //定义一个私有变量
         private ArrayList arrayList = new ArrayList();
         @Override
         public Thing clone(){
                 Thing thing=null;
                 try {
                        thing = (Thing)super.clone();
                        thing.arrayList = (ArrayList)this.arrayList.clone();
                 } catch (CloneNotSupportedException e) {
                        e.printStackTrace();
                 }
                 return thing;
         }
    }

注意这里数组与ArrayList等clone,只会拷贝内部元素的引用数组,并不会深拷贝数组内部的元素。

关于一些其他的拷贝的姿势:

1.序列化(List深拷贝)

    public static List deepCopy(List src) throws IOException, ClassNotFoundException {
        ByteArrayOutputStream byteOut = new ByteArrayOutputStream();
        ObjectOutputStream out = new ObjectOutputStream(byteOut);
        out.writeObject(src);

        ByteArrayInputStream byteIn = new ByteArrayInputStream(byteOut.toByteArray());
        ObjectInputStream in = new ObjectInputStream(byteIn);
        List dest = (List) in.readObject();
        return dest;
    }

2.System.arraycopy(数组的浅拷贝)

这个方法不是用java语言写的,而是底层用c或者c++实现的,因而速度会比较快。但是是浅拷贝

3.Arrays.copyOf(数组的浅拷贝)

调用的是System.arraycopy,如ArrayList的clone方法调用的就是Arrays.copyOf。

备忘录模式

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

角色:

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

    //发起人角色
    public 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());
         }
    }

    //备忘录角色
    public 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;
         }
    }

    //备忘录管理员角色
    public 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();
                 //定义出备忘录管理员
                 Caretaker caretaker = new Caretaker();
                 //创建一个备忘录
                 caretaker.setMemento(originator.createMemento());
                 //恢复一个备忘录
                 originator.restoreMemento(caretaker.getMemento());
         }
    }

备忘录模式变种:

1.clone 方式的备忘录(发起者与备忘录融合)

    //发起者与备忘录融合
    public class Originator implements Cloneable{
         //内部状态
         private String state = "";

         public String getState() {
                 return state;
         }
         public void setState(String state) {
                 this.state = state;
         }
         //创建一个备忘录
         public Originator createMemento(){
                 return this.clone();
         }
         //恢复一个备忘录
         public void restoreMemento(Originator _originator){
                 this.setState(_originator.getState());
         }
         //克隆当前对象
         @Override
         protected Originator clone(){
                 try {
                         return (Originator)super.clone();
                 } catch (CloneNotSupportedException e) {
                         e.printStackTrace();
                 }
                 return null;
         }
    }

    public class Caretaker {
         //发起人对象
         private Originator originator;
         public Originator getOriginator() {
                 return originator;
         }
         public void setOriginator(Originator originator) {
                 this.originator = originator;
         }
    }

1.clone 方式的备忘录(发起者与备忘录和管理者 融合)

    public class Originator implements Cloneable{
         private Originator backup;
         //内部状态
         private String state = "";
         public String getState() {
                 return state;
         }
         public void setState(String state) {
                 this.state = state;
         }
         //创建一个备忘录
         public void createMemento(){
                 this.backup = this.clone();
         }
         //恢复一个备忘录
         public void restoreMemento(){
                 //在进行恢复前应该进行断言,防止空指针
                 this.setState(this.backup.getState());
         }
         //克隆当前对象
         @Override
         protected Originator clone(){
                 try {
                         return (Originator)super.clone();
                 } catch (CloneNotSupportedException e) {
                         e.printStackTrace();
                 }
                 return null;
         }
    }

提问?在该对象之外保存这个状态,是否矛盾?

现在我们来考虑一下原型模式深拷贝和浅拷贝的问题,在复杂的场景下它会让你的程序逻辑异常混乱,出现错误也很难跟踪。因此Clone方式的备忘录模式适用于较简单的场景。

多状态的时候需要怎么写?

    public class Caretaker {
         //容纳备忘录的容器
         private ArrayMap<String,Memento> memMap = new ArrayMap<String,Memento>();
         public Memento getMemento(String idx) {
                 return memMap.get(idx);
         }
         public void setMemento(String idx,Memento memento) {
                 this.memMap.put(idx, memento);
         }
    }


本作品由 Tony Zhang 创作,采用 CC BY-NC-SA 3.0 许可协议 进行许可。

Comments