Android中的设计模式——观察者模式

原创 2016年08月31日 11:50:34

先看下这个模式的定义。

定义对象间的一种一对多的依赖关系,当一个对象的状态发送改变时,所有依赖于它的对象都能得到通知并被自动更新

还是那句话,定义往往是抽象的,要深刻的理解定义,你需要自己动手实践一下。

先来讲几个情景。

  • 情景1

    有一种短信服务,比如天气预报服务,一旦你订阅该服务,你只需按月付费,付完费后,每天一旦有天气信息更新,它就会及时向你发送最新的天气信息。

  • 情景2

    杂志的订阅,你只需向邮局订阅杂志,缴纳一定的费用,当有新的杂志时,邮局会自动将杂志送至你预留的地址。

观察上面两个情景,有一个共同点,就是我们无需每时每刻关注我们感兴趣的东西,我们只需做的就是订阅感兴趣的事物,比如天气预报服务,杂志等,一旦我们订阅的事物发生变化,比如有新的天气预报信息,新的杂志等,被订阅的事物就会即时通知到订阅者,即我们。而这些被订阅的事物可以拥有多个订阅者,也就是一对多的关系。当然,严格意义上讲,这个一对多可以包含一对一,因为一对一是一对多的特例,没有特殊说明,本文的一对多包含了一对一。

现在你反过头来看看观察者模式的定义,你是不是豁然开朗了。

然后我们看一下观察者模式的几个重要组成。

  • 观察者,我们称它为Observer,有时候我们也称它为订阅者,即Subscriber
  • 被观察者,我们称它为Observable,即可以被观察的东西,有时候还会称之为主题,即Subject

至于观察者模式的具体实现,这里带带大家实现一下场景一,其实java中提供了Observable类和Observer接口供我们快速的实现该模式,但是为了加深印象,我们不使用这两个类。

场景1中我们感兴趣的事情是天气预报,于是,我们应该定义一个Weather实体类。

public class Weather {
private String description;
public Weather(String description) {
this.description = description;
}
public String getDescription() {
return description;
}
public void setDescription(String description) {
this.description = description;
}
@Override
public String toString() {
return "Weather{" +
"description='" + description + '\'' +
'}';
}
}

然后定义我们的被观察者,我们想要这个被观察者能够通用,将其定义成泛型。内部应该暴露register和unregister方法供观察者订阅和取消订阅,至于观察者的保存,直接用ArrayList即可,此外,当有主题内容发送改变时,会即时通知观察者做出反应,因此应该暴露一个notifyObservers方法,以上方法的具体实现见如下代码。

public class Observable<T> {
List<Observer<T>> mObservers = new ArrayList<Observer<T>>();
public void register(Observer<T> observer) {
if (observer == null) {
throw new NullPointerException("observer == null");
}
synchronized (this) {
if (!mObservers.contains(observer))
mObservers.add(observer);
} }
public synchronized void unregister(Observer<T> observer) {
mObservers.remove(observer);
}
public void notifyObservers(T data) {
for (Observer<T> observer : mObservers) {
observer.onUpdate(this, data);
}
}
}

而我们的观察者,只需要实现一个观察者的接口Observer,该接口也是泛型的。其定义如下。

public interface Observer<T> {
void onUpdate(Observable<T> observable,T data);
}

一旦订阅的主题发送变换就会回调该接口。

我们来使用一下,我们定义了一个天气变换的主题,也就是被观察者,还有两个观察者观察天气变换,一旦变换了,就打印出天气信息,注意一定要调用被观察者的register进行注册,否则会收不到变换信息。而一旦不敢兴趣了,直接调用unregister方法进行取消注册即可

public class Main {
public static void main(String [] args){
Observable<Weather> observable=new Observable<Weather>();
Observer<Weather> observer1=new Observer<Weather>() {
@Override
public void onUpdate(Observable<Weather> observable, Weather data) {
System.out.println("观察者1:"+data.toString());
}
Observer<Weather> observer2=new Observer<Weather>() {
};
@Override
public void onUpdate(Observable<Weather> observable, Weather data) {
System.out.println("观察者2:"+data.toString());
}
observable.register(observer1);
};
observable.register(observer2);
Weather weather=new Weather("晴转多云");
observable.notifyObservers(weather);
Weather weather1=new Weather("多云转阴");
observable.notifyObservers(weather1);
observable.unregister(observer1);
Weather weather2=new Weather("台风");
observable.notifyObservers(weather2);
}
}

