设计模式-观察者模式

可进入我的博客查看原文。

定义

观察者模式定义了对象之间的一对多依赖，使得当一个对象改变状态时，它的所有依赖者都会收到通知并自动更新。观察者模式又叫发布/订阅模式。

角色

• 抽象主题（Subject）：它把所有观察者对象的引用保存到一个列表里，每个主题都可以有任何数量的观察者。抽象主题提供一个接口，可以增加和删除观察者对象。
• 具体主题（ConcreteSubject）：将有关状态存入具体观察者对象；在具体主题内部状态改变时，给所有登记过的观察者发出通知。
• 抽象观察者（Observer）：为所有的具体观察者定义一个接口，在得到主题通知时更新自己。
• 具体观察者（ConcreteObserver）：实现抽象观察者角色所要求的更新接口，以便使本身的状态与主题状态协调。

类图

示例

以猎头-求职者为例。猎头是主题，求职者是观察者。

Subject 接口

public interface Subject {
    public void registerObserver(Observer o);
    public void removeObserver(Observer o);
    public void notifyAllObservers();
}

Observer 接口

public interface Observer {
    public void update(Subject s);
}

HeadHunter 类实现 Subject 接口

import java.util.LinkedList;

public class HeadHunter implements Subject {
    private LinkedList<Observer> userList;
    private LinkedList<String> jobs;

    public HeadHunter() {
        userList = new LinkedList<Observer>();
        jobs = new LinkedList<String>();
    }

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

    @Override
    public void removeObserver(Observer o) {
        userList.remove(o);
    }

    @Override
    public void notifyAllObservers() {
        for (Observer o: userList) {
            o.update(this);
        }
    }

    public void addJob(String job) {
        jobs.add(job);
        notifyAllObservers();
    }

    public LinkedList<String> getJobs() {
        return jobs;
    }

    public String toString() {
        return jobs.toString();
    }
}

JobSeeker 类实现 Observer 接口

public class JobSeeker implements Observer {
        private String name;

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

        @Override
        public void update(Subject s) {
            System.out.println(this.name + " got notified!");
            System.out.println(s);
        }
}

测试

public class Main {
    public static void main(String[] args) {
        HeadHunter hh = new HeadHunter();

        JobSeeker lbd = new JobSeeker("lbd");
        JobSeeker lbx = new JobSeeker("lbx");
        JobSeeker lbn = new JobSeeker("lbn");
        JobSeeker lbb = new JobSeeker("lbb");

        hh.registerObserver(lbd);
        hh.registerObserver(lbx);
        hh.registerObserver(lbn);
        hh.registerObserver(lbb);
        hh.removeObserver(lbb);

        hh.addJob("looking for Java engineers");
        hh.addJob("looking for Python engineers");
    }
}

输出

lbd got notified!
[looking for Java engineers]
lbx got notified!
[looking for Java engineers]
lbn got notified!
[looking for Java engineers]
lbd got notified!
[looking for Java engineers, looking for Python engineers]
lbx got notified!
[looking for Java engineers, looking for Python engineers]
lbn got notified!
[looking for Java engineers, looking for Python engineers]

总结

观察者模式使主题和观察者之间松耦合，松耦合的设计能够让我们建立有弹性的OO系统，能够应对变化，因为对象直接的相互依赖降到了最低。

其他

• 上面的例子是观察者模式的“推”模式，还有一种“拉”模式。
• Java 的 java.util 库里面，提供了一个 Observable 类以及一个 Observer 接口，构成 Java 语言对观察者模式的支持。

可进入我的博客查看原文。