观察者模式

原创 2012年03月27日 11:57:46

实例场景:

1、爱美之心人皆有之,一个美女在街上走,引起人们所关注,在这个场景中,美女是被观察者,而观察她的人属于观察者,当美女发现有很多观察她的人,然后大声叫了一句:今天真开心,这就会通知观察她的人,人们听到后就感觉到美女被自己关注感到很开心。

 2、在java基础的awt或者swing中,常常有按钮点击事件,当我们给按钮注册一个事件监听器,注册的监听器类实现一个Listener接口,我们没有调用Listener中的方法,那么为什么方法会得到调用呢?难道是自己得到调用?在这个里面就使用了我们的设计模式:观察者模式

观察者模式定义了一种一对多的依赖关系,让多个观察者对象同时监听某一个主题对象,这个主题对象在状态上发生改变的时候,会通知所有的观察者对象,让他们能够自动去更新自己就像场景1

观察者模式的组成

抽象主题角色:把所有对观察者对象的引用保存在一个集合中,每个抽象主题角色都可以有任意数量的观察者。抽象主题提供一个接口,可以增加和删除观察者角色。一般用一个抽象类或接口来实现。

抽象观察者角色:为所有具体的观察者定义一个接口,在得到主题的通知时更新自己。

具体主题角色:在具体主题内部状态改变时,给所有登记过的观察者发出通知。具体主题角色通常用一个子类实现。

具体观察者角色:该角色实现抽象观察者角色所要求的更新接口,以便使本身的状态与主题的状态相协调。如果需要,具体观察者角色可以保存一个指向具体主题角色的引用。通常用一个子类实现。

代码实现模拟:

定义一个抽象的主题角色:

package cn.com.observer;
//定义一个抽象的主题,该主题是一个被观察者
public interface Watched {
	//增加一个观察者
	public void addWatcher(Watcher w);
	//移除一个观察者
	public void removeWatcher(Watcher w);
	//发出一个通知给观察者
	public void notifyWatcher(String str);
}


定义一个抽象的观察者角色:

package cn.com.observer;
//定义一个抽象的观察者
public interface Watcher {
	//观察者得到通知后更新
	public void update(String str);
}

定义一个具体的主题角色:

//具体的被观察者,相当与一个美女
public class ConcreteWatched implements Watched {
	//每个主题可以有很多观察者,就像关注一个美女可以有很多人
	List<Watcher> list=new ArrayList<Watcher>();

	@Override
	public void addWatcher(Watcher w) {
		list.add(w);
	}
	
	@Override
	public void removeWatcher(Watcher w) {
		list.remove(w);

	}

	//当主题发出通知的时候,任何观察者都可以收到通知
	@Override
	public void notifyWatcher(String str) {
		for(Watcher watcher:list){
			watcher.update(str);
		}
	}
}

定义一个具体的观察者角色:

package cn.com.observer;

//定义一个具体的观察者,当得到主题通知的时候,自己更新
public class ConcreteWatcher implements Watcher {

	@Override
	public void update(String str) {
		System.out.println(str);
	}
}

测试类:

//测试类
public class Test {
	public static void main(String[] args) {
		//定义一个美女,主题、被观察者
		Watched girl=new ConcreteWatched();
		//定义多个观察者
		Watcher boy1=new ConcreteWatcher();
		Watcher boy2=new ConcreteWatcher();
		Watcher boy3=new ConcreteWatcher();
		
		//观察者关注美女
		girl.addWatcher(boy1);
		girl.addWatcher(boy2);
		girl.addWatcher(boy3);
		//美女看到有这么多人观察她,大叫一声:今天真高兴
		girl.notifyWatcher("今天真高兴");
		//有一个观察者走了
		girl.removeWatcher(boy2);
		//通知剩下的观察者
		girl.notifyWatcher("唉,少了一个");
	
	}

}

结果会输出:今天真高兴

                      今天真高兴

                       今天真高兴

                        唉,少了一个

                        唉,少了一个

到了这里,大家应该知道了吧,实际上具体观察者不是自己调用自己了,二是被主题所封装调用了,类比我们awt或者swing等那些Listener,一个按钮Button相当与一个主题,也就是我们这里的美女,而我们自定义的实现那些Listener接口的Listener就是观察者,当按钮被点击的时候,按钮会发出通知给相应的Listener,在Button类部执行定义的Listener的方法,所以这里的那些方法是在我们的按钮Button里面被调用了,而不是Listener自己调用。这就是一种观察者模式。
下面我们来模仿awt中的Button,写出我们自己的Button以及事件处理:

定义一个抽象的观察者角色:

/**
 * 定义一个抽象的观察者,由客户端实现其actionPerformed方法
 * 做自己的业务逻辑处理
 * @author dell
 *
 */
public interface ActionListener {
	public void actionPerformed(ActionEvent e);
}

定义一个抽象主题角色 :

/**
 * 定义一个抽象主题角色
 * @author dell
 *
 */
public interface IButton {
	//添加观察者、监听器
	public void addActionListener(ActionListener actionLister);
	//删除观察者、监听器
	public void removeActionListener(ActionListener actionLister);
	//执行的方法,相当于我们的单击Button事件,其中的这个方法由系统调用
	public void processActionEvent(ActionEvent e);
}

定义一个具体的主题,就是我们的Button:

/**
 * 定义一个具体的主题、事件源,用户观察者对象集合
 * @author dell
 *
 */
public class Button implements IButton{
	List<ActionListener> listeners=new ArrayList<ActionListener>();
	@Override
	public void addActionListener(ActionListener actionLister) {
		listeners.add(actionLister);
	}

	@Override
	public void removeActionListener(ActionListener actionLister) {
		listeners.remove(actionLister);
	}
	
