Android 实现备忘录效果 安卓备忘录实现

本文研究如何在Android游戏开发中使用备忘录模式进行游戏存档，包含介绍备忘录模式，备忘录模式的实现、优化、拓展等。并会探讨备忘录模式巧妙的设计。

以飞行射击游戏类型为例，飞行射击游戏中，必不可少的一个角色是飞机。我们设计它有这几个状态：生命值、子弹类型、炸弹数目。另外它有三个方法：开始游戏、暂停游戏、恢复游戏。那么这个飞机类我们的初步设计如下：

 

package com.ansiinfo.plane.role;                                                         
public  class Plane {
    private  int health;
    private  int bulletType;
    private  int bombNum;
    public  void play(){};
    public  void pause(){};
    public  void resume(){};
    //get set省略
}

 

我们另外有一个客户端类，用来操作飞机开始游戏，并负责状态的存档。那么这个类可能是这样子的：

 

package com.ansiinfo.plane.role;                                                             
 
public  class Client {
    public  static void main(String[] args) {
       Plane p = new Plane();
       p.play();
//存档
       p.pause();
       Plane back = new Plane();
       back.setHealth(p.getHealth());
       back.setBombNum(p.getBombNum());
       back.setBulletType(p.getBulletType());
       p.resume();
//读取存档
       p.pause();
       p.setHealth(back.getHealth());
       p.setBombNum(back.getBombNum());
       p.setBulletType(back.getBulletType());
    }
}

 

我们使用了一个Plane的备份来保存数据，这样做的确能实现存档功能，但是有一个很大的缺陷：Plane类对外暴露了它的状态操作，这样是不满足面向对象设计思想中的封装性的。如果随便外面的对象都可以修改Plane的状态，那么会造成系统很不稳定。

如果把存档和状态保存的逻辑（即save和load方法）放入Plane中的话，也是一个思路，这样的话不会对外暴露内部状态，但是如果我们需要维护多个存档，或者需要对存档进行持久化等，会造成Plane越来越庞大，也是不满足OO思想的。

备忘录模式介绍

备忘录模式，又叫快照模式，或Token模式，是对象的行为模式。备忘录对象是一个用来存储另外一个对象内部状态的快照的对象。备忘录模式的用意是在不破坏封装的条件下，将一个对象的状态捕捉住，并外部化，存储起来，从而可以在将来合适的时候把这个对象还原到存储起来的状态。备忘录模式常常与命令模式和迭代子模式一同使用。

备忘录模式的类图如下：

它有三个角色：

Originator（原发器）：它是一个普通类，可以创建一个备忘录，并存储它的当前内部状态，也可以使用备忘录来恢复其内部状态，一般将需要保存内部状态的类设计为原发器。

在这里，它对应我们的Plane类。

Memento（备忘录)：存储原发器的内部状态，根据原发器来决定保存哪些内部状态。备忘录的设计一般可以参考原发器的设计，根据实际需要确定备忘录类中的属性。需要注意的是，除了原发器本身与负责人类之外，备忘录对象不能直接供其他类使用，原发器的设计在不同的编程语言中实现机制会有所不同。

在我们的背景中，我们将它命名为存档Record。

Caretaker（负责人）：负责人又称为管理者，它负责保存备忘录，但是不能对备忘录的内容进行操作或检查。在负责人类中可以存储一个或多个备忘录对象，它只负责存储对象，而不能修改对象，也无须知道对象的实现细节。

我们将名称简化为Controller。

这样我们修改后的类图如下：

备忘录模式有个特点：Record类对Plane提供宽接口，即Plane可以访问Record的内部状态，从而进行存档的恢复。Record类对Controller提供窄接口，只允许Controller操作，但不允许其访问Record内部状态。

我们分两步来实现，第一步：不区分宽接口和窄接口，先采用白盒的方式实现；第二步：采用巧妙的设计区分窄接口和宽接口，实现黑盒操作。

备忘录模式的白盒实现

所谓白盒实现，即Record类对外统一提供宽接口，靠程序员的自我约束来避免破坏封装。这种方式下几个类的代码分别如下：

Plane类增加两个个方法：getRecord和loadRecord

package com.ansiinfo.plane.role;
public  class Plane {
    private  int health;
    private  int bulletType;
    private  int bombNum;
    public  void play(){};
    public  void pause(){};
    public  void resume(){};
    //get set省略

    public Record getRecord(){
       Record r = new Record();
health);
bombNum);
bulletType);
       return r;
    }
    public  void loadRecord(Record r){
       this.health
       this.bombNum
       this.bulletType
    }
}

 

可以看出，Record对Plane类是开放的，Plane可以随意获得和设置Record的状态。

 

Record类的代码如下：

package com.ansiinfo.plane.role;
public  class Record {
     private  int health;
    private  int bulletType;
    private  int bombNum;
    //get set省略
}

可以看出，Record类只是对Plane状态的维护，没有其他的逻辑。

 

Controller的代码如下：

