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();
	}
}

测试结果：

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中消息的通知一般是顺序执行，那么一个观察者卡顿，会影响整体的执行效率，在这种情况下，一般会采用异步实现。