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();        r.setHealth(health);        r.setBombNum(bombNum);        r.setBulletType(bulletType);        return r;     }     public void loadRecord(Record r){        this.health = r.getHealth();        this.bombNum = r.getBombNum();        this.bulletType = r.getBulletType();     } }

 

可以看出，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 = r;     }     public Record loadRecord(){        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();        r.setHealth(health);        r.setBombNum(bombNum);        r.setBulletType(bulletType);        return r;     }       public void loadRecord(Record r) {        InnerRecord ir = (InnerRecord)r;        this.health = ir.getHealth();        this.bombNum = ir.getBombNum();        this.bulletType = ir.getBulletType();     }       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 class InnerRecordimplements 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自己提供存档、读档的方法。

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