	//主题发出通知给各个观察者后,观察者做出自己的响应
	@Override
	public void processActionEvent(ActionEvent e) {
		for(ActionListener listener:listeners){
			listener.actionPerformed(e);
		}
	}
}

客户端进行测试:

public class Client {
	public static void main(String[] args) {
		//定义一个主题、事件源
		IButton button=new Button();
		ActionEvent e=new ActionEvent();
		//给主题添加观察者,让观察者自己去处理主题发出通知后的事情
		button.addActionListener(new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent e) {
				System.out.println("点击按钮,用户登录...");
			}
		});
		button.addActionListener(new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent e) {
				System.out.println("点击按钮,用户注册...");
			}
		});
		//点击按钮,主题发出通知给观察者,在awt或者swing中由用户用鼠标进行点击,由系统调用该方法
		button.processActionEvent(e);
	}
}

如上所示,如果我们系统的主题变了,不是button了,而是TextField了,我们也有processActionEvent事件,那么我们的系统就很容易进行拓展了,而不需要修改很多的源代码,类与类之间的耦合度降低了,符合我们面向对象的开闭原则和依赖倒转原则,下面为了不混淆概念,我们把抽象主题的类改个名称为:IComponent

/**
 * 定义一个抽象主题角色
 * @author dell
 *
 */
public interface IComponent {
	//添加观察者、监听器
	public void addActionListener(ActionListener actionLister);
	//删除观察者、监听器
	public void removeActionListener(ActionListener actionLister);
	//执行的方法,相当于我们的单击Button事件,其中的这个方法由系统调用
	public void processActionEvent(ActionEvent e);
}


然后我们的TextField也有像Button一样的监听者,我们只需要继承IComponent即可:

/**
 * 定义一个具体的主题、事件源,用户观察者对象集合
 * @author dell
 *
 */
public class TextField implements IComponent{
	List<ActionListener> listeners=new ArrayList<ActionListener>();
	@Override
	public void addActionListener(ActionListener actionLister) {
		listeners.add(actionLister);
	}

	@Override
	public void removeActionListener(ActionListener actionLister) {
		listeners.remove(actionLister);
	}
	
	//主题发出通知给各个观察者后,观察者做出自己的响应
	@Override
	public void processActionEvent(ActionEvent e) {
		for(ActionListener listener:listeners){
			listener.actionPerformed(e);
		}
	}
}

测试:

	//修改事件源为TextField
		IComponent textField=new TextField();
		textField.addActionListener(new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent e) {
				System.out.println("点击文本框,用户输入姓名...");
			}
		});
		textField.addActionListener(new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent e) {
				System.out.println("点击文本框,用户输入密码...");
			}
		});
		//点击文本框
		textField.processActionEvent(e);

是不是觉得设计模式很是强大呢,呵呵....大家尝试一下吧!!

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

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

观察者模式(Observer Pattern)(二):HeadFirst中的气象站的实现

一、问题描述 Weather-O-Rama气象站计划建立下一代的Internet气象观察站,该气象站必须建立在WeatherData对象的基础上,WeatherData对象提供天气数据,有三...
  • jialinqiang
  • jialinqiang
  • 2013-05-11 08:51:08
  • 2284

最常见的程序员面试题(12)观察者模式和weak_ptr

观察者模式是非常常用的,写出松耦合框架代码的设计模式。常见的问题是: (1) 如何实现一些列的观察者? A: 用一个EventManager来注册和反注册。 (2) 对于被观察者,如何做到通知观察...
  • zealot_2002
  • zealot_2002
  • 2012-11-30 09:54:22
  • 930

设计模式之观察者模式简单理解

本篇文章总结于马士兵的视频教程《观察者模式》。个人非常推荐马士兵的视频教程,对于初学Java的人来说,J2SE基础视频非常不错,对于内存分析讲的十分到位。对于有一定基础的人来说,设计模式系列,反射系列...
  • sundacheng1989
  • sundacheng1989
  • 2015-12-13 19:16:00
  • 2244

java观察者模式观察者模式

  • 2012年05月06日 23:13
  • 51KB
  • 下载

SpringMVC中的观察者模式

观察者接口Observer public interface Observer { public void execute(Map paras) throws ServerException...
  • u013807095
  • u013807095
  • 2015-01-12 08:49:54
  • 1436

观察者模式的优缺点以及使用场景(三)

观察者模式的效果有以下的优点:第一、观察者模式在被观察者和观察者之间建立一个抽象的耦合。观察者模式有下面的缺点:第一、如果一个被观察者对象有很多的直接和间接的观察者的话,将所有的观察者都通知到会花费很...
  • MNJLJ_23NMK
  • MNJLJ_23NMK
  • 2016-04-21 12:08:41
  • 5056

观察者模式Demo观察者模式Demo观察者模式Demo

  • 2011年07月11日 16:18
  • 2KB
  • 下载

观察者模式2种用法---结合代理模式实现

在安卓的内容提供者ContentProvider,RxJava都运用到了观察者模式 今天来了解并学习下观察者模式,希望在自己编写代码时候,更多的运用此模式什么是观察者模式呢? 我是这样理解观察者模...
  • u013210620
  • u013210620
  • 2016-09-12 13:35:00
  • 972

设计模式之观察者模式与事件委托

观察者模式:定义了一种一对多的依赖关系,让多个观察者对象同时监听某个主题对象。这个主题对象在状态发生变化时,会通知所有观察者对象,使它们能够自己更新自己。         观察者结构模式图:     ...
  • wangdan199112
  • wangdan199112
  • 2014-02-16 21:36:55
  • 2373
收藏助手
不良信息举报
您举报文章:观察者模式
举报原因:
原因补充:

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