示例类图

观察者模式.png

示例代码

Abstract Observable

• JDK中提供的用于实现观察者模式的类；
• 在抽象层组合了多个抽象观察者；

package java.util;

public class Observable {
    private boolean changed = false;
    private Vector<Observer> obs;

    public Observable() {
        obs = new Vector<>();
    }

    public synchronized void addObserver(Observer o) {
        if (o == null)
            throw new NullPointerException();
        if (!obs.contains(o)) {
            obs.addElement(o);
        }
    }

    public synchronized void deleteObserver(Observer o) {
        obs.removeElement(o);
    }

    public void notifyObservers() {
        notifyObservers(null);
    }

    public void notifyObservers(Object arg) {
       
        Object[] arrLocal;

        synchronized (this) {            
            if (!changed)
                return;
            arrLocal = obs.toArray();
            clearChanged();
        }

        for (int i = arrLocal.length-1; i>=0; i--)
            ((Observer)arrLocal[i]).update(this, arg);
    }

    public synchronized void deleteObservers() {
        obs.removeAllElements();
    }

    protected synchronized void setChanged() {
        changed = true;
    }

    protected synchronized void clearChanged() {
        changed = false;
    }

    public synchronized boolean hasChanged() {
        return changed;
    }

    public synchronized int countObservers() {
        return obs.size();
    }

}

Contrete Observable

• 实现java.util.Observable；
• setChanged() 用于改变被观察者自身的状态；
• notifyObservers(question) 通知组合的所有观察者，并将通知信息 question 广播给所有观察者；

import java.util.Observable;

public class Course extends Observable{

    private String courseName;

    public Course(String courseName) {
        this.courseName = courseName;
    }

    public String getCourseName() {
        return courseName;
    }

    public void produceQuestion(Course course, Question question){
        System.out.println(
                question.getUserName() + "在"
                + course.courseName
                + "提交了一个问题");
        setChanged();
        notifyObservers(question);
        clearChanged();
    }

}

Abstract Observer

• Observable o 为被观察者；
• Object arg 为被观察者广播给所有观察者的通知信息；

package java.util;

public interface Observer {
    void update(Observable o, Object arg);
}

Concrete Observer

• 所有的具体观察者的 update(Observable o, Object arg) 方法都会被调用；

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

public class Teacher implements Observer{

    private String teacherName;

    public Teacher(String teacherName) {
        this.teacherName = teacherName;
    }

    @Override
    public void update(Observable o, Object arg) {
        Course course = (Course)o;
        Question question = (Question)arg;
        System.out.println(teacherName + "老师的"
                + course.getCourseName() + "课程接收到一个"
                + question.getUserName() + "提交的问答:"
                + question.getQuestionContent());
    }

}

Client

• 被观察者的 course.produceQuestion(course, question); 方法中广播通知了所有的具体观察者；

public class Test {
    public static void main(String[] args) {

        Course course = new Course("Java设计模式精讲");
        Teacher teacher1 = new Teacher("Alpha");
        Teacher teacher2 = new Teacher("Beta");

        course.addObserver(teacher1);
        course.addObserver(teacher2);

        //业务逻辑代码
        Question question = new Question();
        question.setUserName("Geely");
        question.setQuestionContent("Java的主函数如何编写");

        course.produceQuestion(course, question);
    }
}

输出：

Geely在Java设计模式精讲提交了一个问题
Beta老师的Java设计模式精讲课程接收到一个Geely提交的问答:Java的主函数如何编写
Alpha老师的Java设计模式精讲课程接收到一个Geely提交的问答:Java的主函数如何编写