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）观察者并不知道被观察者是怎样发生变化的。