Java工具类Observable源码解析与使用

很多地方,我们需要使用观察者设计模式,而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是不支持多重继承的。
在必要的时候,可以自己手写代码,而不是用这个工具类。

坚持原创技术分享,您的支持将鼓励我继续创作!