精华内容
下载资源
问答
  • 主要介绍了JS模式之简单的订阅者发布者模式,以一个完整实例形式详细分析了JS订阅者发布者模式基本实现技巧,需要的朋友可以参考下
  • 发布者订阅者模式之JAVA实现

    千次阅读 2019-09-24 07:29:30
    发布者订阅者模式之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中的观察者模式,需要的朋友可以参考下
  • 发布者订阅者模式(一)

    千次阅读 2016-06-28 15:09:17
    demo是用了两个场景来描述的,一个是找工作(查的资料),一个是购物,仿照写的,为了加深理解,根据名字可以知道订阅者发布者,然后实体类分别取实现这两个接口类,来看订阅者 package com.fanyafeng.obser; /*...

    自己画了个图


    demo是用了两个场景来描述的,一个是找工作(查的资料),一个是购物,仿照写的,为了加深理解,根据名字可以知道订阅者和发布者,然后实体类分别取实现这两个接口类,来看订阅者

    package com.fanyafeng.obser;
    
    /**
     * Created by fanyafeng on 16/6/27.
     */
    public interface Observer {
        public void update(Subject subject);
    }
    

    发布者:

    package com.fanyafeng.obser;
    
    /**
     * Created by fanyafeng on 16/6/27.
     */
    public interface Subject {
        public void registerObserver(Observer observer);
    
        public void removeObserver(Observer observer);
    
        public void notifyAllObservers();
    }
    
    这个真的可以类比一下网络购物,可以把一间店铺类比为发布者,然后消费者首先需要收藏可以类比订阅才能收到店铺的消息,如果店铺发消息的话肯定所有收藏店铺的都可以收到推送,在这也可以体会一下谁的业务比较复杂,来看具体实现

    shop

    package com.fanyafeng.obser.shopping;
    
    import com.fanyafeng.obser.Observer;
    import com.fanyafeng.obser.Subject;
    
    import java.util.ArrayList;
    import java.util.List;
    import java.util.StringJoiner;
    
    /**
     * Created by fanyafeng on 16/6/28.
     */
    public class Shop implements Subject {
        private ArrayList<Observer> customerList;
        private ArrayList<String> messages;
    
        public Shop() {
            customerList = new ArrayList<>();
            messages = new ArrayList<>();
        }
    
        //订阅消息
        @Override
        public void registerObserver(Observer observer) {
            customerList.add(observer);
        }
    
        @Override
        public void removeObserver(Observer observer) {
    
        }
    
        @Override
        public void notifyAllObservers() {//发布者,通知所有订阅者
            for (Observer observer : customerList) {
                observer.update(this);
            }
        }
    
        //店铺广播消息
        public void postMessage(String message) {
            this.messages.add(message);
            notifyAllObservers();
        }
    
        public ArrayList<String> getMessages() {
            return messages;
        }
    
        //店铺消息
        public String toString() {
            return messages.toString();
        }
    }
    
    customer

    package com.fanyafeng.obser.shopping;
    
    import com.fanyafeng.obser.Observer;
    import com.fanyafeng.obser.Subject;
    
    /**
     * Created by fanyafeng on 16/6/28.
     */
    public class Customer implements Observer {
    
        private String customer;
    
        public Customer(String customer) {
            this.customer= customer;
        }
    
        @Override
        public void update(Subject subject) {//订阅者
            System.out.println("收到店铺消息的消费者:" + this.customer);
            System.out.println("店铺消息:" + subject.toString());
        }
    }
    


    Shop shop = new Shop();
            shop.registerObserver(new Customer("小红"));
            shop.registerObserver(new Customer("小芳"));
            shop.registerObserver(new Customer("广大女生"));
    
            shop.postMessage("鞋子降价了");
            shop.postMessage("零食降价了");
    这样就ok了








    展开全文
  • 自己用C++写一个发布者订阅者模式

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

     

    突然想整理一下自己用过的这个模式,半小时写下了这些代码。

    首先定义两个基类,class notifier(发布者) 和 class receiver(订阅者)。

    在发布者类中有成员 std::vector<receiver*> observerList,该vector用于存储订阅者对象,当发布者需要发布消息时,消息会被发送给vector中所有的订阅者对象。

    在订阅者类中定义 recvMessage(string message)函数,处理从发布者那里得到的消息。

    另外,定义了两个子类,genMessage继承自notifier类,getMessage类继承receiver类,并在main.cpp中进行了验证。


    代码如下欧:

    1)Notifier类:

    notifier.h

    #ifndef NOTIFIER_H
    #define NOTIFIER_H
    
    #include <vector>
    #include "receiver.h"
    #include <string>
    
    using namespace std;
    
    class notifier
    {
    public:
        notifier();
        virtual ~notifier();
    
        void sendToAllRecv(string message);
        void loadReceiver(receiver* pRecv);
    
    private:
        std::vector<receiver*> observerList;
    };
    
    #endif // NOTIFIER_H

    notifier.cpp

    #include "notifier.h"
    
    notifier::notifier()
    {
    
    }
    
    notifier::~notifier()
    {
    
    }
    
    void notifier::loadReceiver(receiver* pRecv)
    {
        observerList.push_back(pRecv);
    }
    
    void notifier::sendToAllRecv(string message)
    {
        std::vector<receiver*>::iterator it = observerList.begin();
        for(;it != observerList.end();it++)
        {
            (*it)->recvMessage(message);
        }
    }

    2)receiver 类

    receiver.h

    #ifndef RECEIVER_H
    #define RECEIVER_H
    
    #include <vector>
    #include <string>
    #include <iostream>
    using namespace std;
    class receiver
    {
    public:
        receiver();
        ~receiver();
        virtual void recvMessage(string message) = 0;
    
    };
    
    #endif // RECEIVER_H

    receiver.cpp

    #include "receiver.h"
    
    receiver::receiver()
    {
    
    }
    
    receiver::~receiver()
    {
    
    }
    
    //void receiver::recvMessage(string message)
    //{
    //    //printf("Receiver get message: %s \n",message);
    //    //cout<<message<<"\n";
    //}

    3)genMessage类
     

    genmessage.h

    #ifndef GENMESSAGE_H
    #define GENMESSAGE_H
    
    #include "notifier.h"
    
    class genMessage:public notifier
    {
    public:
        genMessage();
        ~genMessage();
        void throwMessage(string str);
    };
    
    #endif // GENMESSAGE_H

    genmessage.cpp

    #include "genmessage.h"
    
    genMessage::genMessage()
    {
    
    }
    genMessage::~genMessage()
    {
    
    }
    void genMessage::throwMessage(string str)
    {
        sendToAllRecv(str);//基类的函数
    }
    

    4) getmessage类

     

    getmessage.h
     

    #ifndef GETMESSAGE_H
    #define GETMESSAGE_H
    #include "receiver.h"
    
    class getMessage:public receiver
    {
    public:
        getMessage();
        ~getMessage();
    
        void recvMessage(string message);
    
    };
    
    #endif // GETMESSAGE_H
    

    getmessage.cpp

    #include "getmessage.h"
    
    getMessage::getMessage()
    {
    
    }
    getMessage::~getMessage()
    {
    
    }
    
    void getMessage::recvMessage(string message)
    {
        cout<<"one receiver receive:"<<message<<endl;
    }

    5) main.cpp

    #include <iostream>
    #include <vector>
    #include "getmessage.h"
    #include "genmessage.h"
    
    using namespace std;
    
    int main()
    {
        cout << "Hello World!" << endl;
    
       /
       genMessage notifier1;
       getMessage receiver1;
       getMessage receiver2;
    
       notifier1.loadReceiver(&receiver1);
       notifier1.loadReceiver(&receiver2);
    
       notifier1.sendToAllRecv("here it is");
    
       
    
    
        getchar();
        return 0;
    }
    

    输出结果:

    展开全文
  • 发布者订阅者模式

    千次阅读 2013-10-21 20:06:34
    发布者订阅者模式现实中有很多比如博客、微博....订阅者关注或订阅博主,博主有新动态就通知订阅者。可见博主和订阅者有很强的耦合性,发布者订阅者模式将博主和订阅者抽象为基类,让基类之间耦合,而具体的类之间...

       发布者订阅者模式现实中有很多比如博客、微博....订阅者关注或订阅博主,博主有新动态就通知订阅者。可见博主和订阅者有很强的耦合性,发布者订阅者模式将博主和订阅者抽象为基类,让基类之间耦合,而具体的类之间没有直接的耦合关系。

    发布者订阅者模式的实现里有下面这些角色:
    抽象主题(Subject)角色:主题角色把所有对观察考对象的引用保存在一个聚集里,每个主题都可以有任何数量的观察者。抽象主题提供一个接口,可以增加和删除观察者对象,主题角色又叫做抽象被观察者(Observable)角色,一般用一个抽象类或者一个接口实现。
    抽象观察者(Observer)角色:为所有的具体观察者定义一个接口,在得到主题的通知时更新自己。这个接口叫做更新接口。抽象观察者角色一般用一个抽象类或者一个接口实现。在这个示意性的实现中,更新接口只包含一个方法(即Update()方法),这个方法叫做更新方法。
    具体主题(ConcreteSubject)角色:将有关状态存入具体现察者对象;在具体主题的内部状态改变时,给所有登记过的观察者发出通知。具体主题角色又叫做具体被观察者角色(Concrete Observable)。具体主题角色通常用一个具体子类实现。
    具体观察者(ConcreteObserver)角色:存储与主题的状态自恰的状态。具体现察者角色实现抽象观察者角色所要求的更新接口,以便使本身的状态与主题的状态相协调。如果需要,具体现察者角色可以保存一个指向具体主题对象的引用。具体观察者角色通常用一个具体子类实现。
    从具体主题角色指向抽象观察者角色的合成关系,代表具体主题对象可以有任意多个对抽象观察者对象的引用。之所以使用抽象观察者而不是具体观察者,意味着主题对象不需要知道引用了哪些ConcreteObserver类型,而只知道抽象Observer类型。这就使得具体主题对象可以动态地维护一系列的对观察者对象的引用,并在需要的时候调用每一个观察者共有的Update()方法。

    #include<iostream>
    #include<list>
    #include<string>
    using namespace std;
    class Observer{
        public:
            Observer(){}
            virtual ~Observer(){}
            virtual void update(){}
    };
    class Blog{
        public:
            Blog(){}
            virtual ~Blog(){}
            void Attach(Observer *observer){//博主添加订阅者
                m_observer.push_back(observer);
            }
            void Remove(Observer* observer){//博主移除订阅者
                m_observer.remove(observer);
            }
            void Notify(){//博主有新动态,通知订阅者
                list<Observer*>::iterator it=m_observer.begin();
                for(;it!=m_observer.end();it++){
                    (*it)->update();//订阅者获取博主新冬天
                }
            }
            virtual void Setstatus(string s){//
                m_status=s;
            }
            virtual string Getstatus(){
                return m_status;
            }
        private:
            list<Observer*> m_observer;//订阅者队列
        protected:
            string m_status;//
    };
    class BlogCSDN:public Blog{
        private:
            string m_name;//博主名字
        public:
            BlogCSDN(string name):m_name(name){}
            ~BlogCSDN(){}
            void Setstatus(string s){//返回博主新动态
                m_status="博主通知:"+m_name+s;
            }
            string Getstatus()
            {
                return m_status;
            }
    };
    class ObserverBlog:public Observer{//订阅者
        private:
            string m_name;
            Blog *m_blog;//持有博客指针用于订阅博文
        public:
            ObserverBlog(string name,Blog *blog){
                m_name=name;
                m_blog=blog;
            }
            ~ObserverBlog(){}
            void update(){//获取订阅信息
                string status=m_blog->Getstatus();
                cout<<m_name<<" 收到"<<status<<endl;//输出订阅信息
            }
    };
    int main()
    {
        Blog *blog=new BlogCSDN("liuxuejiang158");//博主
        Observer* observer1=new ObserverBlog("XXXX",blog);//订阅者
        blog->Attach(observer1);//博主添加XXXX
        blog->Setstatus("发表工作照片");//博主有新动态
        blog->Notify();//博主通知订阅者
        delete blog;
        delete observer1;
        return 0;
    }


    展开全文
  • 主要介绍了Vue发布订阅模式实现过程图解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 主要介绍了js实现的订阅发布者模式,结合完整示例形式分析了js订阅发布者模式相关实现与使用方法,需要的朋友可以参考下
  • 该例子程序是用C++代码编写,实现了发布-订阅者模式;通过该例子可以很好的理解设计模式中的发布-订阅者模式的精髓;
  • 发布订阅模式与观察者模式

    万次阅读 多人点赞 2019-03-29 18:25:12
    设计模式并非是软件开发的专业术语,实际上,“模式”最早诞生于建筑学。 设计模式的定义是:在面向对象软件设计过程中针对特定问题的简洁而优雅的解决方案。通俗一点说,设计模式是在某种场合下对某个问题的一种...
  • 主要介绍了JavaScript设计模式之观察者模式(发布订阅模式)原理与实现方法,结合实例形式分析了JavaScript观察者模式概念、原理、使用方法及相关操作注意事项,需要的朋友可以参考下
  • JavaScript发布者-订阅者模式

    千次阅读 2019-05-03 20:26:53
    发布者-订阅者模式又称观察者模式:当一个对象(发布者)状态发生改变时,所有依赖它的对象(订阅者)都会得到通知。 该模式广泛应用在异步编程中:我们无需关注对象在异步运行期间的内部状态,只需要订阅感兴趣的...
  • 本人自己实现的比较完整的发布订阅者模式,不过发布消息时是同步调用。并且在实现过程中使用了单例模式与缺省适配器模式。
  • 观察者模式发布订阅模式有什么区别?大多数的回答都是:Publishers + Subscribers = Observer Pattern,24种基本的设计模式并没有发布-订阅模式,发布订阅模式属于并发型模式;像典型的Mq;这两种相似单并不可以划...
  • js发布订阅者模式es6实现及其图解

    千次阅读 2019-07-04 13:44:06
    //发布者发布, 通知所有主题的所有订阅者更新 pub . publish ( dep1 ) ; console . log ( "===========================" ) ; //新建主题, 并向主题中增加订阅者 let dep2 = new Dep ( item => item + ...
  • 观察者模式 优点:更加解耦,支持广播通信 缺点:大量观察者,广播有性能问题 举个最简单的例子: 其中body是发布者,回调函数function是观察者。 document.body.onclick = function(){ console.log('我是一个观察...
  • 主要介绍了JavaScript设计模式之观察者模式发布订阅模式,结合实例形式详细分析了JavaScript观察者模式发布订阅模式相关概念、原理
  • 用于发布消息,接收任意多个参数,第一参数为要发布的信息名字(唯一标识),如"init/method",其他参数为传递给订阅回调函数的参数。 topic.subscribe: 用于订阅消息,接收两个参数,第一参数为要订阅...
  • JS中的发布-订阅者模式

    千次阅读 2019-03-13 17:19:43
    vue.js 是采用数据劫持结合发布者-订阅者模式的方式,通过Object.defineProperty()来劫持各个属性的setter,getter, 在数据变动时发布消息给订阅者,触发相应的监听回调。 三、什么是发布-订阅者模式 多个订阅者...
  • vue中发布订阅者模式

    千次阅读 2020-01-13 10:54:07
    https://www.jianshu.com/p/2ec316ca0f8b
  • 发布/订阅,类似设计模式中的观察者模式。 redis可以作为pub/sub的服务端。订阅得通过subscribe和psubscribe命令向redis server订阅消息类型,redis将消息类型称为channel。 当发布者通过publish命令向redis ...
  • js实现订阅发布者模式

    千次阅读 2019-05-21 17:42:04
    //如果当前话题已经有订阅者,获取到订阅者数组 //一个话题名下的 订阅者事件可以是多个fn1, fn2, fn3 topics[topic] = topics[topic] ? topics[topic] : []; //给每个订阅者添加唯一的token var token = (++...
  • 主要介绍了C#设计模式订阅发布模式的的相关资料,文中示例代码非常详细,供大家参考和学习,感兴趣的朋友可以了解下
  • 发布/订阅者模式 要搞清楚vue中的双向数据绑定原理,就必须理解什么是发布、订阅者模式!! 1、首先想好谁是发布者、谁是订阅者(例如NBA专栏就是发布者,NBA球迷就是订阅者) 2、然后给发布者添加一个缓存列表,...
  • zh众所周知,vue2.x版本是通过Object.defineProperty() 种的get进行拦截,set进行发送,其实这只是表面理解,实际运用的是JavaScript的 订阅者发布者模式。首先,了解一下什么是订阅者发布者模式 吧。w3c 上是...
  • 二 现实中的发布订阅者模式 1.比如小红最近在淘宝网上看上一双鞋子,但是呢 联系到卖家后,才发现这双鞋卖光了,但是小红对这双鞋又非常喜欢,所以呢联系卖家,问卖家什么时候有货,卖家告诉她,要等一个星期后才...
  • 订阅发布者模式本质上也是一种生产者消费者模式订阅者是消费者,发布者是生产者。如果一定要说个区别,就是抽象级别的区别吧。   订阅者肯定是个消费者,但消费者不一定是订阅者发布者一定是个生产者,但生产...
  • 主要介绍了浅谈发布订阅模式与观察者模式,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 改demo主要叙述java版本发布预订阅模式的主导思想(观察者模式

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 107,174
精华内容 42,869
关键字:

发布者订阅者模式