引子
还记得警匪片上,匪徒们是怎么配合实施犯罪的吗?一个团伙在进行行动的时候,总
有一两个人在门口把风——如果有什么风吹草动,则会立即通知里面的同伙紧急撤退。也许放风的人并不一定认识里面的每一个同伙;而在里面也许有新来的小弟不认识这个放风的。但是这没什么,这个影响不了他们之间的通讯,因为他们之间有早已商定好的暗号。
呵呵,上面提到的放风者、偷窃者之间的关系就是观察者模式在现实中的活生生的例子。
二、
定义与结构
观察者(Observer)模式又名发布-订阅(Publish/Subscribe)模式。GOF给观察者模式如下定义:定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都得到通知并被自动更新。
在这里先讲一下面向对象设计的一个重要原则——单一职责原则。因此系统的每个对象应该将重点放在问题域中的离散抽象上。因此理想的情况下,一个对象只做一件事情。这样在开发中也就带来了诸多的好处:提供了重用性和维护性,也是进行重构的良好的基础。
因此几乎所有的设计模式都是基于这个基本的设计原则来的。观察者模式的起源我觉得应该是在GUI和业务数据的处理上,因为现在绝大多数讲解观察者模式的例子都是这一题材。但是观察者模式的应用决不仅限于此一方面。
下面我们就来看看观察者模式的组成部分。
1)
抽象目标角色(Subject):目标角色知道它的观察者,可以有任意多个观察者观察同一个目标。并且提供注册和删除观察者对象的接口。目标角色往往由抽象类或者接口来实现。
2)
抽象观察者角色(Observer):为那些在目标发生改变时需要获得通知的对象定义一个更新接口。抽象观察者角色主要由抽象类或者接口来实现。
3)
具体目标角色(Concrete Subject):将有关状态存入各个Concrete Observer对象。当它的状态发生改变时, 向它的各个观察者发出通知。
4)
具体观察者角色(Concrete Observer):存储有关状态,这些状态应与目标的状态保持一致。实现Observer的更新接口以使自身状态与目标的状态保持一致。在本角色内也可以维护一个指向Concrete Subject对象的引用。
放上观察者模式的类图,这样能将关系清晰的表达出来。
可以看得出来,在Subject这个抽象类中,提供了上面提到的功能,而且存在一个通知方法:notify。还可以看出来Subject和ConcreteSubject之间可以说是使用了模板模式(这个模式真是简单普遍到一不小心就用到了)。
这样当具体目标角色的状态发生改变,按照约定则会去调用通知方法,在这个方法中则会根据目标角色中注册的观察者名单来逐个调用相应的update方法来调整观察者的状态。这样观察者模式就走完了一个流程。
为了便于理解,首先我举一个现实生活中的例子:在快乐男生比赛过程其实就是观察者的一个体现,可以这样说吉杰是一个被观察者,而杨二,包小柏,还有巫启贤就是3个观察者,被观察者操作(唱歌)时,观察者们就开始操作(评分),被观察者唱歌就是通知观察者们进行评分。
GoF说道:Observer模式的意图是“定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都得到通知并被自动更新”。从这段话里我们可以得到两个信息,如下:
1, 观察者(具体执行操作的对象,有多个)
2, 被观察者(顾名思义是被观察的对象,如果该对象发生某些变化则通知观察者执行对应的操)
接下来我们看一下附件中的图(请下载附件中的图 http://www.iteye.com/topics/download/eed23def-b8a8-43dc-a753-73d740a3ded0
),这个图是观察者模式的真实体现,在这个图中有两个类,java.util.Observable,在我们实现观察者模式的时候,我们的被观察者应该继承这个类,这个observable类把持住了被观察者所持有的观察者列表:
public class Observable {
private boolean changed = false;
private Vector obs;
//创建被观察者时就创建一个它持有的观察者列表,注意,这个列表是需要同步的。
public Observable() {
obs = new Vector();
}
/**
* 添加观察者到观察者列表中去
*/
public synchronized void addObserver(Observer o) {
if (o == null)
throw new NullPointerException();
if (!obs.contains(o)) {
obs.addElement(o);
}
}
/**
* 删除一个观察者
*/
public synchronized void deleteObserver(Observer o) {
obs.removeElement(o);
}
/**
* 通知操作,即被观察者发生变化,通知对应的观察者进行事先设定的操作,不传参数的通知方法
*/
public void notifyObservers() {
notifyObservers(null);
}
/**
* 与上面的那个通知方法不同的是,这个方法接受一个参数,这个参数一直传到观察者里,以供观察者使用
*/
public void notifyObservers(Object arg) {
Object[] arrLocal;
synchronized (this) {
if (!changed)
return;
arrLocal = obs.toArray();
clearChanged();
}
for (int i = arrLocal.length-1; i>=0; i--)
((Observer)arrLocal[i]).update(this, arg);
}
}
这里只列出了一些常用的操作,大家如有不明白可以自己看java.util包下的Observable,每一个方法前都有详细的解释。但是以上列出的方法对于这个例子来说已经够用了。
当我们自己的被观察者继承这个Observable类是,我们就自动的获取到被观察者的一切条件了。很方便是不是,这也是为什么sun要把Observable放到java.util包中的原因,就是为了方便开发者。
讲完了被观察者再让我们来看看观察者,在上面的代码中有一个addObserver(Observer
o)方法,由此我们可以看出来,给被观察者添加观察者时就是用这个方法,那么也就是说观察者一定是Observer的子类或者实现,我们看一下
java.util.Observer吧:
public interface Observer {
/**
* This method is called whenever the observed object is changed. An
* application calls an <tt>Observable</tt> object's
* <code>notifyObservers</code> method to have all the object's
* observers notified of the change.
*
* @param o the observable object.
* @param arg an argument passed to the <code>notifyObservers</code>
* method.
*/
void update(Observable o, Object arg);
}
}
很好,这是一个接口,接口中就只有一个方法,update,方法中有两个参数,Observable和一个object,第一个参数就是被观察的对象,而
第二个参数就得看业务需求了,需要什么就传进去什么。我们自己的观察者类必须实现这个方法,这样在被观察者调用notifyObservers操作时被观
察者所持有的所有观察者都会执行update操作了(当然如果你override这个方法,你甚至可以指定何种情况下只执行某种observer了,是不
是比较像责任链模式了)。
那么到这里我们也差不多可以把观察者模式应用到项目中去了。首先让我们来实现被观察者(因为实现被观察者非常简单)
首先让我们来实现一个发送邮件的观察者:
/**
* @author 张荣华(ahuaxuan)
* @version $Id$
*/
public class MailObserver implements Observer{
/**
* 这个类取名为MailObserver,顾名思义,她是一个用来发送邮件的观察者
*/
public void update(Observable o, Object arg) {
System.out.println("发送邮件的观察者已经被执行");
}
}
接着再让我们来实现一个发送jms消息的观察者:
/**
* @author 张荣华(ahuaxuan)
* @version $Id$
*/
public class JMSObserver implements Observer{
public void update(Observable o, Object arg) {
System.out.println("发送消息给jms服务器的观察者已经被执行");
}
}
如上所见,观察者的实现完全跟业务相关。是否复杂就得看你得业务是否复杂了。
接下来让我们再来实现被观察者,示例如下:
/**
* @author 张荣华(ahuaxuan)
* @version $Id$
*/
public class Subject extends Observable{
/**
* 业务方法,一旦执行某个操作,则通知观察者
*/
public void doBusiness(){
if (true) {
super.setChanged();
}
notifyObservers("现在还没有的参数");
}
public static void main(String [] args) {
//创建一个被观察者
Subject subject = new Subject();
//创建两个观察者
Observer mailObserver = new MailObserver();
Observer jmsObserver = new JMSObserver();
//把两个观察者加到被观察者列表中
subject.addObserver(mailObserver);
subject.addObserver(jmsObserver);
//执行业务操作
subject.doBusiness();
}
}
到此为止,我们已经简单得实现了观察者模式,让我们来运行一下上面main方法,运行结果如下:
发送消息给jms服务器的观察者已经被执行
发送邮件的观察者已经被执行
有了jdk对观察者模式的支持,程序员在实现基本的观察者模式时应该说是易如反掌,这也从一个侧面反应出观察者模式的地位,它的地位应该是非常重要的,引用Nicholas Lesiecki(此人是上面所指的ibm那篇文章的作者)的话说,它是“设计模式中的皇后”。
通过上面的介绍和简单的实例,现在你也可以实现一个自己的观察者了(有时候这个简单的模型并不满足我们的需要,在这种情况下只好自己去写一个类似
的但是是为业务定制的observable和observer类了,但显然这中情况并不常见)。事实上spring对观察者模式也有很好的支持
(spring可以通过配置文件来执行addobserver方法,这样就可以隐式的把观察者加到被观察者的列表中去了,前提是你的被观察者是
spring管理的一个bean之一,详见3楼回复,或者也可以利用afterPropertiesSet方法在被观察者这个bean初始化完成之后立刻
把需要的观察者添加进去),除了spring,hibernate中也大量的使用了观察者模式,同时,如果你想再深入一点,可以看看本文第二段给的ibm
技术文章的链接。
转自:http://www.iteye.com/topic/102068/
分享到:
相关推荐
本文将深入探讨Java内置的观察者模式,包括其原理、实现方式以及实际应用。 ### 观察者模式的核心概念 1. **主题(Subject)**:被观察的对象,也就是发出通知的一方。在Java中,通常通过实现`java.util....
观察者模式是设计模式中的一种行为模式,它在Java编程中有着广泛的应用。该模式的主要目的是定义对象之间的一对多依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都会得到通知并自动更新。这种模式也被...
在Java中,观察者模式的实现通常基于Java的内置接口`java.util.Observer`和`java.util.Observable`。下面将详细解释观察者模式的概念、结构以及如何在Java中应用这个模式。 **观察者模式的核心概念:** 1. **主题...
标题中的“java观察者模式Demo”指的是使用Java语言来演示观察者模式的应用。通常,这个Demo会包含一个可观察的对象(Observable)和多个观察者(Observer),当可观察对象的状态发生变化时,会触发通知机制,使得...
在Java中,观察者模式通常通过`java.util.Observable`和`java.util.Observer`这两个接口来实现。`Observable`类代表被观察的对象,它可以添加多个观察者,并在状态变化时通知它们。而`Observer`接口则定义了观察者的...
观察者模式,也被称为发布-订阅(Publish-Subscribe)模式,是软件设计模式中的行为模式之一,主要用于对象间的一对多依赖关系管理。在Java中,观察者模式的实现主要依赖于`java.util.Observable`和`java.util....
Java观察者模式是一种设计模式,它定义了对象之间的一对多依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都会得到通知并自动更新。这种模式在软件工程中广泛应用,尤其在事件驱动和发布/订阅系统中。...
在Java中,观察者模式通常通过Java内置的`java.util.Observable`类和`java.util.Observer`接口来实现。`Observable`类代表被观察的对象,它可以有多个观察者,而`Observer`接口则定义了观察者的通用行为。 首先,...
以下是一个简单的Java观察者模式的示例: ```java import java.util.Observable; import java.util.Observer; class WeatherData implements Observable { private float temperature; private float humidity; ...
在Java中,观察者模式可以通过Java的内置API `java.util.Observable` 和 `java.util.Observer` 类来实现。`Observable` 类代表被观察的对象,而 `Observer` 接口则表示观察者。以下是对这两个关键类的详细解释: 1....
在Java中,我们可以利用Java提供的内置监听器机制来实现观察者模式,例如`ApplicationListener`和`ApplicationEvent`,这两个类主要用于Swing或JavaFX应用程序中的事件处理。 首先,我们来看`ApplicationListener`...
### Java观察者模式详解 #### 一、观察者模式概述 观察者模式是一种常用的设计模式,主要用于处理对象间的一对多依赖关系。当一个对象(主题)的状态发生变化时,所有依赖于它的对象(观察者)都会收到通知并自动...
在这个名为“运用MVC模式及观察者模式的java小程序”的项目中,我们重点探讨了两种经典的设计模式:Model-View-Controller(MVC)模式和Observer(观察者)模式。这两种模式在JavaWeb开发中扮演着至关重要的角色。 ...
**观察者模式(Observer Pattern)**是软件设计模式中的一种行为模式,它在Java中有着广泛的应用。这个模式的核心思想是“一对多”的依赖关系,即一个主题对象(Subject)可以被多个观察者(Observer)关注,当主题...
在Java中,观察者模式可以通过Java的内置接口`java.util.Observer`和`java.util.Observable`来实现。`Observer`接口代表观察者,而`Observable`类代表被观察的对象,也称为主题(Subject)。下面将详细介绍这两个...
总结来说,这个"java观察者模式实例"帮助我们理解如何在实际项目中应用观察者模式,以及如何利用Java的`Observable`和`Observer`接口来实现。通过这个实例,我们可以更好地掌握Java的继承和多态特性,提升软件设计的...
以下是一个简单的Java观察者模式案例: ```java import java.util.ArrayList; import java.util.List; // 主题类(被观察者) class ObservableSubject extends Observable { private String state; public ...
在Java中,`java.util.Observable`类和`java.util.Observer`接口提供了对观察者模式的支持。 1. **`Observable`类**:代表被观察的对象,可以注册多个观察者,并在状态改变时通知它们。`Observable`类提供了`...
在Java中,观察者模式的实现主要依赖于`java.util.Observable`类和`java.util.Observer`接口。`Observable`类代表被观察的对象,而`Observer`接口则表示观察者。下面我们将详细介绍如何在Java中实现观察者模式。 1....