最后的输出结果也是没有什么问题的,如下

观察者1:Weather{description=’晴转多云’} 
观察者2:Weather{description=’晴转多云’} 
观察者1:Weather{description=’多云转阴’} 
观察者2:Weather{description=’多云转阴’} 
观察者2:Weather{description=’台风’}

接下来我们看看观察者模式在android中的应用。我们从最简单的开始。还记得我们为一个Button设置点击事件的代码吗。

Button btn=new Button(this);
btn.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
Log.e("TAG","click");
}
});

其实严格意义上讲,这个最多算是回调,但是我们可以将其看成是一对一的观察者模式,即只有一个观察者。

其实只要是set系列的设置监听器的方法最多都只能算回调,但是有一些监听器式add进去的,这种就是观察者模式了,比如RecyclerView中的addOnScrollListener方法

private List<OnScrollListener> mScrollListeners;
public void addOnScrollListener(OnScrollListener listener) {
if (mScrollListeners == null) {
mScrollListeners = new ArrayList<OnScrollListener>();
}
mScrollListeners.add(listener);
}
public void removeOnScrollListener(OnScrollListener listener) {
if (mScrollListeners != null) {
mScrollListeners.remove(listener);
} }
public void clearOnScrollListeners() {
if (mScrollListeners != null) {
mScrollListeners.clear();
}
}

然后有滚动事件时便会触发观察者进行方法回调

public abstract static class OnScrollListener {
public void onScrollStateChanged(RecyclerView recyclerView, int newState){}
public void onScrolled(RecyclerView recyclerView, int dx, int dy){}
}
void dispatchOnScrolled(int hresult, int vresult) {
//...
if (mScrollListeners != null) {
for (int i = mScrollListeners.size() - 1; i >= 0; i--) {
mScrollListeners.get(i).onScrolled(this, hresult, vresult);
} } }
void dispatchOnScrollStateChanged(int state) {
//...
if (mScrollListeners != null) {
for (int i = mScrollListeners.size() - 1; i >= 0; i--) {
mScrollListeners.get(i).onScrollStateChanged(this, state);
}
}
}

类似的方法很多很多,都是add监听器系列的方法,这里也不再举例。

还有一个地方就是Android的广播机制,其本质也是观察者模式,这里为了简单方便,直接拿本地广播的代码说明,即LocalBroadcastManager。

我们平时使用本地广播主要就是下面四个方法

LocalBroadcastManager localBroadcastManager=LocalBroadcastManager.getInstance(this);
localBroadcastManager.registerReceiver(BroadcastReceiver receiver, IntentFilter filter);
localBroadcastManager.unregisterReceiver(BroadcastReceiver receiver);
localBroadcastManager.sendBroadcast(Intent intent)

调用registerReceiver方法注册广播,调用unregisterReceiver方法取消注册,之后直接使用sendBroadcast发送广播,发送广播之后,注册的广播会收到对应的广播信息,这就是典型的观察者模式。具体的源代码这里也不贴。

android系统中的观察者模式还有很多很多,有兴趣的自己去挖掘,接下来我们看一下一些开源框架中的观察者模式。一说到开源框架,你首先想到的应该是EventBus。没错,EventBus也是基于观察者模式的。

观察者模式的三个典型方法它都具有,即注册,取消注册,发送事件

EventBus.getDefault().register(Object subscriber);
EventBus.getDefault().unregister(Object subscriber);
EventBus.getDefault().post(Object event);

内部源码也不展开了。接下来看一下重量级的库,它就是RxJava,由于学习曲线的陡峭,这个库让很多人望而止步。

创建一个被观察者

Observable<String> myObservable = Observable.create(
new Observable.OnSubscribe<String>() {
@Override
public void call(Subscriber<? super String> sub) {
sub.onNext("Hello, world!");
sub.onCompleted();
}
}
);

创建一个观察者,也就是订阅者

