设计模式-观察者模式

模式定义

定义了对象之间的一对多依赖，当一个对象改变状态时，它的所有依赖者都会收到通知并自动更新。主题（Subject）是被观察的对象，而其所有依赖者（Observer）称为观察者。

设计原则

为交互对象之间的松耦合设计而努力：当两个对象之间松耦合，它们依然可以交互，但是不清楚彼此的细节。由于松耦合的两个对象之间互相依赖程度很低，因此系统具有弹性，能够应对变化。

UML类图

观察者模式实例

定义被观察者接口

package com.wpx.observer;

/**
 * 抽象被观察者接口
 * 定义了添加、删除、通知观察者方法
 */
public interface Subject {
    public void registerObserver(Observer o);

    public void removeObserver(Observer o);

    public void notifyObservers();
}

定义观察者接口

package com.wpx.observer;

/**
 * 抽象观察者接口
 * 定义了一个update()方法，当被观察者调用notifyObservers()方法时，观察者的update()方法会被回调
 */
public interface Observer {
    public void update(String message);
}

定义被观察者，实现Subject接口，对Subject接口的三个方法进行了具体实现，同时有一个List集合，用以保存注册的观察者，等需要通知观察者时，遍历该集合。

package com.wpx.observer;

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

/**
 * 具体的被观察者
 */
public class ConcreteSubject implements Subject {
    private List<Observer> list;
    private String message;

    public ConcreteSubject() {
        list = new ArrayList<Observer>();
    }

    @Override
    public void registerObserver(Observer o) {
        list.add(o);
    }

    @Override
    public void removeObserver(Observer o) {
        if (!list.isEmpty())
            list.remove(o);
    }

    @Override
    public void notifyObservers() {
        for (int i = 0; i < list.size(); i++) {
            Observer observer = list.get(i);
            observer.update(message);
        }
    }

    public void send(String s) {
        this.message = s;
        System.out.println("更新消息:" + s);
        //消息更新，通知所有观察者
        notifyObservers();
    }
}

定义观察者，实现Observer接口，对方法进行实现

package com.wpx.observer;

/**
 * 具体的观察者
 */
public class ConcreteObserver implements Observer {
    private String name;
    private String message;

    public ConcreteObserver(String name) {
        this.name = name;
    }

    @Override
    public void update(String message) {
        this.message = message;
        read();
    }

    public void read() {
        System.out.println(name + " 收到消息：" + message);
    }
}

测试观察者模式，先创建一个被观察者对象(公司)，再创建三个观察者对象(职工)，公司先发布消息说今天加班，张三一听，不干了辞职，之后公司又发布消息明天放假，张三已经辞职，因此收不到消息，其他观察者(职工)可以收到消息。

package com.wpx.observer;

/**
 * 测试观察者模式
 */
public class ObserverDemo {
    public static void main(String[] args) {
        ConcreteSubject subject = new ConcreteSubject();

        Observer observer1 = new ConcreteObserver("张三");
        Observer observer2 = new ConcreteObserver("李四");
        Observer observer3 = new ConcreteObserver("王五");

        subject.registerObserver(observer1);
        subject.registerObserver(observer2);
        subject.registerObserver(observer3);

        subject.send("今天加班");

        subject.removeObserver(observer1);

        subject.send("明天放假");
    }


}

运行结果

更新消息:今天加班
张三 收到消息：今天加班
李四 收到消息：今天加班
王五 收到消息：今天加班
更新消息:明天放假
李四 收到消息：明天放假
王五 收到消息：明天放假

Process finished with exit code 0

总结

观察者模式是松偶合的。改变主题或观察者中的一方，另一方不会受到影响。
JDK中也有自带的观察者模式，但是被观察者是一个类而不是接口，限制了它的使用和复用能力。JDK内置观察者模式java.util.Observer接口， java.util.Observable类。
在JavaBean和Swing中也有观察者模式的设计思想。