【經典的貓和老鼠】觀察者模式和事件的使用！
[问题点数：20分，结帖人lvjin110]
【經典的貓和老鼠】觀察者模式和事件的使用！
[问题点数：20分，结帖人lvjin110]
不显示删除回复
显示所有回复
显示星级回复
显示得分回复
只显示楼主
相关帖子推荐：
本帖子已过去太久远了，不再提供回复功能。iOS KVO 观察者模式实现方式 - 互联万物 - ITeye技术网站
博客分类：
原文：/post//
KVO (Key Value Observing)是ios里面一种特别方便的机制用于“捕捉”对象属性的变化。在概念理解上，是设计模式里面观察者模式的一种实践。
拿一个具体的例子来讲：
有一个数据对象EmployeeData，该对象有一个属性salary
有一个ViewController 用于显示对象EmployeeData的属性salary的值
当salary的值发生变化的时候，ViewController如何显示变化后的新值。
&&& “可以在EmployeeData类弱引用ViewController类，然后在EmployeeData数据发生变化时，调
&&& 用ViewController类的回调函数。这个方法虽然能达到目的，但是会破坏EmployeeData的完整
&&& 性，一个负责数据管理的类，不应当依赖另一个负责视图控制的类；换句话说，EmployeeData
&&& 类不应该知道关于ViewController类的任何事情，甚至不需要知道其从在”
使用ios提供的消息中心（NSNotificationCenter）。在此EmployeeData为消息生产者，ViewController为消息消费者。当salary数据发生变化时发送一个消息既可。
ViewController接收到salary数据变化的通知做相对应的业务处理。不足之处如同方案一，EmployeeData对象的salary每次变动都需要发送“通知”。这项工作对EmployeeData自身来讲毫无意义。
在ViewController中将自身（self）设置为EmployeeData salary属性值变化的观察者。当salary值发生变化时，执行一个回调方法。这样对“EmployeeData”来讲不用关心除自身业务以
外的事情。避免了方案一和方案二的瑕疵。对ViewController来讲关注谁的变化，注册自己为其的观察者既可。间接轻便。
下面是一些核心的代码。
EmployeeData.h
KVOExample
Created by gaoyong on 12-8-8.
Copyright (c) 2012年 gaoyong. All rights reserved.
#import &Foundation/Foundation.h&
@interface EmployeeData : NSObject {
NSString *
@property(nonatomic,retain) NSString *
EmployeeData.m
KVOExample
Created by gaoyong on 12-8-8.
Copyright (c) 2012年 gaoyong. All rights reserved.
#import "EmployeeData.h"
@implementation EmployeeData
ViewController.h
KVOExample
Created by gaoyong on 12-8-8.
Copyright (c) 2012年 gaoyong. All rights reserved.
#import &UIKit/UIKit.h&
@interface ViewController : UIViewController {
@property(nonatomic,retain) IBOutlet UILabel *
ViewController.m
KVOExample
Created by gaoyong on 12-8-8.
Copyright (c) 2012年 gaoyong. All rights reserved.
#import "ViewController.h"
#import "EmployeeData.h"
@interface ViewController () {
EmployeeData *employeeD
@implementation ViewController
- (void)viewDidLoad
[super viewDidLoad];
// Do any additional setup after loading the view, typically from a nib.
employeeData = [[EmployeeData alloc] init];
[employeeData addObserver:self forKeyPath:@"salary" options:NSKeyValueObservingOptionNew context:nil];
-(void)viewDidAppear:(BOOL)animated {
//employeeData.salary = @"20";
//salary.text = employeeData.
employeeData.salary = @"20";
employeeData.salary = @"200";
employeeData.salary = @"2000";
employeeData.salary = @"20000";
employeeData.salary = @"200000";
- (void)viewDidUnload
[super viewDidUnload];
// Release any retained subviews of the main view.
- (BOOL)shouldAutorotateToInterfaceOrientation:(UIInterfaceOrientation)interfaceOrientation
return (interfaceOrientation != UIInterfaceOrientationPortraitUpsideDown);
-(void) observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary *)change context:(void *)context {
NSLog(@"observeValueForKeyPath is run"); // 美妙在这里：这一行会打印5次。
if (object == employeeData && [keyPath isEqualToString:@"salary"]) {
self.salary.text = employeeData.
-(void) dealloc {
[employeeData removeObserver:self forKeyPath:@"salary"];
浏览: 170521 次
来自: 上海
这个现在已经广泛使用了嘛！
非常之详细
美女求认识
为什么不好使呢?本文来自www.lanttor.org
Internet气象站
有一个模式可以帮助你的对象知悉现况，不会错过对象感兴趣的事。对象甚至在运行时可决定是否要继续被通知。观察者模式是JDK中使用最多的模式之一。非常有用。
气象监测应用的概况
认识观察者模式
报纸和杂志的订阅是怎么回事：
出版者&+&订阅者&=&观察者模式
出版者改称为“主题”(subject)；订阅者改称为“观察者”(Observer)。
观察者模式定义了对象之间的一对多依赖，这样一来，当一个对象改变时，它的所有依赖者都会收到通知并自动更新。
定义观察者模式
实现观察者模式的方法不只一种，但是以包含Subject和Observer接口的类设计的做法最常见。
为了交互对象之间的松耦合设计而努力。当两个对象之间松耦合，他们依然可以交互，但是不太清楚彼此的细节。
观察者模式提供了一种对象设计，让主题和观察者之间松耦合。
松耦合的设计之所以能让我们建立有弹性的OO系统，能够应对变化，是因为对象之间的互相依赖降低到了最低。
设计气象站
气象站代码
Subject.java代码：
package&headfirst.observer.
public&interface&Subject {
&&&&public&void&registerObserver(Observer o);
&&&&public&void&removeObserver(Observer o);
&&&&public&void&notifyObservers();
Observer.java代码：
package&headfirst.observer.
public&interface&Observer {
&&&&public&void&update(float&temp,&float&humidity,&float&pressure);
DisplayElement.java代码：
package&headfirst.observer.
public&interface&DisplayElement {
&&&&public&void&display();
WeatherData.java代码：
package&headfirst.observer.
import&java.util.*;
public&class&WeatherData&implements&Subject {
&&&&private&ArrayList&
&&&&private&float&
&&&&private&float&
&&&&private&float&
&&&&public&WeatherData() {
&&&&&&&&observers&=&new&ArrayList();
&&&&public&void&registerObserver(Observer o) {
&&&&&&&&observers.add(o);
&&&&public&void&removeObserver(Observer o) {
&&&&&&&&int&i =&observers.indexOf(o);
&&&&&&&&if&(i &= 0) {
&&&&&&&&&&&&observers.remove(i);
&&&&public&void&notifyObservers() {
&&&&&&&&for&(int&i = 0; i &&observers.size(); i++) {
&&&&&&&&&&& Observer observer = (Observer)observers.get(i);
&&&&&&&&&&& observer.update(temperature,&humidity,&pressure);
&&&&public&void&measurementsChanged() {
&&&&&&& notifyObservers();
&&&&public&void&setMeasurements(float&temperature,&float&humidity,&float&pressure) {
&&&&&&&&this.temperature&=
&&&&&&&&this.humidity&=
&&&&&&&&this.pressure&=
&&&&&&& measurementsChanged();
&&&&public&float&getTemperature() {
&&&&&&&&return&
&&&&public&float&getHumidity() {
&&&&&&&&return&
&&&&public&float&getPressure() {
&&&&&&&&return&
CurrentConditionsDisplay.java代码：
package&headfirst.observer.
public&class&CurrentConditionsDisplay&implements&Observer, DisplayElement {
&&&&private&float&
&&&&private&float&
&&&&private&Subject&weatherData;
&&&&public&CurrentConditionsDisplay(Subject weatherData) {
&&&&&&&&this.weatherData&= weatherD
&&&&&&& weatherData.registerObserver(this);
&&&&public&void&update(float&temperature,&float&humidity,&float&pressure) {
&&&&&&&&this.temperature&=
&&&&&&&&this.humidity&=
&&&&&&& display();
&&&&public&void&display() {
&&&&&&& System.out.println(&Current conditions: &&+&temperature
&&&&&&&&&&& +&&F degrees and &&+&humidity&+&&% humidity&);
ForecastDisplay.java代码：
package&headfirst.observer.
import&java.util.*;
public&class&ForecastDisplay&implements&Observer, DisplayElement {
&&&&private&float&currentPressure&= 29.92f;&
&&&&private&float&lastP
&&&&private&WeatherData&weatherData;
&&&&public&ForecastDisplay(WeatherData weatherData) {
&&&&&&&&this.weatherData&= weatherD
&&&&&&& weatherData.registerObserver(this);
&&&&public&void&update(float&temp,&float&humidity,&float&pressure) {
&&&&&&&&&&&&&&&&lastPressure&=&currentP
&&&&&&&&currentPressure&=
&&&&&&& display();
&&&&public&void&display() {
&&&&&&& System.out.print(&Forecast: &);
&&&&&&&&if&(currentPressure&&&lastPressure) {
&&&&&&&&&&& System.out.println(&Improving weather on the way!&);
&&&&&&& }&else&if&(currentPressure&==&lastPressure) {
&&&&&&&&&&& System.out.println(&More of the same&);
&&&&&&& }&else&if&(currentPressure&&&lastPressure) {
&&&&&&&&&&& System.out.println(&Watch out for cooler, rainy weather&);
StaticsDisplay.java代码：
package&headfirst.observer.
import&java.util.*;
public&class&StatisticsDisplay&implements&Observer, DisplayElement {
&&&&private&float&maxTemp&= 0.0f;
&&&&private&float&minTemp&= 200;
&&&&private&float&tempSum= 0.0f;
&&&&private&int&numR
&&&&private&WeatherData&weatherData;
&&&&public&StatisticsDisplay(WeatherData weatherData) {
&&&&&&&&this.weatherData&= weatherD
&&&&&&& weatherData.registerObserver(this);
&&&&public&void&update(float&temp,&float&humidity,&float&pressure) {
&&&&&&&&tempSum&+=
&&&&&&&&numReadings++;
&&&&&&&&if&(temp &&maxTemp) {
&&&&&&&&&&&&maxTemp&=
&&&&&&&&if&(temp &&minTemp) {
&&&&&&&&&&&&minTemp&=
&&&&&&& display();
&&&&public&void&display() {
&&&&&&& System.out.println(&Avg/Max/Min temperature = &&+ (tempSum&/&numReadings)
&&&&&&&&&&& +&&/&&+&maxTemp&+&&/&&+&minTemp);
HeatIndexDisplay.java代码：
package&headfirst.observer.
public&class&HeatIndexDisplay&implements&Observer, DisplayElement {
&&&&float&heatIndex&= 0.0f;
&&&&private&WeatherData&weatherData;
&&&&public&HeatIndexDisplay(WeatherData weatherData) {
&&&&&&&&this.weatherData&= weatherD
&&&&&&& weatherData.registerObserver(this);
&&&&public&void&update(float&t,&float&rh,&float&pressure) {
&&&&&&&&heatIndex&= computeHeatIndex(t, rh);
&&&&&&& display();
&&&&private&float&computeHeatIndex(float&t,&float&rh) {
&&&&&&&&float&index = (float)((16.923 + (0.185212 * t) + (5.37941 * rh) - (0.100254 * t * rh)&
&&&&&&&&&&& + (0. * (t * t)) + (0. * (rh * rh))
&&&&&&&&&&& + (0. * (t * t * rh)) - (0. * (t * rh * rh)) +
&&&&&&&&&&& (0. * (t * t * rh * rh)) - (0. * (t * t * t)) + (0. *
&&&&&&&&&&& (rh * rh * rh)) + (0. * (t * t * t * rh)) +
&&&&&&&&&&& (0. * (t * rh * rh * rh)) - (0.9 * (t * t * t * rh * rh)) +
&&&&&&&&&&& 0.296 * (t * t * rh * rh * rh)) -
&&&&&&&&&&& (0.1975 * (t * t * t * rh * rh * rh)));
&&&&&&&&return&
&&&&public&void&display() {
&&&&&&& System.out.println(&Heat index is &&+&heatIndex);
测试代码（WeatherStationHeatIndex.java）:
package&headfirst.observer.
import&java.util.*;
public&class&WeatherStationHeatIndex {
&&&&public&static&void&main(String[] args) {
&&&&&&& WeatherData weatherData =&new&WeatherData();
&&&&&&& CurrentConditionsDisplay&currentDisplay&=&new&CurrentConditionsDisplay(weatherData);
&&&&&&& StatisticsDisplay&statisticsDisplay&=&new&StatisticsDisplay(weatherData);
&&&&&&& ForecastDisplay&forecastDisplay&=&new&ForecastDisplay(weatherData);
&&&&&&& HeatIndexDisplay&heatIndexDisplay&=&new&HeatIndexDisplay(weatherData);
&&&&&&& weatherData.setMeasurements(80, 65, 30.4f);
&&&&&&& weatherData.setMeasurements(82, 70, 29.2f);
&&&&&&& weatherData.setMeasurements(78, 90, 29.2f);
Current conditions: 80.0F degrees and 65.0% humidity
Avg/Max/Min temperature = 80.0/80.0/80.0
Forecast: Improving weather on the way!
Heat index is 82.95535
Current conditions: 82.0F degrees and 70.0% humidity
Avg/Max/Min temperature = 81.0/82.0/80.0
Forecast: Watch out for cooler, rainy weather
Heat index is 86.90124
Current conditions: 78.0F degrees and 90.0% humidity
Avg/Max/Min temperature = 80.0/82.0/78.0
Forecast: More of the same
Heat index is 83.64967
使用java内置的观察者模式
java.util包内包含最基本的Observer接口和Observable类。
导入Observer/Observable：
import java.util.O
import java.util.O
使用Observable类代替之前的Subject接口；Observable是类，所以WeatherData继承Observable。
Observable如何送出通知：
先调用setChanged()方法，标记状态已经改变的事实；
然后调用notifyObservers()/notifyObservers(Object arg)
Observer如何接收通知：
观察者实现了update()方法，只是方法的签名更改为update(Observable o, Object arg)
在update()中，先确定观察者属于WeatherData类型，然后利用getter方法获取相应的更新数据，然后调用display()。
利用内置的观察者模式重做气象站
WeatherData.java代码：
package&headfirst.observer.
import&java.util.O
import&java.util.Observer;
public&class&WeatherData&extends&Observable {
&&&&private&float&
&&&&private&float&
&&&&private&float&
&&&&public&WeatherData() { }
&&&&public&void&measurementsChanged() {
&&&&&&& setChanged();
&&&&&&& notifyObservers();
&&&&public&void&setMeasurements(float&temperature,&float&humidity,&float&pressure) {
&&&&&&&&this.temperature =
&&&&&&&&this.humidity =
&&&&&&&&this.pressure =
&&&&&&& measurementsChanged();
&&&&public&float&getTemperature() {
&&&&&&&&return&
&&&&public&float&getHumidity() {
&&&&&&&&return&
&&&&public&float&getPressure() {
&&&&&&&&return&
CurrentConditionsDisplay.java代码：
package&headfirst.observer.
import&java.util.O
import&java.util.O
public&class&CurrentConditionsDisplay&implements&Observer, DisplayElement {
&&&&private&float&
&&&&private&float&
&&&&public&CurrentConditionsDisplay(Observable observable) {
&&&&&&&&this.observable =
&&&&&&& observable.addObserver(this);
&&&&public&void&update(Observable obs, Object arg) {
&&&&&&&&if&(obs&instanceof&WeatherData) {
&&&&&&&&&&& WeatherData weatherData = (WeatherData)
&&&&&&&&&&&&this.temperature = weatherData.getTemperature();
&&&&&&&&&&&&this.humidity = weatherData.getHumidity();
&&&&&&&&&&& display();
&&&&public&void&display() {
&&&&&&& System.out.println(&Current conditions: & + temperature
&&&&&&&&&&& + &F degrees and & + humidity + &% humidity&);
JDK Swing中观察者模式的使用
一个简单的Swing API：JButton。如果你观察一下JButton的超类AbstractButton，会看到许多增加与删除Listener的方法。这些方法可以让观察者感应到Swing组件的不同类型事件。比方说，ActionListener让你“倾听”可能发生在按钮上的动作，例如按下按钮。这些方法就是典型的观察者模式的使用。
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：130094次
积分：1877
积分：1877
排名：第8921名
原创：38篇
转载：43篇
译文：13篇
评论：11条
(2)(1)(2)(1)(2)(2)(6)(1)(2)(1)(1)(3)(4)(2)(2)(4)(1)(1)(1)(9)(1)(1)(10)(1)(5)(3)(1)(3)(8)(6)(4)(1)(2)细数Objective-C中的回调机制
协议主要是提供接口、或是类似C++多重继承功能，为类提供一种修饰机制。协议不是为回调而生的，它应该表述一组互操作约定。
实现简单，容易理解。
强类型检查。
类与类间建立了比较强的耦合关系
有可能需要较长期保存委托以进行回调。如果保留的委托需要有独占性，可能会给单件模式、以及多线程带来麻烦。
类只能通过一个方法完成一种类型的回调。代码逻辑很容易集中到一个方法中。
大部分回调使用实际无需通过协议暴露给外部。
二、使用respondsToSelector和performSelector进行回调。
利用OBJC的运行时特性，查找对象的消息进行回调
与OBJC代码兼容性好。
具有延迟执行等特性。
轻量级的回调机制。
回调产生的返回值只能为id类型，int等类型会产生错误。
参数最多只能传入两个。但可以通过建立包含多个参数的参数类进行回避。同时返回值限制也可通过此方式解决，即建立一个输入类和一个输出类。NSInvocation也提供了多参数的解决方法。
& [target performSelector:
@selector(callback)];
方式建立回调，则需要对类的回调消息名建立约定，且回调消息名具有独占性，即一个类中只能以此消息名进行回调。
如果通过外部传入SEL建立回调
& [target performSelector: sel];
或是外部传入字符串建立回调
performSelector:NSSelectorFromString(@"callback")];
使用自动引数编译器特征（ARC）会产生警告“performSelector may cause a leak because
its selector is unknown”
使用此种方式建立回调，当传入一个不符合约定的消息时，会产生副作用继续运行，而非报错。比如约定消息有2个参数，但传入消息只有1个参数，则按照参数约定顺序屏蔽掉最后传入的参数。或是传入消息具有3个参数，则多余的参数值未初始化。
三、函数指针
传统的C语言回调机制。
轻量级的回调机制。
只约定返回值和参数，而非函数名。无参数、返回值限制，使用灵活。
编译器提供类型检查。（错误时产生警告）
与OBJC的消息机制不兼容。因为消息并非C语言中那样，函数名对应函数指针。即只能对C函数进行回调。
传入不符合约定的函数指针时，产生副作用继续运行，而非报错。
四、objc_msgSend
通过导入#import
&objc/message.h&获得运行时的消息调用。
& id objc_msgSend(id theReceiver, SEL
theSelector, ...)
轻量级的回调机制。
无传入参数限制。
相比performSelector，使用自动引数特征时，不产生警告。
同系列的方法支持double、struct等类型的返回值，但仍然不支持int型返回值（可使用NSNumber包装以回避）。
传入不符合约定的消息时，产生副作用继续运行，而非报错。
IMP类似于OBJC提供的函数指针，它通过methodForSelector方法查询传入的Selector，以获得函数的入口地址。
& id (*IMP)(id, SEL, ...)
相比普通C语言的函数指针，其定义多了id,SEL这两个强制参数约定，其他与函数指针无异。
轻量级的回调机制。
传入不符合约定的消息时，报错。
无传入参数限制。返回值可通过强转获得，无类型限制。如：
typedef int (*CBFUNC)(id, SEL, int, int, int); // 定义函数指针类型
int ret = ((CBFUNC)callback)(self, sel, param1, param2, param3); //
这里的id和SEL只是OBJC系统约定的占位，自定义回调时无实际意义。
由于此阶段实际是函数指针调用，因此最好还是typedef定义函数指针，然后对IMP强转一下，以免出现错误，也能提供一些编译期保护。
依然不能提供如同协议和函数指针的编译期类型检查
六、NSNotificationCenter
NSNotificationCenter是OBJC提供的消息机制。它有些类似于观察者模式，通过关注感兴趣的消息，建立回调。NSNotificationCenter提供了一种低耦合的对象通讯机制，特别适合无指定对象的一对多回调。
主要方法：
1）获取消息中心实例（系统已创建，单件模式）
NSNotificationCenter *nc = [NSNotificationCenter
defaultCenter];
2）发送消息。(事件发生时调用)
NSNotificationCenter *nc = [NSNotificationCenter
defaultCenter];
postNotificationName:
NOTIFY_MSG_UC_COMMON_PLAYER_PLAY&&
// 消息名（字符串）
&&&&&&&&&&&&&&&&&&&&&
object:self&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&&&&&
userInfo:nil];&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
// 用户字典（传递更多自定义参数）
3）注册消息
addObserver:
self&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
&&&&&&&&&&
@selector(handleNotify_Play:)&&&&
&&&&&&&&&&&&&&
name: NOTIFY_MSG_UC_COMMON_PLAYER_PLAY& //
&&&&&&&&&&&&
nil];&&&&&&&&&&&&&&&&&&&&&&&&&&&&
4）注销消息
removeObserver: self];
5）回调定义
&&& - (void)
handleNotify_Play:(NSNotification *)
&& 只有一个参数
NSNotification*
&name&&&&&
&object&&& //
&userInfo& // 用户字典
回调对象间耦合度低。相互之间可不必知道对方存在。
通过消息传递的信息无限制。
观察者可选择特定消息、特定对象，或者特定对象的特定消息进行观察。
缺乏时序性。当事件发生时，回调执行的先后次序不确定。也不能等待回调完成执行后续操作。解决：1）使用传统回调机制。2）多线程时，可使用NSCondition同步线程。3）使用更多的消息。（过多使用可能导致混乱）
Block是OBJC提供的一种运行时方法机制，类似于Javascript的匿名函数。它提供了一种运行时的临时回调机制。
Block对象的声明：
& 声明一个参数为int，返回值为int的Block对象cb。
(^cb)(int);
& 也可以通过typedef简化定义。
&&& typedef
int(^BLOCK_CALLBACK_FUNC)(int);
BLOCK_CALLBACK_FUNC cb = …
& 回调函数定义：
-(int)handleBlockCallbackFunc: (BLOCK_CALLBACK_FUNC)callback
return callback(10);
回调函数使用：
& 1）赋值后使用
BLOCK_CALLBACK_FUNC cb =
^(int param)
NSLog(@"Block Msg: %d", param);
return param*2;
int ret = [self handleBlockCallbackFunc:cb];
& 2）使用时赋值
int ret = [self handleBlockCallbackFunc:
&&&&&&&&&&&&&&&&
^(int param) {
&&&&&&&&&&&&&&&&&&
NSLog(@"Block Msg: %d", param);
&&&&&&&&&&&&&&&&&&
return param*2;
&&&&&&&&&&&&&&&&
1）block对象使用的变量、参数在运行时被绑定，因此可以直接使用栈空间建立的变量，无需参数传入。但block对象的创建依然有生命周期限制，因此传入异步调用的block对象时，如果是栈空间创建的block，必须
使用Block_copy()将block拷出备份，然后使用Block_release()将block释放。参见Using
Blocks章，Patterns to Avoid节
2）对于在栈空间声明的变量，绑定到block时被标记为const。只能读取不能写入。如果需要写入，需要用__block对变量进行标记。此时block使用的是从栈拷贝到堆中的对象。当出block时，如果栈可用则将堆中对象自动拷贝回栈。
最轻量级的回调机制。
编译器类型检查。
如函数指针一样，灵活定义回调函数。
执行效率。（影响程度不清楚）
容易导致代码逻辑集中。
IOS4之后的特性
OBJC还没有太完美的轻量级回调机制，只能根据情况选择合适的机制。
单纯的回调，且没有复用的必要，也无IOS版本限制，可采用block。
单纯的回调，有复用要求，可使用performSelector、objc_msgSend，或是IMP的回调机制。
使用自动引数的情况下，尽量不使用performSelector回调传入的@Selector，防止警告。
对象间有较多的互操作，对象有复用的必要，可采用协议。
无指定对象的一对多回调采用NSNotificationCenter。
有延迟调用等特殊应用的，可以使用performSelector。
已投稿到：
以上网友发言只代表其个人观点，不代表新浪网的观点或立场。}