package com.ansiinfo.plane.role;                                                                                                                                
public  class Controller {
    private Recordr;
    public  void saveRecord(Record r) {
       this.r
    }
    public  Record
       returnr;
    }
}

可以看出，Controller只是对存档的维护,并没有访问Record的状态。

 

Client代码如下：

package com.ansiinfo.plane.role;                                                                                                                                
 
public  class Client {
    public  static void main(String[] args) {
       Plane p = new Plane();
       Controller c = new Controller();
       
       p.play();
       p.pause();
//存档
       c.saveRecord(p.getRecord());
       
       
       p.play();
       
//读取存档
       p.pause();
       p.loadRecord(c.loadRecord());
    }
}

 

这样就完成了备忘录模式的白盒实现，存在的问题是Controller类虽然没有访问Record的内部状态，但实际它是由这个能力的，只能靠开发者的自我约束，接下来研究如何做到Record对Controller实现真正的窄接口。

备忘录模式的黑盒研究

所谓的黑盒是指要实现：Record类对Plane提供宽接口，即可以让Plane访问其状态；同时Record类对Controller提供窄接口，不允许其访问内部状态。

要在JAVA语言中实现如上功能，可以采用的方法是使用内部类。具体的办法如下：

1.  将Record修改为一个接口，不提供任何实现。

2.  在Plane中增加一个内部类InnerRecord，实现Record接口。

3.  把以前的Record里面的逻辑移植到InnerRecord中。

 

具体类图如下：

 

只需修改Plane类和Record类，修改后的内容如下：

 

Record:标识接口，不提供内容。

package com.ansiinfo.plane.role;                                                                                                     
 
public  interface Record {
}

 

Plane类：

package com.ansiinfo.plane.role; 
public  class Plane {
    private  int health;
    private  int bulletType;
    private  int bombNum;
    public  void play(){};
    public  void pause(){};
    public  void resume(){};
    //get set省略

    public Record getRecord() {
       InnerRecord r = new InnerRecord();
health);
bombNum);
bulletType);
       return r;
    }
 
    public  void loadRecord(Record r) {
       InnerRecord ir = (InnerRecord)r;
       this.health
       this.bombNum
       this.bulletType
    }
 
    private  class InnerRecord implements Record{
       private  int health;
       private  int bulletType;
       private  int bombNum;
       //省略get set
    }
}

 

通过内部类，我们巧妙的实现了备忘录的黑盒模式。

备忘录模式的缺点

上面实现的备忘录模式中有两个缺点：

1.  内存消耗。如果Plane的状态较多，那么它的存档将会占用较大内存。虽然Android手机不像以前的J2ME平台那样对内存要求十分严格，但是优化资源占用也是很有必要的。

2.  Record里的状态完全是Plane状态的复制，当Plane状态增加时，Record需要相应修改，而且在两个地方维护相同的一组状态，容易造成状态不一致。

下面章节中，会针对这两个缺点提出我的解决方案。

备忘录模式的优化

针对上文提到备忘录存在的两个缺点，我的解决方案如下：

1.  对于资源占用，由于我们的目标是实现游戏存档，那么完全可以采用序列化的方式，将内存空间（即RAM）转化为磁盘空间（即ROM），从而减少内存占用。而Android手机的ROM一般是比较充足的，上兆的存档完全不会带来压力。

具体实现方式如下：

1)  修改内部类InnerRecord，修改为静态类，增加Serializable声明。

private  static classInnerRecordimplements Record,Serializable{

2)  修改Controller，改为序列化方式：

public  class Controller { 

public  void saveRecord(Record r) {
    File f = new File("存档路径");
    if (f.exists()) {
       f.delete();
    }
    FileOutputStream fos = null;
    ObjectOutputStream oos = null;
    try {
       f.createNewFile();
       fos = new FileOutputStream(f);
       oos = new ObjectOutputStream(fos);
       oos.writeObject(r);
    } catch (Exception e) {
       e.printStackTrace();
    } finally {
       if (fos !=null) {
           try {
              fos.close();
           } catch (IOException e1) {
           }
       }
       if (oos !=null) {
           try {
              oos.close();
           } catch (IOException e1) {
           }
       }
    }
}
 
public Record loadRecord() {
    File f = new File("d:\\record");
    if (!f.exists()) {
       return  null;
    } 
    try {
       ObjectInputStream ois = new ObjectInputStream(new FileInputStream(f));
       Record record = (Record)ois.readObject();
       return record;
    }catch (Exception e) {
       e.printStackTrace();
    }
    return  null;
}
}

从这里也可以看出引入Controller的优点，可以更好的进行封装。

2.  我们可以引入状态类State，Plane和InnerRecord均引用State，即可解决该问题。

备忘录模式的拓展

备忘录模式可以进行如下拓展：

1.  将Controller进行增强，Client不再直接引用Record。

2.  可以维护多个状态/存档。

3.  对其进行精简，比如将Plane与Controller合并，Plane自己提供存档、读档的方法。

设计模式存在多种变种，具体可以在实际开发时灵活使用。