前言
观察者模式定义了对象间的一对多依赖关系，让一个或者多个观察者对象观察一个主题对象。当主题对象的状态发生变化时，系统能通知所有的依赖于此对象的观察者对象，从而使得观察者对象能自动更新。
在观察者模式中，被观察的对象通常被称为主题(Subject),依赖的对象被称为观察者(Observer)。在java中其实就有经典的AWT，比如按钮单击监听等等。
请模拟下面的情形：
版本1
主要思想：设计两个类Child和Dad，都是线程类，其中Dad类主动监测小孩是否还在睡觉，如果小孩一旦醒来，就喂它吃东西。
Child类:设置小孩的状态为睡着的，过了5秒，就醒来
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
| public class Child implements Runnable {
private boolean wakenUp = false;
void wakeUp(){
wakenUp = true;
}
@Override
public void run() {
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
wakeUp();
}
public boolean isWakenUp() {
return wakenUp;
}
public void setWakenUp(boolean wakenUp) {
this.wakenUp = wakenUp;
}
}
|
Dad类：将Child的引用传给Dad，监听小孩一旦醒来，就喂他吃的
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
| public class Dad implements Runnable{
Child c;
public Dad(Child c) {
this.c = c;
}
void feed(Child c) {
System.out.println("Child is feeded!");
}
@Override
public void run() {
while(!c.isWakenUp()){
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
c.wakeUp();
feed(c);
}
}
|
监听测试
1
2
3
4
5
6
7
8
9
10
| public class DadOberverChild {
public static void main(String[] args) {
Child c = new Child();
new Thread(c).start();
new Thread(new Dad(c)).start();
}
}
|
该设计有些不合理，主动地监测，爸爸要不停地看着小孩，内存消耗严重，浪费时间。
版本2
修正版本1中cpu浪费的情形，现在不拿Dad来监控Child，反过来被动监测，让Child来监控Dad，比如你可以一边看欧洲杯，当儿子一醒来后，他就会用绳子拉着你去喂他。
Child类
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
| public class Child implements Runnable {
private boolean wakenUp = false;
private Dad d;
public Child(Dad d){
this.d = d;
}
void wakeUp(){
wakenUp = true;
}
@Override
public void run() {
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
wakeUp();
d.feed(this);
}
public boolean isWakenUp() {
return wakenUp;
}
public void setWakenUp(boolean wakenUp) {
this.wakenUp = wakenUp;
}
}
|
Dad类
1
2
3
4
5
6
| public class Dad{
void feed(Child c) {
System.out.println("Child is feeded!");
}
}
|
监听测试类
1
2
3
4
5
6
7
8
| public class DadOberverChild {
public static void main(String[] args) {
Dad d = new Dad();
new Thread(new Child(d)).start();
}
}
|
版本3
小孩一醒过来，触发一件事，就让爸爸对这件事做出反应，不管是喂他吃东西，还是抱他出去玩，都会使程序更灵活。
Child类
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
| public class Child implements Runnable {
private Dad d;
public Child(Dad d){
this.d = d;
}
void wakeUp(){
d.ActionToWakenUp(new WakenUpEvent(System.currentTimeMillis(),"bed",this));
}
public void run() {
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
this.wakeUp();
}
}
|
Dad类
1
2
3
4
5
6
7
8
9
10
11
| public class Dad{
void feed(Child c) {
System.out.println("Child is feeded!");
}
public void ActionToWakenUp(WakenUpEvent wakenUpEvent) {
System.out.println("OK!");
}
}
|
事件类：封装发生的事件对象
1
2
3
4
5
6
7
8
9
10
| public class WakenUpEvent {
private long wakenTime;
private String location;
private Child source;
public WakenUpEvent(long wakenTime, String location, Child source)
......
public Setter()/Getter()
......
}
|
版本4
对于小孩来说，一旦某件事发生，监听着这件事的人可能不只有一个，比如爸爸喂他吃东西，爷爷带他出去玩，奶奶给他开电视机.
Child类
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
| public class Child implements Runnable {
private List<WakenUpListener> wakenUpListeners = new ArrayList<WakenUpListener>();
public void addWakenUpListener(WakenUpListener l){
wakenUpListeners.add(l);
}
void wakeUp(){
for(int i=0;i<wakenUpListeners.size();i++){
WakenUpListener l = wakenUpListeners.get(i);
l.ActionToWakenUp(new WakenUpEvent(System.currentTimeMillis(),"bed",this));
}
}
public void run() {
}
}
|
Dad类
1
2
3
4
5
6
7
| public class Dad implements WakenUpListener{
public void ActionToWakenUp(WakenUpEvent wakenUpEvent) {
System.out.println("Feed Child!");
}
}
|
GrendFather类
1
2
3
4
5
6
7
| public class GrendFather implements WakenUpListener {
public void ActionToWakenUp(WakenUpEvent wakenUpEvent) {
System.out.println("Hug Child!");
}
}
|
监听者接口
1
2
3
| public interface WakenUpListener {
public void ActionToWakenUp(WakenUpEvent wakenUpEvent);
}
|
事件类之前就已经封转好了，不用改变。
监听测试类
1
2
3
4
5
6
7
8
9
10
11
12
| public class DadOberverChild {
public static void main(String[] args) {
Child c = new Child();
Dad d = new Dad();
GrendFather gf = new GrendFather();
c.addWakenUpListener(d);
c.addWakenUpListener(gf);
new Thread(c).start();
}
}
|
测试结果
程序改装到现在，灵活性非常高了，此时如果还有什么人要对小孩做什么事的话，只要再创建一个类就好，而且我们可以将要调用的类的信息放到配置文件中，在测试时，只需要读取配置文件中的信息就好，程序的可维护性变高了。
如：在程序中建立Observer.properties文件，随意添加对象名称。如：
1
| observers = Dad,GrendFather
|
监听测试类：解析资源文件Observer.properties
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
| public class DadOberverChild {
static Properties props = new Properties();
static{
try {
props.load(DadOberverChild.class.getClassLoader().getResourceAsStream("Observer.properties"));
} catch (IOException e) {
e.printStackTrace();
}
}
private DadOberverChild(){}
public static void main(String[] args) {
Child c = new Child();
String[] observers = props.getProperty("observers").split(",");
for(String s : observers){
try {
c.addWakenUpListener((WakenUpListener)(Class.forName(s).newInstance()));
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
new Thread(c).start();
}
}
|