Java设计模式笔记之观察者模式

1.观察者模式

观察者模式是对象的行为那模式，又叫发布-订阅（Publish/Subcrible）模式,模型-视图(Model/View)模式、源-监听器模式或从属者模式。

观察者模式定义了一种一对多的依赖关系，让多个观察者同时监听某一个主题对象。这个主题对象在状态上发生变化时，会通知多有观察者对象，使它们自动更新。

2.观察者模式的结构

参与角色：

• Subject：抽象主题，定义所有被观察者的行为，并且提供一个集合保存所有的观察者。
• ConcreteSubject：具体主题，实现抽象主题定义的行为，并保存相关状态，状态改变时通知观察者（Observer）
• Observer：抽象观察者，为具体观察者定义一个接口（update），主题改变状态时，通过这个接口通知观察者
• ConcreteObserver：具体观察者，实现观察者接口，可观察主题（subject）来改变自身状态。

3.示例源码

Subject（主题）

package com.patterns.observer;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public abstract class Subject {
	public void attach(Observer observer) {
		observers.add(observer);
	}

	public void detach(Observer observer) {
		observers.remove(observer);
	}

	//通知所有观察者
	public void notifyObservers() {

		Iterator<Observer> it = observers.iterator();
		while (it.hasNext()) {
			((Observer) it.next()).update();
		}
	}

	//存储观察者
	private List<Observer> observers = new ArrayList<Observer>();
}

ConcreteSubject（具体主题）

public class ConcreteSubject extends Subject {

	
	// 状态改变,通知观察者
	public void change() {
		this.notifyObservers();
	}

}

Observer（抽象观察者）

public interface Observer
{
    void update();
}

ConcreteObserver（具体观察者）

public class ConcreteObserver implements Observer {
	private String name;
	public ConcreteObserver(String name){
		this.setName(name);
	}
	public void update() {
		System.out.println(getName() + " kown Subject has changed");
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}

}

client（测试代码）

package com.patterns.observer;

public class Client {

	public static void main(String[] args) {
		
		Observer ob1 = new ConcreteObserver("ob1");
		Observer ob2 = new ConcreteObserver("ob2");
		
		ConcreteSubject subject = new ConcreteSubject();
		subject.attach(ob1);
		subject.attach(ob2);
		
		subject.change();
		
	}

}

运行效果：

ob1 kown Subject has changed
ob2 kown Subject has changed

4.Java对观察者模式的支持

在Java语言的java.util库里面,提供了一个Observable类以及一个Observer接口，构成了对观察者模式的支持。使用步骤如下：

1. 实现Observer接口，定义一个观察者。
2. 继承Observable类，实现一个被观察者（主题）。
3. 被观察者状态改变时，调用setChanged()方法改变内部状态，调用notifyObservers(),通知所有观察者更新。

示例代码：

Watcher.java(观察者)

import java.util.Observable;
import java.util.Observer;

public class Watcher implements Observer {

	public Watcher(Watched w)
    {
        w.addObserver(this);
    }

    public void update( Observable ob, Object arg)
    {
        System.out.println("Data has been changed to:  '" + ((Watched)ob).retrieveData() + "'");
    }

}

Watched.java（被观察者）

public class Watched extends Observable {

	private String data = "";

	public String retrieveData() {
		return data;
	}

	public void changeData(String data) {
		if (!this.data.equals(data)) {
			this.data = data;
			
			//改变状态，不改变状态notifyObservers（），不起作用		
			setChanged();
		}

		notifyObservers();
	}

}

ObserverTester.java(测试代码)

import java.util.Observer;
public class ObserverTester {

	static private Watched watched;
	static private Observer watcher;

	public static void main(String[] args) {
		watched = new Watched();

		watcher = new Watcher(watched);

		watched.changeData("In C, we create bugs.");
		watched.changeData("In Java, we inherit bugs.");
		/**
		 * 状态与上一次相同,不会通知观察者更新
		 */
		watched.changeData("In Java, we inherit bugs.");
		watched.changeData("In Visual Basic, we visualize bugs.");
	}

}

运行结果：

Data has been changed to:  'In C, we create bugs.'
Data has been changed to:  'In Java, we inherit bugs.'
Data has been changed to:  'In Visual Basic, we visualize bugs.'

5.结语

观察者适用于特定的场景，当一个或多个对象的更新依赖于一个特定的对象，可以使用观察者模式。使用观察者模式有助于代码结构的分离，降低耦合。观察者模式还支持广播通信。

观察者模式的缺点：

（1）如果一个被观察者对象有很多观察者对象，全部通知可能很耗时间。

（2）如果被观察者之间有循环依赖，会触发他们之间的循环调用，导致系统崩溃。需要避免这种情况。

（3）如果对观察者的通知是通过另外的线程进行异步投递的话，需要保证投递是以自洽的方式进行（啥意思。。。）

（4）观察者并不知道被观察者是怎样发生变化的。