java设计模式之观察者模式

1.简介

定义

观察者模式（又被称为发布-订阅（Publish/Subscribe）模式，属于行为型模式的一种，它定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态变化时，会通知所有的观察者对象，使他们能够自动更新自己。

观察者模式结构图

Subject：抽象主题（抽象被观察者），抽象主题角色把所有观察者对象保存在一个集合里，每个主题都可以有任意数量的观察者，抽象主题提供一个接口，可以增加和删除观察者对象。
ConcreteSubject：具体主题（具体被观察者），该角色将有关状态存入具体观察者对象，在具体主题的内部状态发生改变时，给所有注册过的观察者发送通知。
Observer：抽象观察者，是观察者者的抽象类，它定义了一个更新接口，使得在得到主题更改通知时更新自己。
ConcrereObserver：具体观察者，是实现抽象观察者定义的更新接口，以便在得到主题更改通知时更新自身的状态。

2.观察者模式简单实现

当一个对象变化时，其它依赖该对象的对象都会收到通知，并且随着变化！对象之间是一种一对多的关系。先来看看关系图：



这些类的作用：MySubject类就是我们的主对象，Observer1和Observer2是依赖于MySubject的对象，当MySubject变化时，Observer1和Observer2必然变化。AbstractSubject类中定义着需要监控的对象列表，可以对其进行修改：增加或删除被监控对象，且当MySubject变化时，负责通知在列表内存在的对象。我们看实现代码：

Observer：

package com.deppon.tps.module.TestObserverPattern;
public interface Observer {
public void update();
}

ConcrereObserver：

package com.deppon.tps.module.TestObserverPattern;
public class Observer1 implements Observer{
@Override
public void update() {
System.out.println("observer1 has received!");
}
}

package com.deppon.tps.module.TestObserverPattern;
public class Observer2 implements Observer {
@Override
public void update() {
System.out.println("observer2 has received!");
}
}

Subject：

package com.deppon.tps.module.TestObserverPattern;
public interface Subject {
///*增加观察者*/
public void add(Observer observer);
/*删除观察者*/
public void del(Observer observer);
/*通知所有的观察者*/
public void notifyObservers();
/*自身的操作*/
public void operation();
}

ConcreteSubject：

package com.deppon.tps.module.TestObserverPattern;
import java.util.Enumeration;
import java.util.Vector;
public abstract class AbstractSubject implements Subject {
private Vector<Observer> vector = new Vector<Observer>();
@Override
public void add(Observer observer) {
vector.add(observer);
}
@Override
public void del(Observer observer) {
vector.remove(observer);
}
@Override
public void notifyObservers() {
//Enumeration是java.util中的一个接口类，在Enumeration中封装了有关枚举数据集合的方法
Enumeration<Observer> enumo = vector.elements();
while(enumo.hasMoreElements()){
enumo.nextElement().update();
}
}
}

package com.deppon.tps.module.TestObserverPattern;
public class MySubject extends AbstractSubject {
@Override
public void operation() {
System.out.println("update self!");
notifyObservers();
}
}

client:

package com.deppon.tps.module.TestObserverPattern;
public class Test {
public static void main(String[] args) {
MySubject mySubject=new MySubject();
mySubject.add(new Observer1());
mySubject.add(new Observer2());
mySubject.operation();
}
}

测试结果：



<
4000
h3 style="margin:.8em 0px;padding:0px;font-weight:100;color:rgb(85,85,85);font-family:'microsoft yahei';line-height:35px;">
3.场景实例

观察者模式这种发布-订阅的形式我们可以订阅人民日报来举例，假设订阅者是观察者，人民日报是被观察者，有多个的订阅者订阅了这个报纸，只要是订阅了人民日报的人，有了新报纸就会送到订阅者那里去，当你不想订的时候取消就不订阅就不会再收到报纸了。图例如下：



       类图：

       


好了我们来看看用代码如何实现：

package com.deppon.tps.module.TestObserverPattern.example;
public interface InewPaper {
//添加订阅者
void RegisterSubscriber(ISubScribe f_subScribe);
//取消订阅
void RemoveSubScriber(ISubScribe f_subScribe);
//发送报纸
void SendPaper();
}

package com.deppon.tps.module.TestObserverPattern.example;
public interface ISubScribe {
//有新的报纸了就会被执行通知
void HasNewPaper();
}

package com.deppon.tps.module.TestObserverPattern.example;
import java.util.ArrayList;
import java.util.List;
public class PeopleNewsPaper implements InewPaper{
private List<ISubScribe> subList = new ArrayList<ISubScribe>();
@Override
public void RegisterSubscriber(ISubScribe f_subScribe) {
subList.add(f_subScribe);
}
@Override
public void RemoveSubScriber(ISubScribe f_subScribe) {
if (subList.contains(f_subScribe)){
subList.remove(f_subScribe);
}
}
@Override
public void SendPaper() {
for(int i=0;i<subList.size();i++){
subList.get(i).HasNewPaper();
}
}
}

package com.deppon.tps.module.TestObserverPattern.example;
public class SubHuman implements ISubScribe{
private String peopleName;
public SubHuman(String peopleName){
this.peopleName=peopleName;
}
@Override
public void HasNewPaper() {
System.out.println(peopleName+"：您有新的报纸了！");
}
}

client:

package com.deppon.tps.module.TestObserverPattern.example;
public class Test {
public static void main(String[] arg){
PeopleNewsPaper paper = new PeopleNewsPaper();
SubHuman _XiaoMing = new SubHuman("小明");
SubHuman _ZhaoYun = new SubHuman("赵云");
SubHuman _LiuBei = new SubHuman("刘备");
//小明订报
paper.RegisterSubscriber(_XiaoMing);
//赵云订报
paper.RegisterSubscriber(_ZhaoYun);
//刘备订报
paper.RegisterSubscriber(_LiuBei);
//有新报纸了
paper.SendPaper();
System.out.println("---------------发完报纸了------------------");
//小明不想订了，取消报纸
paper.RemoveSubScriber(_XiaoMing);
//又有新报纸了  就没有小明的报纸 了
paper.SendPaper();
}
}

结果：

4.使用观察者模式的场景和优缺点

使用场景

关联行为场景，需要注意的是，关联行为是可拆分的，而不是“组合”关系。
事件多级触发场景。
跨系统的消息交换场景，如消息队列、事件总线的处理机制。

优点

解除耦合，让耦合的双方都依赖于抽象，从而使得各自的变换都不会影响另一边的变换。

缺点

在应用观察者模式时需要考虑一下开发效率和运行效率的问题，程序中包括一个被观察者、多个观察者，开发、调试等内容会比较复杂，而且在Java中消息的通知一般是顺序执行，那么一个观察者卡顿，会影响整体的执行效率，在这种情况下，一般会采用异步实现。