设计模式-观察者模式
前言
观察者模式定义了对象间的一对多依赖关系,让一个或者多个观察者对象观察一个主题对象。当主题对象的状态发生变化时,系统能通知所有的依赖于此对象的观察者对象,从而使得观察者对象能自动更新。
在观察者模式中,被观察的对象通常被称为主题(Subject),依赖的对象被称为观察者(Observer)。在java中其实就有经典的AWT,比如按钮单击监听等等。
请模拟下面的情形:
- 小孩在睡觉
- 醒来后要吃东西
版本1
主要思想:设计两个类Child和Dad,都是线程类,其中Dad类主动监测小孩是否还在睡觉,如果小孩一旦醒来,就喂它吃东西。
Child类:设置小孩的状态为睡着的,过了5秒,就醒来
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,监听小孩一旦醒来,就喂他吃的
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);
}
}
监听测试
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类
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类
public class Dad{
void feed(Child c) {
System.out.println("Child is feeded!");
}
}
监听测试类
public class DadOberverChild {
public static void main(String[] args) {
Dad d = new Dad();
new Thread(new Child(d)).start();
}
}
版本3
小孩一醒过来,触发一件事,就让爸爸对这件事做出反应,不管是喂他吃东西,还是抱他出去玩,都会使程序更灵活。
Child类
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类
public class Dad{
void feed(Child c) {
System.out.println("Child is feeded!");
}
//处理可能发生的事件
public void ActionToWakenUp(WakenUpEvent wakenUpEvent) {
System.out.println("OK!");
}
}
事件类:封装发生的事件对象
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类
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类
public class Dad implements WakenUpListener{
public void ActionToWakenUp(WakenUpEvent wakenUpEvent) {
System.out.println("Feed Child!");
}
}
GrendFather类
public class GrendFather implements WakenUpListener {
public void ActionToWakenUp(WakenUpEvent wakenUpEvent) {
System.out.println("Hug Child!");
}
}
监听者接口
public interface WakenUpListener {
public void ActionToWakenUp(WakenUpEvent wakenUpEvent);
}
事件类之前就已经封转好了,不用改变。
监听测试类
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();
}
}
测试结果
Feed Child!
Hug Child!
程序改装到现在,灵活性非常高了,此时如果还有什么人要对小孩做什么事的话,只要再创建一个类就好,而且我们可以将要调用的类的信息放到配置文件中,在测试时,只需要读取配置文件中的信息就好,程序的可维护性变高了。
如:在程序中建立Observer.properties文件,随意添加对象名称。如:
observers = Dad,GrendFather
监听测试类:解析资源文件Observer.properties
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();
}
}
本博客所有文章除特别声明外均采用CC BY-NC-SA 4.0许可。转载请注明来自https://newgr8player.com。
本文链接:https://newgr8player.com/2018/03/24/设计模式-观察者模式/