(九)大话设计模式 -观察者模式(发布-订阅者模式)(iOS版)

介绍

观察者模式也被称为发布-订阅（Publish/Subscribe）模式，它属于行为型模式的一种。观察者模式定义了一种一对多的依赖关系，一个主题对象可被多个观察者对象同时监听。当这个主题对象状态变化时，会通知所有观察者对象并作出相应处理逻辑。

角色

观察者模式定义了四种角色：抽象主题、具体主题、抽象观察者、具体观察者。

1.抽象主题（Subject）：该角色是一个抽象类或接口，定义了增加、删除、通知观察者对象的方法。

2.具体主题（ConcreteSubject）：该角色继承或实现了抽象主题，定义了一个集合存入注册过的具体观察者对象，在具体主题的内部状态发生改变时，给所有注册过的观察者发送通知。

3.抽象观察者（Observer）：该角色是具体观察者的抽象类，定义了一个更新方法。

4.具体观察者（ConcrereObserver）：该角色是具体的观察者对象，在得到具体主题更改通知时更新自身的状态。

代码实现

iOS版本就不理会抽象的两个角色了(如果做简单的一对多通知框架的话则需要使用到),直接上具体的的Subject和Observer

HandleProxy定义事件协议

#import <Foundation/Foundation.h>

NS_ASSUME_NONNULL_BEGIN

@protocol HandleProxy <NSObject>

@optional
-(void)didSomethingChanged;

@end

NS_ASSUME_NONNULL_END

观察者Observerable(监听主题对象的消息)

#import <Foundation/Foundation.h>
#import "HandleProxy.h"
NS_ASSUME_NONNULL_BEGIN

@interface Observerable : NSObject<HandleProxy>

@end

NS_ASSUME_NONNULL_END

#import "Observerable.h"

@implementation Observerable

-(void)didSomethingChanged {
    NSLog(@"Observerable收到通知消息");
}

@end

主题对象Subject,相当于消息中心（持有监听对象有变更时通知所有监听对象）

1.添加监听对象（两种方式 a.对象形式 b.Block形式）
2.通知所有监听对象

#import <Foundation/Foundation.h>
#import "HandleProxy.h"


typedef void(^SubjectHandleBlcok)();
NS_ASSUME_NONNULL_BEGIN

//主题对象
@interface Subject : NSObject

//单例
+ (instancetype)sharedInstance;
+ (void)removeInstance;

/*
 监听方式一:
 添加观察者 耦合
 但是更多时候 我们希望持有观察对象便于调试查看都有哪些对象监听了该消息
 */
- (void)addObserver:(id<HandleProxy>)observer;
//除移观察者
- (void)removeObserver:(id<HandleProxy>)observer;

/*
 监听方式二:
 handle形式 解耦
 */
- (void)addListenBlock:(SubjectHandleBlcok)block;
//remove
- (void)removeListenBlock:(SubjectHandleBlcok)block;

//主题对象通知所有的观察者
- (void)notifyAllObservers;

@end

NS_ASSUME_NONNULL_END

#import "Subject.h"

@interface Subject ()

@property (nonatomic, strong) NSHashTable *observers;
@property (nonatomic, strong) NSMutableArray *blocks;

@end

@implementation Subject

static dispatch_once_t onceToken;
static Subject *instance;
//单例
+ (instancetype)sharedInstance {
    dispatch_once(&onceToken, ^{
        instance = [[Subject alloc] init];
    });
    return instance;
}
+ (void)removeInstance {
    [instance.observers removeAllObjects];
    [instance.blocks removeAllObjects];
    instance = nil;
    onceToken = 0;
}

//添加观察者
- (void)addObserver:(id<HandleProxy>)observer {
    [self.observers addObject:observer];
}
//除移观察者
- (void)removeObserver:(id<HandleProxy>)observer {
    [self.observers removeObject:observer];
}

- (void)addListenBlock:(SubjectHandleBlcok)block {
    if (block == nil) {
        return;
    }
    [self.blocks addObject:block];
}

//remove
- (void)removeListenBlock:(SubjectHandleBlcok)block {
    if (block == nil) {
        return;
    }
    [self.blocks removeObject:block];
}

//主题对象通知所有的观察者
- (void)notifyAllObservers {
    for (id<HandleProxy> observer in self.observers) {
        if (observer && [observer respondsToSelector:@selector(didSomethingChanged)]) {
            [observer didSomethingChanged];
        }
    }
    for (SubjectHandleBlcok block in self.blocks) {
        block();
    }
}

-(NSMutableArray *)blocks {
    if (!_blocks) {
        _blocks = [[NSMutableArray alloc] init];
    }
    return _blocks;
}

- (NSHashTable *)observers {
    if (!_observers) {
        _observers = [NSHashTable weakObjectsHashTable];
    }
    return _observers;
}

@end

外部调用
消息监听回调的方式有两种
1.delegate的形式
2.Block形式(通过Block的形式更解耦 (不持有监听者) 但是更多时候我们希望持有观察对象便于调试查看都有哪些对象监听了该消息)

   /*
     观察者模式
     */
    
    //监听方式一
    Observerable *observer = [[Observerable alloc] init];//创建一个消息监听者
    [[Subject sharedInstance] addObserver:observer];//主题对象把 监听者 放在一个队列里面
    
    //监听方式二 解耦 通过EvenetHandle的形式更解耦 (不持有监听者)  但是更多时候 我们希望持有观察对象便于调试查看都有哪些对象监听了该消息
    [[Subject sharedInstance] addListenBlock:^{
        NSLog(@"block 1 收到通知消息");
    }];
    
    [[Subject sharedInstance] addListenBlock:^{
        NSLog(@"block 2 收到通知消息");
    }];
    
    SubjectHandleBlcok handle = ^(){
         NSLog(@"block 3 收到通知消息");
    };
    [[Subject sharedInstance] addListenBlock:handle];
    [[Subject sharedInstance] removeListenBlock:handle];
    //发出通知
    [[Subject sharedInstance] notifyAllObservers];////主题对象便利队列里面监听者 把消息发送给他们

结果

2019-03-26 10:46:14.244437+0800 DesignModeDemo[17725:2837364] Observerable收到通知消息
2019-03-26 10:46:14.244570+0800 DesignModeDemo[17725:2837364] block 1 收到通知消息
2019-03-26 10:46:14.244773+0800 DesignModeDemo[17725:2837364] block 2 收到通知消息

IOS开发场景

一对多的场景很多好比系统的NotifyCenter,KVO等本质都是这个模式，