设计模式---观察者模式(Observer Pattern with java)

概述

观察者模式(有时又被称为发布/订阅模式)是软体设计模式的一种。在此种模式中，一个目标物件管理所有相依于它的观察者物件，并且在它本身的状态改变时主动发出通知。这通常透过呼叫各观察者所提供的方法来实现。此种模式通常被用来实作事件处理系统。

 

先看一个例子

有个小孩在睡觉，醒来之后要喂奶。

我们使用的是java，所以不要闹出下面的笑话（披着面向对象的面向过程）：

public class Simulation {
	public static void main(String... args) {
		//小孩睡觉
		//起来之后爸爸喂奶
		//...
	}
}

 

我们根据面向对象思想，加上多线程模拟Child和Dad，小孩在睡觉，随时可以起来，Dad隔一段时间看下小孩是否醒来。

package observer;
import java.util.Random;
class Child implements Runnable {
	public static Random r = new Random();
	private boolean wake = false;
	public Child() {
		new Thread(this).start();
	}
	@Override
	public void run() {
		while (!wake) {
			System.out.println("Child:I am sleeping...");
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			if (r.nextInt(10) > 8) {
				wakeUp();
			}
		}
	}
	public void wakeUp() {
		wake = true;
	}
	public boolean isWake() {
		return wake;
	}
}