Subscriber<String> mySubscriber = new Subscriber<String>() {
@Override
public void onNext(String s) { System.out.println(s); }
@Override
public void onCompleted() { }
@Override
public void onError(Throwable e) { }
};

观察者进行事件的订阅

myObservable.subscribe(mySubscriber);  

具体源码也不展开,不过RxJava这个开源库的源码个人还是建议很值得去看一看的。


版权声明:本文为博主原创文章,未经博主允许不得转载。

Android设计模式(十一)-观察者模式

观察者模式是一种使用频率非常高的设计模式,最常用的地方就是订阅-发布系统。这个模式的重要作用就是将观察者和被观察者解耦,使他们之间的依赖更小甚至没有。定义定义对象一种一对多的依赖关系,使得每当一个对象...
  • qq_25806863
  • qq_25806863
  • 2017年04月05日 00:26
  • 679

Android设计模式之观察者模式(Observer Pattern)

观察者模式介绍观察者模式是一个使用率非常高的模式,它最常用的地方就是GUI系统、订阅–发布系统。因为这个模式的一个重要作用就是解耦,将观察者和被观察者解耦,使得它们之间的依赖性更小,甚至做到毫无依赖。...
  • happy_horse
  • happy_horse
  • 2016年05月30日 21:05
  • 1842

设计模式(五)观察者模式

观察者模式(又被称为发布-订阅(Publish/Subscribe)模式,它定义了一种一对多的依赖关系,让多个观察者对象同时监听莫一个主题对象。这个主题对象在状态变化时,会通知所有的观察者对象,使他们...
  • itachi85
  • itachi85
  • 2016年03月02日 17:41
  • 40459

.NET中的设计模式五:观察者模式

 观察者模式(Observer)完美的将观察者和被观察的对象分离开。举个例子,用户界面可以作为一个观察者,业务数据是被观察者,用户界面观察业务数据的变化,发现数据变化后,就显示在界面上。面向对象设计的...
  • mydriverc
  • mydriverc
  • 2007年05月30日 13:47
  • 577

PHP设计模式之观察者模式(Observer)详细介绍和代码实例

【意图】 定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都得到通知并被自动更新【GOF95】 又称为发布-订阅(Publish-Subscribe)模式、模型-视图...
  • longjef
  • longjef
  • 2016年11月02日 09:51
  • 3739

Unity设计模式:观察者模式

初学编程的时候内容比较少没有数据交互,等内容多到需要多个文件多个类协同运行的时候就涉及到类之间的数据交互了。比较简单的数据交互是这些类之间互相引用,直接或间接传值或调用,但是这样类之间的耦合性太高了,...
  • ylbs110
  • ylbs110
  • 2016年12月31日 08:36
  • 545

Java设计模式(观察者模式JDK自带)

JDK自带的观察者模式和我们上一节说的基本相似,也有通用的观察协议规则 Observer,这个接口中只有一个方法,就是update方法 public interface Observer { ...
  • xyjwsj
  • xyjwsj
  • 2017年02月15日 16:47
  • 750

Qt信号槽与观察者模式

qt的核心机制:信号与槽和设计模式中的观察者模式很类似。 https://www.devbean.net/2012/08/qt-study-road-2-custom-signal-slot 这篇...
  • u011391629
  • u011391629
  • 2017年03月20日 21:59
  • 1108

回调函数升级版-设计模式(观察者模式)

书接上回,上一周大体写了一下回调函数的使用,这周我就大体说一下设计模式中的观察者模式。我自己认为观察模式就是回调函数的升级版,在用法上。废话少说,直接上图。 这是我正在弄的一个应用,画面有点模仿荔枝...
  • liujianshui
  • liujianshui
  • 2015年07月07日 14:32
  • 784

JavaScript设计模式--观察者模式

一、定义观察者模式(发布-订阅模式):其定义对象间一种一对多的依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都将得到通知。 在JavaScript中,一般使用事件模型来替代传统的观察者模式...
  • ligang2585116
  • ligang2585116
  • 2015年12月20日 19:22
  • 5103
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:Android中的设计模式——观察者模式
举报原因:
原因补充:

(最多只允许输入30个字)