很多地方，我们需要使用观察者设计模式，而Java内部有提供了这样的一个类。通过继承Observable类和实现Observer接口，就可以省下一些代码，不用我们自己去实现这些代码。

Observable类

Observable类的方法

  • public void addObserver(Observer o) 添加一个观察者
  • public void deleteObserver(Observer o) 删除一个观察者
  • public void notifyObservers() 通知所有观察者
  • public void notifyObservers(Object arg) 通知所有观察者，带一个Object参数
  • public void deleteObservers() 删除所有观察者
  • protected void setChanged() 设置主题数据改变标志
  • protected void clearChanged() 清除主题数据改变标志
  • public boolean hasChanged()
  • public int countObservers()

Observer接口

  • void update(Observable o, Object arg); 主题更新时调用这个方法

一个例子

这个例子实现了对一个书单的监视，当书单改变时，会通知观察者。 具体原理如下：

  1. 实现Observer接口，也就是观察者
  2. 继承Observable类，在数据改变时使用setchanged()和notifyObservers()方法可以通知观察者
  3. 新建Observer和Observable实例，并使用addObserver()将观察者加入到观察列表中
  4. 改变数据，这时候观察者已经可以收到改变的通知了。

BookObserver.java代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

import java.util.Observable;
import java.util.Observer;
public class BookObserver implements Observer {
    private String name;
    public BookObserver(String name) {
        this.name = name;
    }
    @Override
    public void update(Observable o, Object arg) { // 主题更新时调用这个方法
        BookList bl = (BookList)o;
        System.out.println(name+": "+bl.getBooks().toString());
    }
}

BookList.java代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

import java.util.ArrayList;
import java.util.List;
import java.util.Observable;
public class BookList extends Observable {
    List<String> books;
    public void addBook(String bookName) {
        if (books == null)
            books = new ArrayList<>();
        books.add(bookName);
        setChanged();       // 设置数据发生变化标志
        notifyObservers();  // 通知所有观察者
    }
    public void delBook(String bookName) {
        if (books.remove(bookName)) {
            setChanged();
            notifyObservers();
        }
    }
    public List<String> getBooks() {
        return books;
    }
    public void setBooks(List<String> books) {
        this.books = books;
    }
}

Main.java代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

public class Main {
    public static void main(String[] args) {
        BookList bl = new BookList();       // 新建主题实例
        BookObserver bo1 = new BookObserver("Observer1"); // 新建观察者实例
        BookObserver bo2 = new BookObserver("Observer2");
        bl.addObserver(bo1);                // 将观察者加入主题
        bl.addObserver(bo2);
        bl.addBook("Java从入门到放弃");       // 更新主题
        bl.addBook("MySQL从删库到跑路");
        bl.delBook("MySQL从删库到跑路");
    }
}

输出结果

1
2
3
4
5
6
7

"F:\Program Files\Java\jdk1.8.0_172\bin\java.exe" ...
Observer2: [Java从入门到放弃]
Observer1: [Java从入门到放弃]
Observer2: [Java从入门到放弃, MySQL从删库到跑路]
Observer1: [Java从入门到放弃, MySQL从删库到跑路]
Observer2: [Java从入门到放弃]
Observer1: [Java从入门到放弃]

源码解析(JDK 8u172)

Observer接口源码

Observer接口只有一个方法。

1
2
3
4

package java.util;
public interface Observer {
    void update(Observable o, Object arg);
}

Observable类源码

Observable类内部维护了changed和ob两个变量，其中changed是数据改变标志，而obs就是观察者列表了。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

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); // 根据缓存来通知观察者
        // 缓存机制解决了并发线程对obs改变造成的异常问题
        // 但实际这样子有时候还是会出问题的，比如多线程的时候，可能某个观察者已经删除了，但是它仍然可能被通知。
        // 或者新加进来的没有被通知到，因为用的是缓存。
    }

    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();
    }
}

总结

Observable是一个类，只能通过继承来实现。这也限制了它的使用范围，比如Java是不支持多重继承的。 在必要的时候，可以自己手写代码，而不是用这个工具类。