class Dad implements Runnable {
	private Child c;
	public Dad(Child c) {
		new Thread(this).start();
		this.c = c;
	}
	@Override
	public void run() {
		while (!c.isWake()) {
			System.out.println("Dad:child is sleeping...");
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		feed(c);
	}
	private void feed(Child c2) {
		System.out.println("feed child!");
	}
}

public class FirstQuestion {
	public static void main(String[] args) {
		new Dad(new Child());
	}
}

这样可以实现功能，但造成资源的浪费。开了这么多线程，Dad时间都用在看小孩身上了,Dad下午打牌的计划泡汤了。我们可以很容易的把Dad解放出来：

class Child implements Runnable {
	public static Random r = new Random();
	private Dad d;
	private boolean wake = false;
	public Child(Dad d) {
		this.d = d;
	}
	@Override
	public void run() {
		while (!wake) {
			System.out.println("Child:I am sleeping...");
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			if (r.nextInt(10) > 8) {
				wakeUp();
			}
		}
	}
	public void wakeUp() {
		wake = true;
		d.feed(this);
	}
	public boolean isWake() {
		return wake;
	}
}
class Dad {
	public void feed(Child c) {
		System.out.println("feed child!");
	}

}
public class FirstQuestion {
	public static void main(String[] args) {
		new Thread(new Child(new Dad())).start();
	}
}

这样基本已经实现功能，稍微完善下，假如想知道小孩什么时候起来等一些信息，如果我们写在小孩类中就不太合适，所以我们抽象出类中WakenUpEvent:

class WakenUpEvent {
	private Date date;
	private String loc;
	private Dad dad;
	public WakenUpEvent(Date date, String loc, Dad dad) {
		super();
		this.date = date;
		this.loc = loc;
		this.dad = dad;
	}
}
class Child implements Runnable {
	private Dad d;
	public Child(Dad d) {
		this.d = d;
	}
	@Override
	public void run() {
		try {
			Thread.sleep(5000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		wakeUp();
	}
	public void wakeUp() {
		d.actionToWakenUp(new WakenUpEvent(new Date(), "child", d));
	}
}

class Dad {
	public void actionToWakenUp(WakenUpEvent wakenUpEvent) {
		System.out.println("child feed!");
	}
}
public class FirstQuestion {
	public static void main(String[] args) {
		new Thread(new Child(new Dad())).start();
	}
}

 

这样Dad可以做自己事，只要听到孩子声音，就过来喂奶。似乎问题已经解决，假如小孩醒后，小孩的爷爷想抱下，小孩家的小狗要叫下，等等，如果按照上面的设计，小孩需要持有爷爷GrandFather、狗Dog等的引用，再调用用响应的处理方法…需要修改较大的篇幅。实际上我们可以在小孩中使用一个集合存储所有监听小孩的对象，当小孩醒后，小孩依次调用监听者处理方法。要实现统一的接口，以可以被小孩监听器集合引用和调用相应方法，我们使用接口interface。

class WakenUpEvent {
	private Date date;
	private String eventType;
	private Object source;
	public WakenUpEvent(Date date, String eventType, Object source) {
		this.date = date;
		this.eventType = eventType;
		this.source = source;
	}
}

class Child implements Runnable {
	private List<WakenUpListener> list = new ArrayList<WakenUpListener>();
	public void addWakenUpListener(WakenUpListener l) {
		list.add(l);
	}
	@Override
	public void run() {
		System.out.println("child is sleeping...");
		try {
			Thread.sleep(2000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		wakeUp();
	}
	public void wakeUp() {
		for (WakenUpListener l : list) {
			l.actionWakenUp(new WakenUpEvent(new Date(), "", this));
		}
	}
}
interface WakenUpListener {
	void actionWakenUp(WakenUpEvent e);
}
class Dad implements WakenUpListener {
	@Override
	public void actionWakenUp(WakenUpEvent e) {
		System.out.println("dad feed child!");
	}
}
class GrandFather implements WakenUpListener {
	@Override
	public void actionWakenUp(WakenUpEvent e) {
		System.out.println("grandfather holl child!");
	}
}
public class FirstQuestion {
	public static void main(String[] args) {
		Child c = new Child();
		c.addWakenUpListener(new Dad());
		c.addWakenUpListener(new GrandFather());
		new Thread(c).start();
	}
}

 

这个时候再看概述的例子，比较容易理解了吧！

定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时, 所有依赖于它的对象都得到通知并被自动更新。[GOF 《设计模式》]

 

观察者模式中的推模式与拉模式[摘录]

在Observer模式中区分推模式和拉模式，先简单的解释一下两者的区别：推模式是当有消息时，把消息信息以参数的形式传递（推）给所有观察者，而拉模式是当有消息时，通知消息的方法本身并不带任何的参数，是由观察者自己到主体对象那儿取回（拉）消息。知道了这一点，大家可能很容易发现上面我所举的例子其实是一种推模式的Observer模式。我们先看看这种模式带来了什么好处：当有消息时，所有的观察者都会直接得到全部的消息，并进行相应的处理程序，与主体对象没什么关系，两者之间的关系是一种松散耦合。但是它也有缺陷，第一是所有的观察者得到的消息是一样的，也许有些信息对某个观察者来说根本就用不上，也就是观察者不能“按需所取”；第二，当通知消息的参数有变化时，所有的观察者对象都要变化。鉴于以上问题，拉模式就应运而生了，它是由观察者自己主动去取消息，需要什么信息，就可以取什么，不会像推模式那样得到所有的消息参数。OK，说到这儿，你是否对于推模式和拉模式有了一点了解呢？

实际上上面的代码中，因java中awt事件的影响，我在Event中加入了source字段，这算是拉模式的一种体现。我们可以得到公共的事件信息，也可以通过source得到发出事件对象的信息。

 

AWT事件模拟

说到AWT事件，我们根据上面的思路模拟下awt事件处理，观察者模式实现awt事件功能更加简单优雅，然而真正的awt也需要windows本身的事件驱动的支持，比如你按下某个button，首先windows捕获这个消息，把消息分发给java虚拟机，虚拟机在调用button相应的处理，button调用监听器处理（个人理解）。一般awt事件处理：

public class AwtButton extends Frame {
	public void lanch() {
		Button b = new Button("test");
		b.addActionListener(new MyActionListener());
		b.addActionListener(new MyActionListener1());
		this.add(b);
		this.addWindowListener(new WindowAdapter() {
			@Override
			public void windowClosing(WindowEvent e) {
				System.exit(0);
			}
		});
		setSize(100, 100);
		setVisible(true);
	}
	public static void main(String[] args) {
		new AwtButton().lanch();
	}
	class MyActionListener implements ActionListener {
		@Override
		public void actionPerformed(ActionEvent e) {
			System.out.println("button pressed!");
		}
	}
	class MyActionListener1 implements ActionListener {
		@Override
		public void actionPerformed(ActionEvent e) {
			System.out.println("button pressed1!");
		}
	}
}

 

结合上面的孩子的例子，我们使用控制台模拟awt事件：

public class SimulationAwtButton {
	public static void main(String[] args) {
		Button b = new Button();
		b.addActionListener(new MyActionListener1());
		b.addActionListener(new MyActionListener2());
		b.pressed();
	}
}
class Button {
	private List<ActionListener> list = new ArrayList<ActionListener>();
	public void addActionListener(ActionListener l) {
		list.add(l);
	}
	public void pressed() {
		ActionEvent e = new ActionEvent(this);
		for(ActionListener l : list) {
			l.actionPerform(e);
		}
	}
}
interface ActionListener {
	void actionPerform(ActionEvent e) ;
}
class ActionEvent {
	private long time;
	private Object source;
	public ActionEvent(Object source) {
		this.time = System.currentTimeMillis();
		this.source = source;
	}
	public long getTime() {
		return time;
	}
	public Object getSource() {
		return source;
	}
}
class MyActionListener1 implements ActionListener {
	@Override
	public void actionPerform(ActionEvent e) {
		System.out.println("SimulationButton ActionPerformed:" +e.getTime() + e.getSource());
	}
}
class MyActionListener2 implements ActionListener {
	@Override
	public void actionPerform(ActionEvent e) {
		System.out.println("SimulationButton ActionPerformed:" +e.getTime() + e.getSource());
	}
}

 

这样，对java送awt事件处理有了更深的认识。

 

适用性

1．当一个抽象模型有两个方面, 其中一个方面依赖于另一方面。将这二者封装在独立的对象中以使它们可以各自独立地改变和复用。

2．当对一个对象的改变需要同时改变其它对象, 而不知道具体有多少对象有待改变。

3．当一个对象必须通知其它对象，而它又不能假定其它对象是谁。换言之, 你不希望这些对象是紧密耦合的。

总结

通过Observer模式，把一对多对象之间的通知依赖关系的变得更为松散，大大地提高了程序的可维护性和可扩展性，也很好的符合了开放-封闭原则。

参考资料

.NET设计模式（19）：观察者模式（Observer Pattern）（部分摘录原文）

java尚学堂马士兵设计模式

百度百科:观察者模式