精华内容
下载资源
问答
  • java 子线程通过观察者模式通知主线程
  • 观察者模式

    千次阅读 2019-02-17 23:00:05
    关键点:  1、针对观察者与被观察者分别定义接口,有利于分别进行扩展。  2、重点就在被观察者的实现中: ... 3、观察者中需要有个接收被观察者通知的方法。 1.抽象主题角色,watched被观察 ...

    关键点:

        1、针对观察者与被观察者分别定义接口,有利于分别进行扩展。

        2、重点就在被观察者的实现中:

          (1)定义观察者集合,并定义针对集合的添加、删除操作,用于增加、删除订阅者(观察者)

          (2)定义通知方法,用于将新情况通知给观察者用户(订阅者用户)

        3、观察者中需要有个接收被观察者通知的方法。

    1.抽象主题角色,watched被观察

    public interface Watched {
        public void addWatcher(Watcher watcher);
        public void removeWatcher(Watcher watcher);
        public void notifyWatchers(String str);
    }

    2.抽象观察角色

    
    public interface Watcher {
        public void update(String str);
    }

    3.具体的被观察者

    public class ConcreteWatched implements Watched {
        //1.需要存储观察者
        private List<Watcher> list = new ArrayList<Watcher>();
        //2.新增观察者
        public void addWatcher(Watcher watcher) {
            list.add(watcher);
    
        }
        //3.删除观察者
        public void removeWatcher(Watcher watcher) {
            list.remove(watcher);
    
        }
        //4.调用观察者的方法来通知观察者
        public void notifyWatchers(String str) {
            for(Watcher watcher:list){
                watcher.update(str);
            }
    
        }
    }

    4.具体的观察者

    public class ConcreteWatcher implements Watcher {
        public void update(String str) {
            System.out.println(str);
        }
    }

    5.测试客户端

    public class Test {
    
        public static void main(String[] args) {
            Watched girl = new ConcreteWatched();
            Watcher watcher1 = new ConcreteWatcher();
            Watcher watcher2 = new ConcreteWatcher();
            Watcher watcher3 = new ConcreteWatcher();
    
            girl.addWatcher(watcher1);
            girl.addWatcher(watcher2);
            girl.addWatcher(watcher3);
    
            girl.notifyWatchers("update");
        }
    
    
    }

    本问的实现较为简单,比较通用的实现方式为观察者和被观察者都有多个实现,

    可参考下面这篇博文

    https://www.cnblogs.com/V1haoge/p/6513651.html

    展开全文
  • 观察者模式: ObserverPattern 定义对象间的一种一对多依赖关系, 使得每当一个对象状态...创建state状态标志位, 状态转换后通知更新给所有的观察者 代码示例 #include <iostream> #include <algorithm> //

    观察者模式: ObserverPattern

    定义对象间的一种一对多依赖关系, 使得每当一个对象状态发生改变时, 其相关依赖对象皆得到通知并自动更新

    应用

    最经典的应用就是我们订阅邮件, 当有新的文章发表, 发布者会通过邮件给我们这些订阅者发送通知, 我们就知道了更新的文章

    核心

    • 创建list链表保存所有的观察者基类指针
    • 创建state状态标志位, 状态转换后通知更新给所有的观察者

    代码示例

    在这里插入图片描述

    #include <iostream>
    #include <algorithm> // reverse
    #include <vector>
    #include <list>
    
    using namespace std;
    
    /* 观察者模式: 
    	有两个银行, 赵四和王五开的
    	张三跟赵四和王五借款后(行为), 没有钱(状态), 所以无法还给银行,只能等有钱才能还
    	银行如何知道张三有钱呢? 
    	方法1: 天天给张三打电话询问
    	方法2: 张三有了通知银行(显然这种方法更高效)
    	下面的代码就是实现了这样的一种方案: 
    		当一个对象状态发生改变, 其他依赖对象得到通知, 并进行自动的更新
    */
    
    // 银行
    class Credit{
    public:
        virtual void takeMoney()=0;
    };
    
    // 赵四家的银行
    class Zhao4: public Credit{
    public:
        void takeMoney(){
            cout<< "赵四收到了通知, 拿到了钱" <<endl;
        }
    };
    
    // 王五家的银行
    class Wang5: public Credit{
    public:
        void takeMoney(){
            cout<< "王五收到了通知, 拿到了钱" <<endl;
        }
    };
    
    // 借款方
    class Debit{
    public:
        virtual void borrow(Credit *c)=0; // 借钱
        virtual void notifyCredit() = 0;   // 通知
    };
    
    
    // 借款人 张三
    class ZhangSan: public Debit{
    private:
        list<Credit*> allCredits; // 表示贷款了几个银行
        bool state = false; // 表示有钱没钱
    public:
        void borrow(Credit *c){
            allCredits.emplace_back(c);
        }
        // 遍历所有银行, 通知有钱了 
        void notifyCredit(){
            for(Credit *a: allCredits){
                a->takeMoney();
            }
        }
    };
    
    int main() {
        Credit *zhao4 = new Zhao4();
        Credit *wang5 = new Wang5();
    
        Debit *zhangsan  = new ZhangSan();
        zhangsan->borrow(zhao4);
        zhangsan->borrow(wang5);
    
        // 一定时间后, 转到钱了, state改变, 通知所有银行
        zhangsan->notifyCredit();
        return 0;
    }
    
    
    展开全文
  • 通知 NSNotification ...通知:一种发送给一个或者多个观察者,用来通知其在程序中发生了某个事件的消息。Cocoa中的通知机制遵循的是一种广播模式。它是一种程序中事件的发起者或者是处理者和其它想要知道该

    通知 NSNotification
    OC中的KVO是一种简单的观察者设计模式,涉及到两个对象,分别是观察者和被观察者。这种方式实质有很大的局限性。OC的Foundation框架为开发者提供了新的一种观察者设计模式,即通知。
    通知:一种发送给一个或者多个观察者,用来通知其在程序中发生了某个事件的消息。Cocoa中的通知机制遵循的是一种广播模式。它是一种程序中事件的发起者或者是处理者和其它想要知道该事件的对象沟通的一种方式。消息的接收者,也就是观察者响应该事件来改变自己的UI、行为或者状态。
    初始化一个通知(NSNotification)的实例对象:

    NSNotification *notification1 = [NSNotification notificationWithName:@"nontification_One" object:self];
    //或者
    NSNotification *notification2 = [NSNotification notificationWithName:@"nontification_Two" object:self userInfo:@{@"content":@"Hello world!"}];

    其中name表示的是通知名称,object表示通知发起人(对象),userInfo:表示通知内容


    创建通知中心(NSNotificationCenter)对象

    NSNotificationCenter *center = [NSNotificationCenter defaultCenter];

    建立通知发送机制:

    //.m实现文件(观察者类中实现)
    //重写初始化方法
    -(id)init{
        if(self = [super init])
        {   //1.注册监听者
        [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(notificationAction:) name:@"WeatherAndPhoneUser" object:nil];
        }
        return self;
    }

    其中addObserver是添加监听者,selector是选择回调方法,name是通知名称,Object表示通知的目标。

    //回调方法
    -(void)notificationAction:(NSNotification *)notification{
        NSDictionary *dic = notification.userInfo;
        NSL(@"%@",dic);
    }
    //移除监听者
    -(void)dealloc{
        [[NSNotificationCenter defaultCenter] removeObserver:self];
    }
    //通知发送(一般在被观察者类中实现)
    -(void)sendMessage{
        [NSNotificationCenter default]postNotificationName:"WeatherAndPhoneUser" object:self userInfo:@{@"":@""}];
    }

    运行结果:
    这里写图片描述

    展开全文
  • 观察者模式-通知详解

    2018-08-22 15:31:17
    在这种模式中,一个目标物件管理所有相依于它的观察者物件,并且在它本身的状态改变时主动发出通知。这通常透过呼叫各观察者所提供的方法来实现。此种模式通常被用来实现事件处理系统。 观察者模式的类图如下:  ...

    观察者模式也叫发布/订阅模式,是软件设计模式中的一种。在这种模式中,一个目标物件管理所有相依于它的观察者物件,并且在它本身的状态改变时主动发出通知。这通常透过呼叫各观察者所提供的方法来实现。此种模式通常被用来实现事件处理系统。

    观察者模式的类图如下:

                                      

                                                                                                        观察者模式类图

    可以看出它有四个角色,具体如下:

    抽象主题(Subject):抽象主题是一个协议,它是一个观察者的集合容器,定义添加观察者(attach)方法,移除观察者(detach)方法和所有观察者发送通知的方法(notifyObserve)。

    抽象观察者(Observe):抽象观察者也是一个协议,它有一个更新(update)方法。

    具体观察者(ConcreteObserve):观察协议具体实现。

    具体主题(ConcerteSubject):主题协议的具体实现。

    从图中可以看出,引入观察和主题这两个协议后,观察者模式可以完美的将观察者和被观察的对象分离开,不仅提高了系统的可复用行,还降低了耦合度。

    在Cocoa Touch框架中,观察者模式的具体应用有两个 - 通知(notification)机制和KVO(Key-ValueObserving)机制。

    通知机制

    通知机制与委托机制不同的是,前者是“一对多”的对象之间的通信,后者是“一对一”的对象之间的通信。

    在通知机制中对某个通知感兴趣的所有对象可以成为接收者首先,对这些对象需要向通知中心(NSNotificationCenter)发出addObserve:选择器:名称:对象消息进行注册,在投送对象投送通知给通知中新世,通知中心就会把通知广播给注册过的接收者。所有的接收者都不知道是谁投送的,更不关心细节。投送对象与接收者是一对多的关系。接收者如果对通知不再关注,会给通知中心发出removeObserver:名称:对象:消息解除注册,以后不再接收通知。

                             

                                                                                 通知机制

    注册通知:

    - (void)viewDidLoad {
        [super viewDidLoad];
        self.view.backgroundColor = [UIColor whiteColor];
        [[NSNotificationCenter defaultCenter]addObserver:self selector:@selector(resignNotification:) name:@"login" object:nil];
    
        /** 换种方式 */
        __weak typeof(self) weakSelf = self;
        [[NSNotificationCenter defaultCenter]addObserverForName:@"drain" object:nil queue:[NSOperationQueue new] usingBlock:^(NSNotification * _Nonnull note) {
            NSLog(@"你瞅啥");
            NSLog(@"接收到通知:%@",[NSThread currentThread]);
        }];
    }
    
    -(void)resignNotification:(NSNotification *)notification{
        NSLog(@"%s",__func__);
        NSLog(@"接收到通知:%@",[NSThread currentThread]);
    }

    发送同步通知:

    -(void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event{
         [[NSNotificationCenter defaultCenter]postNotificationName:@"login" object:nil userInfo:@{}];
    
    }

    发送异步通知:

    /**
     * NSPostingStyle有三种:
     NSPostNow:与postNotificationName相同(就是在哪个线程里面就是获取当前线程的通知队列并且默认采用NSPostNow发送时机)
     NSPostASAP:不立即发出通知,而是在runloop匹配时调用,即:runloop处理事件源时
     NSPostWhenIdle:runloop闲置的时候post,即:runloop进入睡眠时
     */
    /*
     NSNotificationCoalescing消息合并的方式
     NSNotificationNoCoalescing = 0, //不合并
     NSNotificationCoalescingOnName = 1,//按名称合并
     NSNotificationCoalescingOnSender = 2,//按发送者合并
     */
    -(void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event{
        //每个线程都默认又一个通知队列,可以直接获取,也可以alloc
        NSNotificationQueue *notificationQueue = [NSNotificationQueue defaultQueue];
        NSNotification *notification = [NSNotification notificationWithName:@"drain" object:nil];
        NSNotification * notificationtwo = [NSNotification notificationWithName:@"drain" object:nil];
    
        NSLog(@"发送通知before:%@",[NSThread currentThread]);
        [notificationQueue enqueueNotification:notification postingStyle:NSPostNow coalesceMask:NSNotificationNoCoalescing forModes:nil];
        [notificationQueue enqueueNotification:notificationtwo postingStyle:NSPostWhenIdle coalesceMask:NSNotificationCoalescingOnName forModes:nil];
        [notificationQueue enqueueNotification:notification postingStyle:NSPostWhenIdle coalesceMask:NSNotificationCoalescingOnName forModes:nil];
        NSLog(@"发送通知After:%@",[NSThread currentThread]);
    }

    移除通知:

    [[NSNotificationCenter defaultCenter]removeObserver:self name:@"login" object:nil];
    //<# #>就是<## >

    输出结果:

    2018-08-22 15:20:53.382286+0800 AngelClient[4074:168069] -[ViewController resignNotification:]
    2018-08-22 15:20:53.382421+0800 AngelClient[4074:168069] 接收到通知:<NSThread: 0x60c0000788c0>{number = 1, name = main}
    2018-08-22 15:20:53.382513+0800 AngelClient[4074:168069] 发送通知before:<NSThread: 0x60c0000788c0>{number = 1, name = main}
    2018-08-22 15:20:53.382889+0800 AngelClient[4074:168112] 你瞅啥
    2018-08-22 15:20:53.383015+0800 AngelClient[4074:168112] 接收到通知:<NSThread: 0x604000267dc0>{number = 3, name = (null)}
    2018-08-22 15:20:53.383172+0800 AngelClient[4074:168069] 发送通知After:<NSThread: 0x60c0000788c0>{number = 1, name = main}
    2018-08-22 15:20:53.383594+0800 AngelClient[4074:168112] 你瞅啥
    2018-08-22 15:20:53.383741+0800 AngelClient[4074:168112] 接收到通知:<NSThread: 0x604000267dc0>{number = 3, name = (null)}

    NSNotificationCenter是单例模式,创建获得共享实例的方法defaultCenter。其中名称是通知的名字,对象是投送通知时传递过来的对象(不一定是self对象,如果接收者不需要,可以将其设为nil),USERINFO是投送通知时定义的字典对象,可以用于参数的传递,进行的是同步发送.NSNotificationQueue是将发送的通知加到当前线程的队列中,进行异步发送。

    下一篇:观察者模式-KVO详解

    展开全文
  • 一、通知中心是一种机制,是观察者设计模式的一种实现。 观察者,是一个对被观察者的状态变化需要做出反应的对象,所以观察者需要被观察者状态变化的信息 被观察者一旦发生变化,需要通知所有被观察者。如果不是...
  • 1、观察者 public interface Observer { // 声明响应方法 public void update(Observable o, Object obj); } 2、被观察者 public abstract class Observable { protected List<Observer> observers...
  • 当一个通知有多个观察者通知发生时,观察者的执行顺序是什么,是随机的吗, 如果是,有什么办法使他们按一定的顺序去执行?
  • 观察者模式也只是在使用通知中心的时刻才能用到,难道是观察者模式比不上代理模式?虽然说,观察者模式在效率上不如代理模式,但是使用观察者模式可以实现程序的解耦,并且在层次结构比较深的地方,使用观察者也比...
  • android,内容观察者,数据库变化通知

    千次阅读 2014-02-17 01:25:02
    //一旦执行添加删除修改操作,就context.getCOntentResolver().notifyChange(uri,...//用内容观察者观察这个uri的变化 getContentResolver().registerContentObserver(messageuri,true,new MyObserver(new Handler()));
  • 这个主题对象在状态上发生变化时,会通知所有观察者对象,使它们能够自动更新自己。 类图 角色 抽象主题(Subject)角色:抽象主题角色把所有对观察者对象的引用保存在一个聚集(比如ArrayList对象)里,每个主题...
  • 这个主题对象在状态变化时,会通知所有的观察者对象,使他们能够自动更新自己。 观察者模式结构图 Subject:抽象主题(抽象被观察者),抽象主题角色把所有观察者对象保存在一个集合里,每个主题都可以有任意数量的...
  • 设计模式之观察者模式

    万次阅读 2021-09-13 21:41:08
    观察者模式主要包括观察者(需要知道的人)和被观察者(被观察的那件事) 行为型模式 观察者模式属于推的模式,观察者是被动接受的 类图: 示例: 被观察者: import java.util.ArrayList; import java.util.List; ...
  • iOS通知观察者的添加和移除

    千次阅读 2016-12-12 16:10:25
    一种是在-view didload中注册通知观察者对应的我们需要在在dealloc中移除通知。因为didload只在view controller生成时执行一次,dealloc也是view controller销毁时才执行,这样对应保证我们不会多次注册通知或者多次...
  • java中观察者模式的使用场景

    千次阅读 2016-11-07 10:44:50
    特点一 : 被观察者 和观察者 一般是 一对多的关系,一个被观察者 对应多个观察者,当一个被观察者的状态发生改变时,被观察者通知观察者, 然后可以在观察者内部 进行业务逻辑的处理。 JD
  • 观察者模式定义了一种一对多的依赖关系, 让多个观察者对象可以同时监听某一主题对象, 当这个主题对象的状态发生改变的时候, 就会通知所有的观察者对象, 使他们可以自动更新自己。 subject 类, 一般称为主题类...
  • 安卓开发观察者模式应用-一个service通知多个activity更新ui的实现, service与activity的交互: 1.接口回调 2.自定义广播 3.观察者模式
  • IOS观察者设计模式

    2021-01-20 09:24:12
    什么是观察者模式?我们先打个比方,这就像你订...从经典的角度看,观察者模式是一种通知变化的模式,一般认为只在对象发生变化感兴趣的场合有用。主题对象知道有观察者存在,设置会维护观察者的一个队列;而从广义的角
  • 在此种模式中,一个目标物件管理所有相依于它的观察者物件,并且在它本身的状态改变时主动发出通知。这通常透过呼叫各观察者所提供的方法来实现。此种模式通常被用来实现事件处理系统。(百度百科) 当对象间存在一...
  • 观察者模式代码

    2018-03-27 15:18:32
    观察模式可以用多种形式来写这里分别用了委托跟接口。 优点: 1、观察者和被观察者是抽象耦合的。...缺点: 1、如果一个被观察者对象有很多的直接和间接的观察者的话,将所有的观察者通知到会花费很多时间。
  • 通知机制和KVO都是通过—------观察者模式实现的 KVO, 即: Key-Value Observing ,它提供一种机制,当指定的对象的属性被修改后,则对象就会接受到通知。简单的说就是每次指定的被观察的对象的属性被修改后...
  • C++ 观察者模式

    万次阅读 多人点赞 2017-03-13 19:33:34
    当主题对象的状态发生更改时,会通知所有观察者,让它们能够自动更新。 简述 背景 模式结构 优缺点 适用场景 案例分析 代码实现 版权所有:一去丶二三里,转载请注明出处:...
  • 都得到通知并被自动更新。如在舆情系统中发现有客户给出差评,就需要2小时内给相应的负责人发送短信通知,在客流系统中,人数超过预警值需要发送短信提醒相关负责人并记录到预警流水表中。 特点:一般由两个角色组成...
  • 观察者设计模式

    万次阅读 2019-09-23 16:39:10
    观察者设计模式 用订阅和发布来理解更好,我想了一下是的 为什么呢?因为监听器这个名词听起来是一个主动的,可实际监听器是一个被动的玩意 ...被观察者主题状态改变,通知观察者 下面开始模拟观察者设计模式...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 131,407
精华内容 52,562
关键字:

观察者通知