精华内容
下载资源
问答
  • 发布者订阅者模式

    2021-01-14 09:49:33
    1 发布订阅模式理解 假定存在一个信号中心,某个任务执行完成就向信号中心发布一个任务,其他任务可以向信号中心订阅这个任务...注:vue中兄弟组件通信过程就是通过发布者订阅者模式实现的。 2 发布订阅者模式代码 ...

    1 发布订阅模式理解

    假定存在一个信号中心,某个任务执行完成就向信号中心发布一个任务,其他任务可以向信号中心订阅这个任务从而知道什么时候自己可以开始执行。
    (学生家长向学生所在班级订阅了获取学生考试成绩这一个事件,当老师公布了学生的成绩后就自动的通知学生的家长,这样学生家长就知道了学生的考试成绩)在这个例子中学生所在班级就是信号中心,老师是发布者,家长是订阅者。
    注:vue中兄弟组件通信过程就是通过发布者订阅者模式实现的。

    展开全文
  • Python-redis生产者消费者模式和发布者订阅者模式 生产者消费者模式 生产者消费者模式是一个或多个消费者监听redis消息队列,一旦生产者有消息发出,那么消费者谁抢到算谁的,消息队列没有消息后,则继续监听等待。 ...

    Python-redis生产者消费者模式和发布者订阅者模式

    生产者消费者模式

    生产者消费者模式是一个或多个消费者监听redis消息队列,一旦生产者有消息发出,那么消费者谁抢到算谁的,消息队列没有消息后,则继续监听等待。
    示例代码:
    关键方法:blpop

    import redis
    
    # 生产者消费者模式
    class RedisTask(object):
        def __init__(self,info):
            self.rcon = redis.StrictRedis(host='localhost', db=1)
            self.queue = info
    
    
        def listen_task(self):
            while True:
                task = self.rcon.blpop(self.queue, 0)    # 填0为阻塞等待,填大于0的数字为超时等待,超过时间没有消息接收到,则task为None
                print(task)
    if __name__ == '__main__':
        info = 'abc'
        redis_task = RedisTask(info)
        redis_task .listen_task()
    

    发布者订阅者模式

    发布者订阅者模式是一个或多个客户端订阅消息频道,只要发布者发布这个频道的消息,则所有订阅者都可以接收到此频道的消息,等待模式为阻塞等待。
    示例代码:
    关键方法:pubsub,publish,subscribe,psubscribe

    发布者

    import redis
    
    # 发布者
    redis_conn = redis.StrictRedis(host='localhost', db=5)
    redis_conn.publish('test1', 'abcdef')
    

    订阅者

    #订阅者
    redis_conn = redis.StrictRedis(host='localhost', db=5)
    rc_sub = redis_conn.pubsub()
    rc_sub.subscribe('test1')
    # 订阅多个频道使用psubscribe方法,参数为列表
    # rc_sub.psubscribe(['test1','test2','test3'])
    for item in rc_sub.listen():
        if item['type'] == 'message':
            print(item['channel'])
            print(item['data'])
    
    展开全文
  • 发布者订阅者模式之JAVA实现 1.发布者接口 package com.shoshana.publishsubscribe;public interface IPublisher<M>...

     

     

    1.发布者接口

    package com.shoshana.publishsubscribe;

    public interface IPublisher<M> {
    public void publish(SubscribePublish subscribePublish, M message, boolean isInstantMsg);
    }

      

     

    2.订阅者接口
     
    package com.shoshana.publishsubscribe;

    public interface ISubcriber<M> {
    public void subcribe(SubscribePublish subscribePublish);

    public void unSubcribe(SubscribePublish subscribePublish);

    public void update(String publisher, M message);
    }

      

     

    3.订阅器类
    package com.shoshana.publishsubscribe;
    
    import java.util.ArrayList;
    import java.util.List;
    import java.util.concurrent.ArrayBlockingQueue;
    import java.util.concurrent.BlockingQueue;
    
    public class SubscribePublish<M> {
        //订阅器名称
        private String name;
        //订阅器队列容量
        final int QUEUE_CAPACITY = 20;
        //订阅器存储队列
        private BlockingQueue<Msg> queue = new ArrayBlockingQueue<Msg>(QUEUE_CAPACITY);
        //订阅者
        private List<ISubcriber> subcribers = new ArrayList<ISubcriber>();
    
        public SubscribePublish(String name) {
            this.name = name;
        }
    
        public void publish(String publisher, M message, boolean isInstantMsg) {
            if (isInstantMsg) {
                update(publisher, message);
                return;
            }
            Msg<M> m = new Msg<M>(publisher, message);
            if (!queue.offer(m)) {
                update();
            }
        }
    
        public void subcribe(ISubcriber subcriber) {
            subcribers.add(subcriber);
        }
    
        public void unSubcribe(ISubcriber subcriber) {
            subcribers.remove(subcriber);
        }
    
        public void update() {
            Msg m = null;
            while ((m = queue.peek()) != null) {
                this.update(m.getPublisher(), (M) m.getMsg());
            }
        }
    
        public void update(String publisher, M Msg) {
            for (ISubcriber subcriber : subcribers) {
                subcriber.update(publisher, Msg);
            }
        }
    }
    
    class Msg<M> {
        private String publisher;
        private M m;
    
        public Msg(String publisher, M m) {
            this.publisher = publisher;
            this.m = m;
        }
    
        public String getPublisher() {
            return publisher;
        }
    
        public void setPublisher(String publisher) {
            this.publisher = publisher;
        }
    
        public M getMsg() {
            return m;
        }
    
        public void setMsg(M m) {
            this.m = m;
        }
    }
    

     

    4.发布者实现类
    package com.shoshana.publishsubscribe;
    
    public class PublisherImpOne<M> implements IPublisher<M> {
        private String name;
    
        public PublisherImpOne(String name) {
            super();
            this.name = name;
        }
    
        public void publish(SubscribePublish subscribePublish, M message, boolean isInstantMsg) {
            subscribePublish.publish(this.name, message, isInstantMsg);
        }
    }
    

      

     

     
    5.订阅者实现类 
    package com.shoshana.publishsubscribe;
    
    public class SubcriberImpOne<M> implements ISubcriber<M> {
        public String name;
    
        public SubcriberImpOne(String name) {
            super();
            this.name = name;
        }
    
        public void subcribe(SubscribePublish subscribePublish) {
            subscribePublish.subcribe(this);
        }
    
        public void unSubcribe(SubscribePublish subscribePublish) {
            subscribePublish.unSubcribe(this);
        }
    
        public void update(String publisher, M message) {
            System.out.println(this.name + "收到" + publisher + "发来的消息:" + message.toString());
        }
    }
    

      

    6.测试类
    package com.shoshana.publishsubscribe;
    
    public class SubPubTest {
        public static void main(String[] args) {
            SubscribePublish<String> subscribePublish = new SubscribePublish<String>("订阅器");
            IPublisher<String> publisher1 = new PublisherImpOne<String>("发布者1");
            ISubcriber<String> subcriber1 = new SubcriberImpOne<String>("订阅者1");
            ISubcriber<String> subcriber2 = new SubcriberImpOne<String>("订阅者2");
            subcriber1.subcribe(subscribePublish);
            subcriber2.subcribe(subscribePublish);
            publisher1.publish(subscribePublish, "welcome", true);
            publisher1.publish(subscribePublish, "to", true);
            publisher1.publish(subscribePublish, "yy", false);
        }
    }

    测试结果:

    com.shoshana.publishsubscribe.SubPubTest
    订阅者1收到发布者1发来的消息:welcome
    订阅者2收到发布者1发来的消息:welcome
    订阅者1收到发布者1发来的消息:to
    订阅者2收到发布者1发来的消息:to
    
    Process finished with exit code 0
    

      

    posted on 2019-04-23 23:26 shoshana~ 阅读(...) 评论(...) 编辑 收藏

    转载于:https://www.cnblogs.com/shoshana-kong/p/10759830.html

    展开全文
  • 今天重温《JavaScript高级程序设计》扫了JavaScript实现发布者订阅者模式的盲区。 书上如是说。 事件是JavaScript和浏览器交互的主要途径。事件是一种叫做观察者的设计模式。这是一种创建松散耦合代码的技术。对象...

    很多东西起初都是哇感觉很难。然后从内心就会产生抵触心理。

    然而真正硬着头皮去看的时候,发现也是妈妈不用担心我的学习系列。

    今天重温《JavaScript高级程序设计》扫了JavaScript实现发布者订阅者模式的盲区。

    书上如是说。

    事件是JavaScript和浏览器交互的主要途径。事件是一种叫做观察者的设计模式。这是一种创建松散耦合代码的技术。对象可以发布事件。用来表示在该对象生命周期中某个有趣的时刻到了。然后对象可以观察该对象。等待这些有趣的时刻到来并通过运行代码来响应。

    这时,我们回头看看一个简单的点击事件的代码。

    <button id="btn">你点我</button>

    JavaScript如下

    let btn = document.querySelector("#btn")
        btn.addEventListener('click',function () {
            console.log(1)
        })

    看到btn.addEventListener这行。为什么button的onclick可以用addEventListener来实现呢。实际上就是利用了发布者-订阅者模式。btn.addEventListener顾名思义添加订阅者,也可以叫监听者。这就是listener的由来。btn.addEventListener(‘click’),实际上就是监听了btn对象的`click`事件,当我们点下按钮,click事件就会被触发。然后就会执行addEventListener的第二个参数。回调函数。

    看完这篇博客你不仅知道了addEventListener的原理,而且能自己动手写出一个来!

    实现发布订阅第一步

    新建一个Event对象

        function Event() {
            this.handlers={}
        }

    私有部分我们放在构造函数的里面。公有属性和方法我们放在Event对象的原型上。什么是私有部分呢。比如说button对象的触发动作有click,doubleclick等等。但是输入框input对象的触发动作就是keydown,keyup,keypress之类。他们都是节点所独有的的。所以要把这些放在构造函数的构造部分实现实例的私有化。

    那么公有方法都有什么呢。所有的元素节点,不论是Button还是input。他们都有一个共同的方法,那就是addEventListener。这里我们重写一下Event对象的原型对象。

        Event.prototype={
            constructor:Event,
            addEventListener:function (type,method) {
                if (!type||!method){
                    console.error(`缺少必填字段,触发动作或者回调函数!`)
                }else{
                    this.handlers[type]=method
                }
            }
        }

    由于是重写,我们把因重写丢失的构造函数Event给补上,然后写上addEventListener方法。我们知道addEventListener至少必须要两个参数,一个是触发事件,一个是回调函数。(其实参数有三个,这里我们做了简化)所以我们校验一下参数的合法性。如果参数少于两个,控制台就会报错。

        let event = new Event()
        event.addEventListener('click')

    这里我只填入了一个参数

    传入完整的参数我们再来看看event对象

        event.addEventListener('click',function () {
            console.log(1)
        })
        console.log(event)

    此时event对象里的handler就有了click属性啦!它是一个函数。监听器写好了。该写个触发器了!触发器再简单不过了

            eventEmmit:function (type) {
                this.handlers[type]()
            }

    传入值,触发动作type,根据type类型找到回调函数,直接触发函数即可!

    二话不说,直接上头!在btn的点击函数中触发eventEmmit。

        btn.onclick=function () {
            event.eventEmmit('click')
        }

    此时完整的代码如下。

    let btn = document.querySelector("#btn")
        function Event() {
            this.handlers={}
        }
        Event.prototype={
            constructor:Event,
            addEventListener:function (type,method) {
                if (!type||!method){
                    console.error(`缺少必填字段,触发动作或者回调函数!`)
                }else{
                        this.handlers[type] = method
                }
            },
            eventEmmit:function (type) {
                this.handlers[type]()
            }
        }
        let event = new Event()
        event.addEventListener('click',function () {
            console.log(1)
        })
    
        btn.onclick=function () {
            event.eventEmmit('click')
        }

    我没有用addEventListener,但是却一样实现了它的功能。

    成功触发回调!

    当然,JavaScript中实现的addEventListener肯定比我这个要复杂一点。首先,addEventListener可以传入第三个参数。再者,addEventListener可以重复添加,还有removeEventListener。但是知道了发布者订阅者模式的原理。这些都不在话下。

    这些统统统统统统不重要!重要的是我们已经短短十几行代码实现了一个发布者订阅者模式!

    因为JavaScript中所有的事件全部是由发布订阅实现的。因此,我们可以还实现自己的自定义事件。

    展开全文
  • 观察者模式 let publisher = { // 订阅者列表 list:[], // 新增订阅者 listen:function(user,type){ if(!this.list[type]){ this.list[type] = [] } this.list[type].push(user) }, // ...
  • 发布者实现类 package com.shoshana.publishsubscribe; public class PublisherImpOne implements IPublisher { private String name; public PublisherImpOne(String name) { super(); this.name = name; } public ...
  • 发布/订阅,类似设计模式中的观察者模式。 redis可以作为pub/sub的服务端。订阅得通过subscribe和psubscribe命令向redis server订阅消息类型,redis将消息类型称为channel。 当发布者通过publish命令向redis ...
  • 发布者实现类 package com.shoshana.publishsubscribe; public class PublisherImpOne implements IPublisher { private String name; public PublisherImpOne(String name) { super(); this.name = name; } public ...
  • 自己用C++写一个发布者订阅者模式

    千次阅读 2019-03-07 22:40:17
    突然想整理一下自己用过的这个模式,半小时写下了这些代码。... observerList,该vector用于存储订阅者对象,当发布者需要发布消息时,消息会被发送给vector中所有的订阅者对象。 在订阅者类中定义...
  • 发布者订阅者模式(一)

    千次阅读 2016-06-28 15:09:17
    demo是用了两个场景来描述的,一个是找工作(查的资料),一个是购物,仿照写的,为了加深理解,根据名字可以知道订阅者发布者,然后实体类分别取实现这两个接口类,来看订阅者 package com.fanyafeng.obser; /*...
  • 用于发布消息,接收任意多个参数,第一参数为要发布的信息名字(唯一标识),如"init/method",其他参数为传递给订阅回调函数的参数。 topic.subscribe: 用于订阅消息,接收两个参数,第一参数为要订阅...
  • 订阅发布者模式 观察者模式 重点 (Top highlight) 软件工程 , 系统 (Software Engineering, Systems) Don’t get confused with these two similar but different patterns, and know which one to use when. 不要...
  • 之前一直对观察者模式和发布订阅模式的区别理解不深... pubSub.png从图中可以看出,观察者模式中观察者和目标直接进行交互,而发布订阅模式中统一由调度中心进行处理,订阅者发布者互不干扰。这样一方面实现了解耦...
  • 观察者模式发布订阅模式有什么区别?大多数的回答都是:Publishers + Subscribers = Observer Pattern,24种基本的设计模式并没有发布-订阅模式,发布订阅模式属于并发型模式;像典型的Mq;这两种相似单并不可以划...
  • 发布者订阅模式简介 发布—订阅模式又叫观察者模式,它定义对象间的一对多的依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都将得到通知。在javascript开发中,一般用事件模型来替代传统的发布—订阅...
  • 在我看来,其他的模式为了简化编程的复杂性,都是鼓励函数或者对象间解耦和的,但是发布-订阅者模式虽然发布者和订阅者对象分开了,但是之间的依赖关系反而更强了。关键点:1.订阅者在订阅事件的时候实际是在发布者...
  • 主要介绍了JavaScript设计模式之观察者模式(发布者-订阅者模式),本文详细的讲解了JavaScript中的观察者模式,需要的朋友可以参考下
  • 观察者模式订阅者维护在发布者这里,需要发布消息时直接发消息给订阅者。在观察者模式中,发布者本身是知道订阅者存在的。而发布/订阅模式中,发布者并不维护订阅者,也不知道订阅者的存在,所以也不会直接通知...
  • 观察者模式和发布/订阅模式很像,其区别主要在于,发布/订阅模式中发布者订阅者双方没有感知。两者的区别可以抽象地理解租房子。观察者模式是自己找房东,两个人协商好生意就达成了。发布/订阅模式则是房东将租房...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 9,807
精华内容 3,922
关键字:

发布者订阅者模式