游戏中的事件管理--观察者模式的解读

前言：

最近在网上浏览到一篇对软件设计模式概述的文章，说的相对通透易懂可以看看～
http://c.biancheng.net/view/1317.html

一、观察者模式的介绍

在现实世界中，许多对象并不是独立存在的，其中一个对象的行为发生改变可能会导致一个或者多个其他对象的行为也发生改变。例如：红灯停路灯行；下课铃声响起所有的学生走出教室自由活动等等。

在软件世界也是这样，例如，Excel 中的数据与折线图、饼状图、柱状图之间的关系；MVC 模式中的模型与视图的关系；事件模型中的事件源与事件处理者。所有这些，如果用观察者模式来实现就非常方便。
模式的定义与特点

观察者（Observer）模式的定义：指多个对象间存在一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。这种模式有时又称作发布-订阅模式、模型-视图模式，它是对象行为型模式。

观察者模式是一种对象行为型模式，其主要优点如下。
降低了目标与观察者之间的耦合关系，两者之间是抽象耦合关系。符合依赖倒置原则。
目标与观察者之间建立了一套触发机制。

它的主要缺点如下。
目标与观察者之间的依赖关系并没有完全解除，而且有可能出现循环引用。
当观察者对象很多时，通知的发布会花费很多时间，影响程序的效率。

二、观察者简单代码

我们通过代码抽象理解一下观察者的原理和上文所说的缺点：

abstract class Subject {
    protected observers: Observer[] = [];
    //增加观察者方法
    public add(observer: Observer): void{
        this.observers.push(observer);
    }

    //删除观察者方法
    public remove(observer: Observer): void {
        this.observers.pop()// 简单使用伪代码进行删除
    }
    public abstract notifyObserver(): any; //通知观察者方法
}

//具体目标
class ConcreteSubject extends Subject {
    public notifyObserver(): void{
        this.observers.forEach((obs) => {
            obs.response();
        });
    }
}
//抽象观察者
interface Observer {
    response(): any; //反应
}
//具体观察者1
class ConcreteObserver1 implements Observer {
    public response(): void{
        cc.log("具体观察者1作出反应！");
    }
}
//具体观察者1
class ConcreteObserver2 implements Observer {
    public response(): void{
        cc.log("具体观察者2作出反应！");
    }
}

//使用的时候
    let subject: Subject = new ConcreteSubject();
    let obs1: Observer = new ConcreteObserver1();
    let obs2: Observer = new ConcreteObserver2();
    subject.add(obs1);
    subject.add(obs2);
    subject.notifyObserver();

三、cocosCreator中对观察者的使用

我们使用观察者的目的就是为解耦合，比如引擎中提供的cc.game：
1.在任意地方定义事件：cc.game.on;
2.在任意地方分发事件：cc.game.dispatchEvent；
使用起来相当方便，但记得既然注册了监听事件就要记得删除；有的时候我喜欢自己实现一个或者有的时候需要自己写一个类似的观察者。

并不严谨只是展示观察者的内部逻辑：

export default class EventCenter {
    private static eventMap: Map<string, EventHandler[]> = new Map<string, EventHandler[]>();
    //事件注册
    static registEvent(eventName: string, callBack: Function, target: Object): void {
        if (eventName == undefined || callBack == undefined || target == undefined) {
            return;
        }
        if (this.eventMap.get(eventName) == undefined) {
            this.eventMap[eventName] = new Array<EventHandler>();
        }
        let handler: EventHandler = new EventHandler(target, callBack);
        EventCenter.eventMap[eventName].push(handler);
    }

    //事件分发出去
    static postEvent(eventName: string, param?: any): void { //分发可以传递参数
        let handlers = EventCenter.eventMap[eventName];
        if (handlers == undefined) { return; }
        for (let i = 0; i < handlers.length; i++) {
            let handler = handlers[i]
            try {
                handlers.callBack.call(handler.target, param);
            }
            catch (errer) {
                cc.log(errer.message);
                cc.log(errer.stack.toString());
            }
        }
    }

    //删除事件
    static removeEvent(eventName: string, callBack: Function, target: Object): void {
        let handlers = EventCenter.eventMap[eventName];
        if (handlers == undefined) { return; }

        for (let i = 0; i < handlers.length; i++) {
            let handler = handlers[i]
            if (handler != undefined && handler.target == target && handler.callBack == callBack) {
                handler[i] = undefined;
                break;
            }
        }
    }
}

//事件的结构
class EventHandler {
    target: object;
    callBack: Function;

    constructor(target: object, callBack: Function) {
        this.target = target;
        this.callBack = callBack;
    }
}