什么是观察者模式:
定义了对象之间的一对多依赖,这样一来,当主题对象改变状态时,它的所有依赖者都会收到通知并自动更新。
这就好比订阅报纸,我们知道出版社每天都要出版报纸(主题Subject),如果你(观察者Observer)订阅了报纸,那么出版社一旦出版了报纸,就会给每个订阅过报纸的用户派发一份报纸。如果你不想要了,随时可以取消订阅,那么下次出版社就不会派发报纸给你了,就这么简单。
设计原则:
为了交互对象之间的松耦合设计而努力。即主题和观察者之间的松耦合。
这里先了解下两个概念:
主题
Subject
,也叫Observable
,可观察者
。当数据有变化通过它来通知所有注册了的观察者
Observer
。
那么这一切该如何实现呢?
我们先来看看效果图
说明下:这里的SeekBar起到的作用是模拟数据更新变化的作用,当然需要你来滑动它。当它的数据变化的时候,告诉主题,再由主题负责通知主题所维护的每个观察者(Button),来更新数据。你可以这样看,实际上主题在这充当了桥梁的作用,负责变化的数据源和Button之间的沟通。
我们再来看看项目的结构:
这里我定义了两个接口,一个是为主题定义的,一个是为观察者定义的。
Observable.java:
/**
* 主题接口,也就是起到java.util.Observable这个类的作用
*
* */
public interface Observable {
void addObserver(Observer observer);
void deleteObserver(Observer observer);
void notifyObservers(int progress);
}
这个接口的目的是为了维护观察者对象,这里的维护包括了添加,取消,通知。
Observer.java:
public interface Observer {
void update(int degree);
}
就一个方法,负责更新主题传递过来的数据。
下面我们看看如何实现这两个接口:
主题接口的实现ObservableImpl.java:
public class ObservableImpl implements Observable{
private List<Observer> observerList;//这个List维护着观察者的注册和取消注册
public ObservableImpl() {
observerList = new ArrayList<Observer>();
}
/**
* 注册监听
*
* */
@Override
public void addObserver(Observer observer) {
observerList.add(observer);
}
/**
* 取消监听
*
* */
@Override
public void deleteObserver(Observer observer) {
int index = observerList.indexOf(observer);
if(index >= 0)
{
observerList.remove(index);
}
}
/**
* 通知所有的观察者改变数据
*
* */
@Override
public void notifyObservers(int progress) {
for (Observer observer : observerList) {
observer.update(progress);
}
}
/**
* SeekBar通过这个方法与Subject进行交互
* 当然,通过notifyObservers也是一样的。
*
* */
public void setData(int progress)
{
notifyObservers(progress);
}
}
观察者接口的实现ObserverButton.java:
public class ObserverButton extends Button implements Observer{
public ObserverButton(Context context, AttributeSet attrs, int defStyle) {
super(context, attrs, defStyle);
}
public ObserverButton(Context context, AttributeSet attrs) {
super(context, attrs);
}
public ObserverButton(Context context) {
super(context);
}
/**
* 将本类注册成为一个观察者,本来这个最好是在构造器中进行,但是由于构造器的参数限制,因此写一个方法用来注册
* 这个方法需要首先被调用
*
* */
public void registerObserver(Observable observable)
{
observable.addObserver(this);
}
/**
* 取消监听
*
* */
public void unRegisterObserver(Observable observable)
{
observable.deleteObserver(this);
}
/**
* 对主题的改变进行处理
*
* */
@Override
public void update(int degree) {
this.setText("" + degree);
}
}
MainActivity.java:
/**
* 自己实现的观察者模式,效果类似于java API中的Observable类
*
*
* */
public class MainActivity extends Activity {
private SeekBar sbDataChanger;
private ObservableImpl subjectImpl;
private ObserverButton btnObserverOne;
private ObserverButton btnObserverTwo;
private ObserverButton btnObserverThree;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
subjectImpl = new ObservableImpl();
sbDataChanger = (SeekBar)findViewById(R.id.sb_data_changer);
btnObserverOne = (ObserverButton )findViewById(R.id.btn_observer_one);
btnObserverTwo = (ObserverButton )findViewById(R.id.btn_observer_two);
btnObserverThree = (ObserverButton )findViewById(R.id.btn_observer_three);
//这里需要在3个按钮被实例化的时候都调用registerObserver(Observable observable)方法
//一便一开始就实现监听,本来这个是要放在构造器中来做的,但是Button的构造器不能自定义,因此放在这里来调用
btnObserverOne.registerObserver(subjectImpl);
btnObserverTwo.registerObserver(subjectImpl);
btnObserverThree.registerObserver(subjectImpl);
sbDataChanger.setOnSeekBarChangeListener(new OnSeekBarChangeListener() {
@Override
public void onStopTrackingTouch(SeekBar seekBar) {
}
@Override
public void onStartTrackingTouch(SeekBar seekBar) {
}
@Override
public void onProgressChanged(SeekBar seekBar, int progress,
boolean fromUser) {
// SeekBar在这个地方与主题进行交互
//当SeekBar的progress改变的时候,主题中的数据也改变,主题再对所有监听了该主题的观察者一一通知,从而达到改变数据的目的
//主题在这个地方相对于桥梁的作用,不仅这样,它还负责观察者的注册和取消注册
subjectImpl.setData(progress);
}
});
btnObserverOne.setOnClickListener(clickListener);
btnObserverTwo.setOnClickListener(clickListener);
btnObserverThree.setOnClickListener(clickListener);
}
private View.OnClickListener clickListener = new View.OnClickListener() {
@Override
public void onClick(View v) {
switch (v.getId()) {
case R.id.btn_observer_one:
cancelRegister(v);
break;
case R.id.btn_observer_two:
cancelRegister(v);
break;
case R.id.btn_observer_three:
cancelRegister(v);
break;
default:
break;
}
}
};
/**
* 取消监听
*
* */
private void cancelRegister(View view)
{
ObserverButton observerButton = (ObserverButton)view;
observerButton.unRegisterObserver((Observable)subjectImpl);
Toast.makeText(this, "一个按钮取消了监听", Toast.LENGTH_SHORT).show();
}
}
这样我们自定义的一个观察者模式就实现了。
当然这样的做法利于对象之间的松耦合,可是每次为了实现观察者都需要大量的代码量,未免太麻烦了,因此java语言中提供了内置的类和接口供你方便地使用观察者模式。
主题:java.util.Observable;
观察者:java.util.Observer;
注意主题Observable是一个类,而不是接口!Observer是接口。这也就是说,如果你的主题对象已经继承自别的类,那么就限制了你使用java所提供的Observable类,你就不得不按照上面的做法来实现观察者模式了。
下面看看工程结构:
主题:ObservableImpl.java:
/**
* 这个类继承自java.util.Observable,注意:这个类是一个类,而不是接口
* 这个是java API提供的类,我们就不需要自己去实现观察者对象的管理了,即不需要使用List来管理以及发送通知了。
*
* 但是这个类最大的缺点就是它是一个类,而不是接口,扩展性较差
*
* */
public class ObservableImpl extends Observable{
int progress = 0;
/**
* SeekBar通过这个方法与Subject进行交互
*
* */
public void setData(int progress)
{
this.progress = progress;
setChanged();//在调用notifyObservers方法之前,这个方法一定要调用!否则没有效果!看看源码就知道了,这里有一个boolean标志位
notifyObservers(progress);
}
/**
* 供“拉”方法取数据
*
* */
public int getProgress()
{
return this.progress;
}
}
观察者:ObserverButton.java:
/**
* 实现的是java。util.Observer这个接口,而不是自定义的接口
* 这个接口提供了一个update方法,用来接收主题传递过来的数据
*
* */
public class ObserverButton extends Button implements Observer{
public ObserverButton(Context context, AttributeSet attrs, int defStyle) {
super(context, attrs, defStyle);
}
public ObserverButton(Context context, AttributeSet attrs) {
super(context, attrs);
}
public ObserverButton(Context context) {
super(context);
}
private int progress = 0;
/**
* 将本类注册成为一个观察者,本来这个最好是在构造器中进行,但是由于构造器的参数限制,因此写一个方法用来注册
* 这个方法需要首先被调用
*
* */
public void registerObserver(Observable observable)
{
observable.addObserver(this);
}
/**
* 取消监听
*
* */
public void unRegisterObserver(Observable observable)
{
observable.deleteObserver(this);
}
/**
* 这里接收主题的通知
*
* */
@Override
public void update(Observable arg0, Object arg1) {
//这个是“拉”方法
if(arg0 instanceof ObservableImpl){
ObservableImpl subjectImpl = (ObservableImpl)arg0;
this.progress = subjectImpl.getProgress();//需要自己去主题中取数据
display();
}
//这个是“推”方法
// if(arg1 instanceof Integer){
//
// this.progress = (Integer)arg1;
// display();
// }
}
/**
* 显示数据
*
* */
private void display()
{
this.setText(""+progress);
}
}
MainActivity.java和第一种方法差不多,这里就不贴出来了。
可见让java语言提供的类来实现观察者确实可以省下不少的代码量,但是正如前面所说的。由于主题是一个类,这难免影响了主题类的扩展。所以,当你的主题没有从别的类继承,那么推荐你使用系统提供的Observable主题,如果你的主题已经继承自别的类,那么你就必须自己实现观察者了。
还需要解释下什么是“推”方法,什么是“拉”方法。看下面代码:
@Override
public void update(Observable arg0, Object arg1) {
//这个是“拉”方法
if(arg0 instanceof ObservableImpl){
ObservableImpl subjectImpl = (ObservableImpl)arg0;
this.progress = subjectImpl.getProgress();//需要自己去主题中取数据
display();
}
//这个是“推”方法
// if(arg1 instanceof Integer){
//
// this.progress = (Integer)arg1;
// display();
// }
}
其实就是在update方法中,对参数的处理不太一样而已,update方法中将主题对象的引用和数据对象传递过来。通过主题对象的引用来调用getter方法,称为“拉”方法,而直接获取并使用传递过来的数据,称为“推”方法。这个很形象,应该不难理解。
当然,我在自定义的观察者模式中使用的是推方法,即直接将数据传递过去。并没有实现拉方法,你也可以自己加上去。多个参数而已。
下面是使用java内置观察者达到的效果,也自定义的没有什么区别:
我将这两个工程放到github上,有兴趣的同学可以下载看看:
https://github.com/michaelye/ObserverPattern
自定义观察者模式
https://github.com/michaelye/ObserverPattern_JavaUtil
使用java内置的观察者模式
- 大小: 185.9 KB
- 大小: 149.2 KB
- 大小: 31.2 KB
- 大小: 28.1 KB
分享到:
相关推荐
观察者模式是一种行为设计模式,它允许你定义一个订阅机制,可以在对象事件发生时通知多个“观察”该对象的其他对象。这个模式的核心在于建立一种一对多的关系,当一个对象的状态改变时,所有依赖于它的对象都会得到...
观察者模式(Observer Pattern)是软件设计模式中的一种行为模式,它定义了对象之间的一对多依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都会得到通知并自动更新。这种模式常用于实现发布-订阅...
观察者模式(Observer Pattern)是软件设计模式中的一种行为模式,它定义了对象之间的一对多依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都会得到通知并自动更新。这种模式常用于实现事件驱动或者发布...
本篇文章将深入探讨Qt中的观察者模式(Observer Pattern),这是一种行为设计模式,它定义了对象之间的一对多依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都会得到通知并自动更新。 观察者模式的核心...
观察者模式是设计模式中的一种行为模式,它在Java编程中有着广泛的应用。该模式的主要目的是定义对象之间的一对多依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都会得到通知并自动更新。这种模式也被...
观察者模式,也被称为发布-订阅模式,是软件设计中的一种行为模式,它定义了对象之间的一对多依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都会得到通知并自动更新。这种模式在分布式系统、事件驱动...
观察者模式(Observer Pattern)是设计模式中的一种行为模式,它允许一个对象,当其状态发生改变时,能够自动通知所有依赖它的其他对象。在Java中,这种模式已经被内置到语言核心,使得开发者可以轻松地实现事件驱动...
观察者模式(Observer Pattern)是软件设计模式中的一种行为模式,它定义了对象之间的一对多依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都会得到通知并自动更新。这种模式常用于事件驱动的系统或者...
观察者模式(Observer Pattern)是设计模式中的一种行为模式,它定义了对象之间的一对多依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都会得到通知并被自动更新。这种模式常用于实现事件驱动的系统或者...
观察者模式(Observer Pattern)是软件设计模式中的一种行为模式,它定义了对象之间的一对多依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都会得到通知并自动更新。这种模式常用于事件驱动的系统或者...
在这个名为“运用MVC模式及观察者模式的java小程序”的项目中,我们重点探讨了两种经典的设计模式:Model-View-Controller(MVC)模式和Observer(观察者)模式。这两种模式在JavaWeb开发中扮演着至关重要的角色。 ...
观察者模式,也被称为发布-订阅(Publish-Subscribe)模式,是软件设计中的一种行为模式。在iOS开发中,它是一种让多个对象监听或订阅某一个主题对象的状态变化,并在状态变化时自动收到通知的方式。这种模式使得...
观察者模式详解 观察者模式(Observer Design Pattern)是行为型设计模式的一种,主要解决的是“类或对象之间的交互”问题。它定义了一个一对多的依赖关系,当一个对象的状态改变时,所有依赖的对象都会自动收到...
观察者模式(Observer Pattern)是一种行为设计模式,它允许你定义一个订阅机制,可以在对象状态改变时通知多个“观察”该对象的其他对象。在这个"股票分析程序"中,我们很显然看到它利用了这种模式来实时更新股票...
观察者模式是面向对象设计中的一种经典模式,它在软件工程中扮演着重要的角色,用于实现对象间的松耦合。这种模式定义了对象之间的一对多依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都会得到通知并...
观察者模式(Observer Pattern)是设计模式中的一种行为模式,它定义了对象之间的一对多依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都会得到通知并被自动更新。这种模式常用于事件驱动的系统或者实时...
观察者模式是一种行为设计模式,它允许你定义一个订阅机制,可以在对象状态改变时通知多个“观察”该对象的其他对象。在Java或其他面向对象语言中,这种模式通常用于实现事件处理或发布/订阅系统。在给定的“观察者...
观察者模式(Observer Pattern)是软件设计模式中的一种行为模式,它定义了对象之间的一对多依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都会得到通知并自动更新。这种模式常用于事件驱动的系统或者...
### Unity3D设计模式之观察者模式 #### 观察者模式概述 观察者模式(Observer Pattern)是一种软件设计模式,属于行为型模式之一。它定义了对象间的一种一对多依赖关系,当一个对象的状态发生改变时,所有依赖于它...
### 观察者模式概述与应用 #### 一、观察者模式定义 观察者模式是一种常用的软件设计模式,主要用于处理对象间的依赖关系。在这种模式下,一个对象(称为“主题”或“被观察者”)负责维护一组依赖于它的对象...