介绍
观察者模式也被称为发布-订阅（Publish/Subscribe）模式，它属于行为型模式的一种。观察者模式定义了一种一对多的依赖关系，一个主题对象可被多个观察者对象同时监听。当这个主题对象状态变化时，会通知所有观察者对象并作出相应处理逻辑。
角色
观察者模式定义了四种角色：抽象主题、具体主题、抽象观察者、具体观察者。
1.抽象主题（Subject）：该角色是一个抽象类或接口，定义了增加、删除、通知观察者对象的方法。
2.具体主题（ConcreteSubject）：该角色继承或实现了抽象主题，定义了一个集合存入注册过的具体观察者对象，在具体主题的内部状态发生改变时，给所有注册过的观察者发送通知。
3.抽象观察者（Observer）：该角色是具体观察者的抽象类，定义了一个更新方法。
4.具体观察者（ConcrereObserver）：该角色是具体的观察者对象，在得到具体主题更改通知时更新自身的状态。
代码实现
iOS版本就不理会抽象的两个角色了(如果做简单的一对多通知框架的话则需要使用到),直接上具体的的Subject和Observer
HandleProxy定义事件协议
#import
NS_ASSUME_NONNULL_BEGIN
@protocol HandleProxy
@optional
-(void)didSomethingChanged;
@end
NS_ASSUME_NONNULL_END
观察者Observerable(监听主题对象的消息)
#import
#import "HandleProxy.h"
NS_ASSUME_NONNULL_BEGIN
@interface Observerable : NSObject
@end
NS_ASSUME_NONNULL_END
#import "Observerable.h"
@implementation Observerable
-(void)didSomethingChanged {
NSLog(@"Observerable收到通知消息");
}
@end
主题对象Subject,相当于消息中心（持有监听对象 有变更时通知所有监听对象）
1.添加监听对象（两种方式 a.对象形式 b.Block形式）
2.通知所有监听对象
#import
#import "HandleProxy.h"
typedef void(^SubjectHandleBlcok)();
NS_ASSUME_NONNULL_BEGIN
//主题对象
@interface Subject : NSObject
//单例
+ (instancetype)sharedInstance;
+ (void)removeInstance;
/*
监听方式一:
添加观察者 耦合
但是更多时候 我们希望持有观察对象便于调试查看都有哪些对象监听了该消息
*/
- (void)addObserver:(id)observer;
//除移观察者
- (void)removeObserver:(id)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)observer {
[self.observers addObject:observer];
}
//除移观察者
- (void)removeObserver:(id)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 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等 本质都是这个模式，