美文网首页
JavaScript设计模式六(发布-订阅模式)

JavaScript设计模式六(发布-订阅模式)

作者: moyi_gg | 来源:发表于2018-05-02 09:31 被阅读0次

    JavaScript设计模式六(发布-订阅模式)

    发布-订阅模式又叫做观察者模式,定义:

    定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变的时候,所有依赖于它的对象都将得到通知。在JavaScript中的,我们一般用事件模型来代理传统的发布-订阅模式

    发布-订阅模式的例子

    例如小明想要买房子,去售楼处去问了,售楼小姐姐告诉他买完了,后续会加推楼盘。小明要了售楼小姐姐的电话,隔一段时间就问楼盘出来了么没有。然后可能小洪、小熊也是这样,然后售楼小姐姐就离职了。。。。
    but,实际上售楼处的小姐姐不会这么傻,她们会让小明这一类的客户把电话留下,当楼盘出来了,它再一个个的电话通知
    这个例子其实就是典型的发布订阅模式。小明、小洪都是订阅者,她们订阅了房子出售的信息,售楼处作为发不者,会在合适的时候依次给购房者打电话。这么做的好处在于购房者不用天天打电话咨询开售时间,售楼处的变动也不会影响购买者。
    发布订阅模式的作用:

    • 发布-订阅模式广泛应用于异步编程中,这是替代回调函数的一种方法,例如node中eventproxy
    • 发布-订阅模式可以替代对象之间的硬编码的通知机制,一个对象不用再显式的调用另外一个对象的某个接口

    JavaScript中的事件模型

    JavaScript中有两种事件模型:DOM0级、DOM2级

    • DOM0级是早期的事件模型,所有的浏览器都是支持的,而且实现也是比较简单的,代码如下:
    // 绑定事件
    document.getElementById('test').onclick = function(){
        console.log('哈哈哈');
    }
    
    // 解除事件
    document.getElementById('test').onclick = null;
    

    在DOM0级中,只能绑定一个同类型的函数,如果注册多个,就会发生覆盖

    • DOM2级
    document.getElementById('test').addEventListener('click', function(){
        console.log('哈哈哈');
    }, false);
    

    如何实现自定义事件

    除了DOM事件之外,还会有一些自定义的事件,接下来我们看如何实现发布-订阅模式

    • 首先指定好谁充当发布者
    • 然后给发布者添加一个缓存列表,用于存放回调函数以便通知订阅者
    • 最后发消息的时候,发布者会遍历这个缓存列表,依次触发里面存放的订阅者回调函数
    var salesOffices = {};
    salesOffices.clientList = [];
    salesOffices.listen = function(fn) {
        this.clientList.push(fn);
    }
    salesOffices.trigger = function() {
        for(var i = 0, fn; fn = this.clientList[i]; ) {
            fn.apply(this, arguments);
        }
    }
    
    // 然后开始订阅
    // 小明
    salesOffices.listen(function(price, squreMeter) {
        console.log(price, squreMeter);
    })
    // 小红
    salesOffices.listen(function(price, squreMeter) {
        console.log(price, squreMeter);
    })
    
    salesOffices.trigger( 2000000, 88 );
    

    这里算上线了基本的发布订阅模式,但是还是有点问题,比如小明不想要88平的,结果售楼处把88平的房子信息发给了小明。解决方法就是增加一个标志

    var salesOffices = {}
    salesOffices.chatList = [];
    salesOffices.listen = function(key, fn){
        if (!this.chatList[key]) {
            this.chatList[key] = [];
        }
        this.chatList[key].push(fn);
    };
    
    salesOffices.trigger = function() {
        var key = Array.prototype.shift.call(arguments);
        var fns = this.chatList[key];
        if (!fns || fns.lenght == 0) {
            return false;
        }
        for(var i = 0, fn; fn = fns[i++];){
            fn.apply(this, arguments);
        }
    };
    
    salesOffices.listen('squreMeter88', function(price){
        console.log(price);
    });
    
    salesOffices.listen('squreMeter110', function(price){
        console.log(price);
    });
    
    salesOffices.trigger('squreMeter88', 200000);
    salesOffices.trigger('squreMeter110', 300000);
    

    发布-订阅模式的通用实现

    上面的版本已经还不错了,但是小明觉得应该广撒网,不仅仅针对一个售楼处,还需要买其他楼盘的房子,然后综合一下。

    var event = {
        clientList: [],
        listen: function(key, fn) {
            if (!this.chatList[key]) {
                this.chatList[key] = [];
            }
            this.chatList[key].push(fn);
        },
        trigger: function() {
            var key = Array.prototype.shift.call(arguments);
            var fns = this.chatList[key];
            if (!fns || fns.lenght == 0) {
                return false;
            }
            for(var i = 0, fn; fn = fns[i++];){
                fn.apply(this, arguments);
            }
        },
    };
    
    // 拷贝对象
    var installEvent = function(obj) {
        for (var i in event) {
            obj[i] = event[i];
        }
    }
    

    这样,我们就可让一个普通对象有发布-订阅的功能

    var salesOffices = {};
    installEnvent(saleOffices);
    salesOffices.listen('squreMeter88', function(price){
        console.log(price);
    });
    
    salesOffices.listen('squreMeter110', function(price){
        console.log(price);
    });
    
    salesOffices.trigger('squreMeter88', 200000);
    salesOffices.trigger('squreMeter110', 300000);
    

    全局的发布-订阅对象

    上面例子还有点问题,就是我们用的拷贝的方式,给每个实例都添加了listen和trigger方法,还有一个缓存列表chatList;此外还有一个问题就是购房者必须要知道楼盘的名字叫salesOffices才能订阅,但是实际生活中并不是这样。购房者有可能是通过中介来买房子,我们可以设计一个全局的Event对象,订阅者和发布者互相是不知道

    var Event = (function(){
        var clientList = {},
        listen, trigger;
        listen = function(key, fn) {
            if (!chatList[key]) {
                chatList[key] = [];
            }
            chatList[key].push(fn);
        },
        trigger: function() {
            var key = Array.prototype.shift.call(arguments);
            var fns = chatList[key];
            if (!fns || fns.lenght == 0) {
                return false;
            }
            for(var i = 0, fn; fn = fns[i++];){
                fn.apply(this, arguments);
            }
        },
    })();
    
    Event.listen( 'squareMeter88', function( price ){ // 小红订阅消息 
        console.log( '价格= ' + price ); // 输出:'价格=2000000' 
    });
    
    Event.trigger( 'squareMeter88', 2000000 ); // 售楼处发布消息
    

    必须先订阅再发布么?

    在我们做IM通信的过程中,分为消息和消息的回执,如果消息的回执先到客户端,需要先把回执存起来,然后等消息来了之后,把回执拿出来比对一下,更新消息的状态。
    所以我们可以新建一个离线栈,当事件发布的时候,如果还没有订阅这个事件,可以先把事件的发布动作包装起来,然后存入栈中,等真正有时间订阅的时候才触发。

    全局事件的命名冲突

    前面我们用全局事件解决了问题,但是如果各个不同的业务都在全局事件上弄事件,难免会有key的重复,而且业务逻辑又糅合到了一起,这种情况我们可以增加一个全局的事件。
    这段代码稍微有点复杂,解决了命名冲突和发布前未订阅的问题。

    var Event = (function() {
        var global = this,
            Event,
            _default = 'default';
            
        Event = function() {
        
            var _listen, 
                _trigger,
                _remove,
                _slice = Array.prototype.slice,
                _shift = Array.prototype.shift,
                _unshift = Araay.prototype.unshift,
                namespaceCache = {},
                _create,
                find,
                each = function(ary, fn) {
                    var ret;
                    for(var i=0, l = fn.length; i < l; i++) {
                        var n = ary[i];
                        ret = fn.call(n, i, n);
                    }
                    return ret;
                };
                
            _listen = function(key, fn, cache) {
                if (!cache[key]) {
                    cache[key] = [];
                }
                cache[key].push(fn);
            };
            
            _remove = function(key, cache, fn) {
                if (cache[key]) {
                    if (fn) {
                        for(var i = cache[key].length; i > 0; i--) {
                            if (cache[key][i] === fn) {
                                cache[key].splice(i, 1);
                            }
                        }
                    } else {
                        cache[key] = [];
                    }
                }  
            };
            
            _trigger = function() {
                var cache = _shift.call(arguments),
                    key = _shift.call(arguments),
                    args = arguments,
                    _self = this,
                    ret,
                    stack = cache[key];
                if (!stack || !stack.length) {
                    return;
                }
                return each(stack, function(){
                    return this.apply(_self, args);
                });
            };
            
            _create = function(namespace) {
                var namespace = namespace || _defalut;
                var cache = {},
                    offlineStack = [],
                    ret = {
                        listen: function(key, fn, last) {
                            _listen(key, fn, cache);
                            if (offlineStack == null) {
                                return;
                            }
                            if (last === 'last') {
                                offlineStack.lenth && offlineStack.pop()();
                            } else {
                                each(offlineStack, function(){
                                    this();
                                }); 
                            }
                            offlineStack = null;
                        },
                        one: function(key, fn, last) {
                            _remove(key, cache);
                            this.listen(key, fn, last);
                        },
                        remove: function(key, fn) {
                            _remove(key, cache, fn);
                        },
                        trigger: function() {
                            var fn, args, _self = this;
                            _unshift.call(arguments, cache);
                            args = arguments;
                            fn = funciton() {
                                return _trigger.call(_self, args);
                            };
                            if (offlineStack) {
                                return offlineStack.push(fn);
                            }
                            return fn();
                        }
                    }
            };
                
                
            return {
                create: _create,
                one: function(key, fn, last) {
                    var event = this.create();
                    event.one(key, fn, last);
                },
                remove: function(key, fn) {
                    var event = this.create();
                    event.remove(key, fn);
                },
                listen: function(key, fn, last) {
                    var event = this.create();
                    event.listen(key, fn, last);
                },
                trigger: function() {
                    var event = this.create();
                    event.trigger.apply(this. arguments);
                }
            }
        }
        
        return Event;
    })();
    

    使用方法:

    // 先发布后订阅
    
    Event.trigger( 'click', 1 );
    
    Event.listen( 'click', function( a ){ 
        console.log( a ); // 输出:1 
    });
    
    // 使用命名空间
    
    Event.create( 'namespace1' ).listen( 'click', function( a ){ 
        console.log( a ); // 输出:1 
    });
    
    Event.create( 'namespace1' ).trigger( 'click', 1 );
    
    Event.create( 'namespace2' ).listen( 'click', function( a ){ 
        console.log( a ); // 输出:2 
    });
    
    Event.create( 'namespace2' ).trigger( 'click', 2 );
    

    相关文章

      网友评论

          本文标题:JavaScript设计模式六(发布-订阅模式)

          本文链接:https://www.haomeiwen.com/subject/rxuqrftx.html