Observer模式美在哪里?
Observer缔造互换性。提升互换性的途径:降低依赖性。
定义
定义对象之间的一对多依赖关系,当一个对象改变状态时,它的所有依赖对象都会自动获得通知。
观察者模式定义了一个一对多的依赖关系,让一个或多个观察者对象监听一个主题对象。这样一来,当被观察者状态发生改变时,需要通知相应的观察者,使这些观察者对象能够自动更新。
关键要素
1.主题
主题是观察者观察的对象,一个主题必须具备下面三个特征。
- 持有监听的观察者的引用
- 支持增加和删除观察者
- 主题状态改变,通知观察者
2.观察者
当主题发生变化,收到通知进行具体的处理是观察者必须具备的特征。
为什么要用这种模式
这里举一个例子来说明,牛奶送奶站就是主题,订奶客户为监听者,客户从送奶站订阅牛奶后,会每天收到牛奶。如果客户不想订阅了,可以取消,以后就不会收到牛奶。
松耦合
- 观察者增加或删除无需修改主题的代码,只需调用主题对应的增加或者删除的方法即可。
- 主题只负责通知观察者,但无需了解观察者如何处理通知。举个例子,送奶站只负责送递牛奶,不关心客户是喝掉还是洗脸。
- 观察者只需等待主题通知,无需观察主题相关的细节。还是那个例子,客户只需关心送奶站送到牛奶,不关心牛奶由哪个快递人员,使用何种交通工具送达。
通知不错过
由于被动接受,正常情况下不会错过主题的改变通知。而主动获取的话,由于时机选取问题,可能导致错过某些状态。
是一种委托式的IOC
抽象主题(Subject):它把所有观察者对象的引用保存到一个聚集里,每个主题都可以有任何数量的观察者。抽象主题提供一个接口,可以增加和删除观察者对象。
具体主题(ConcreteSubject):将有关状态存入具体观察者对象;在具体主题内部状态改变时,给所有登记过的观察者发出通知。
抽象观察者(Observer):为所有的具体观察者定义一个接口,在得到主题通知时更新自己。
具体观察者(ConcreteObserver):实现抽象观察者角色所要求的更新接口,以便使本身的状态与主题状态协调。
自己代码实现:public interface Subject {
void notifyFighter();
}
2、 具体主题将有关状态存入具体观察者对象;在具体主题内部状态改变时,给所有登记过的观察者发出通知。
public class FangxueLe implements Subject {
//存放所有观察者对象,也可以是一个观察者对象
private int msg;
public FangxueLe(int msg){
this.msg = msg;
}
public void setMsg(int msg){
this.msg = msg;
}
List<RoleObserver> list = new ArrayList<>();
public void addRoleObserver(RoleObserver o){
list.add(o);
}
public void removeRoleObser(RoleObserver o){
list.remove(o);
}
public void notifyFighter(){
for (int i = 0; i < list.size(); i++) {
list.get(i).update(msg);
}
}
}
3、抽象观察者(Observer):为所有的具体观察者定义一个接口,在得到主题通知时更新自己。
public interface RoleObserver {
void update(int msg);
}
4、具体观察者(RoleA与RoleB ):
public class RoleA implements RoleObserver{
@Override
public void update(int msg) {
if (msg == 0) {
System.out.println("A : 再等等 ,他还没下课");
} else if (msg == 1) {
System.out.println("A : 小贱下课了 抄家伙");
}
}
}
public class RoleB implements RoleObserver{
@Override
public void update(int msg) {
if (msg == 0) {
System.out.println("B : 快点走 他快要下课了");
} else if (msg == 1) {
System.out.println("B : 快 他下课了 要挨揍。去帮忙");
}
}
}
测试类代码如下:
public static void main(String[] args) {
FangxueLe f = new FangxueLe(0);
RoleObserver a = new RoleA();
RoleObserver b = new RoleB();
f.addRoleObserver(a);
f.addRoleObserver(b);
f.notifyFighter(); //msg为0时的反应
f.setMsg(1); //msg为1时的反应
f.notifyFighter();
}
通过对msg的变化,两个观察者会做出不同的反应
Java实现
Java中有观察者模式使用的API
- java.util.Observable 这是一个类,而非接口,主题需要继承这个类。
- java.util.Observer 这是一个接口,监听者需要实现这个接口。
示例代码
import java.util.Observable;
import java.util.Observer;
public class MainRoot {
public static void main(String[] args) {
Observer consumer = new Consumer();
MilkProvider provider = new MilkProvider();
provider.addObserver(consumer);
provider.milkProduced();
}
static class MilkProvider extends Observable {
public void milkProduced() {
setChanged();//状态改变,必须调用
notifyObservers();
}
}
static class Consumer implements Observer {
@Override
public void update(Observable arg0, Object arg1) {
System.out.println("Consumer update..." + arg0 + ";arg1=" + arg1);
}
}
}
上述代码完成了
- 将consumer加入主题provider的观察者行列
- provider设置状态变化,通知持有的观察者
- 观察者consumer收到通知,打印日志处理
setChanged为何物
其实上述代码中存在这样一处代码setChanged();,如果在通知之前没有调用这个方法,观察者是收不到通知的,这是为什么呢?
这里我们看一下setChanged的源码
protected synchronized void setChanged() {
changed = true;
}
很简单,然后找一下谁使用changed这个值
public synchronized boolean hasChanged() {
return changed;
}
notifyObservers的代码
public void notifyObservers(Object data) {
int size = 0;
Observer[] arrays = null;
synchronized (this) {
if (hasChanged()) {
clearChanged();
size = observers.size();
arrays = new Observer[size];
observers.toArray(arrays);
}
}
if (arrays != null) {
for (Observer observer : arrays) {
observer.update(this, data);
}
}
}
但是为什么要加入这样一个开关呢?可能原因大致有三点
1.筛选有效通知,只有有效通知可以调用setChanged。比如,我的微信朋友圈一条状态,好友A点赞,后续该状态的点赞和评论并不是每条都通知A,只有A的好友触发的操作才会通知A。
2.便于撤销通知操作,在主题中,我们可以设置很多次setChanged,但是在最后由于某种原因需要取消通知,我们可以使用clearChanged轻松解决问题。
3.主动权控制,由于setChanged为protected,而notifyObservers方法为public,这就导致存在外部随意调用notifyObservers的可能,但是外部无法调用setChanged,因此真正的控制权应该在主题这里。
主动获取
观察者模式即所谓的推送方式,然而推送并非完美无缺。比如主题变化会推送大量的数据,而其中的一些观察者只需要某项数据,此时观察者就需要在具体实现中花费时间筛选数据。
这确实是个问题,想要解决也不难,需要主题为某些数据提供getter方法,观察者只需调用getter取数据处理即可。
static class MilkProvider extends Observable {
public void milkProduced() {
setChanged();//状态改变,必须调用
notifyObservers();
}
public float getPrice() {
return 2.5f;
}
}
static class Consumer implements Observer {
@Override
public void update(Observable arg0, Object arg1) {
MilkProvider provider = (MilkProvider)arg0;
System.out.println("milk price =" + provider.getPrice());
}
}
不足与隐患
主要的问题表现在内存管理上,主要由以下两点
- 主题持有观察者的引用,如果未正常处理从主题中删除观察者,会导致观察者无法被回收。
- 如果观察者具体实现代码有问题,会导致主题和观察者对象形成循环引用,在某些采用引用计数的垃圾回收器可能导致无法回收。
interface WakenUpListener {
void action2WakenUp(WakenUpEvent wakenUpEvent);
}
class WakenUpEvent {
private long time;
private String loc;
private Child source;
public WakenUpEvent(long time, String loc, Child source) {
super();
this.time = time;
this.loc = loc;
this.source = source;
}
}
class Child implements Runnable {
private List<WakenUpListener> wakenUpLinteners = new LinkedList<>();
public void addWakenUpListener(WakenUpListener l) {
wakenUpLinteners.add(l);
}
void wakeUp() {
for (WakenUpListener listener : wakenUpLinteners) {
listener.action2WakenUp(new WakenUpEvent(
System.currentTimeMillis(), "bed", this));
}
}
@Override
publicvoid run() {
try {
Thread.sleep(1000);
} catch (Exception e) {
e.printStackTrace();
}
wakeUp();
}
}
class GrandFather implements WakenUpListener {
public void action2WakenUp(WakenUpEvent wakenUpEvent) {
System.out.println("hug child");
}
}
class Mom implements WakenUpListener {
publicvoid action2WakenUp(WakenUpEvent wakenUpEvent) {
System.out.println("kiss child");
}
}
class Dad implements WakenUpListener {
publicvoid action2WakenUp(WakenUpEvent wakenUpEvent) {
System.out.println("feed child");
}
}
observer.properties:
observers=test.Dad,test.GrandFather,test.Mom
public class Test {
publicstaticvoid main(String[] args) {
Child c = new Child();
Properties properties = new Properties();
try {
properties.load(Test.class.getClassLoader().getResourceAsStream(
"test/observer.properties"));
} catch (IOException e) {
e.printStackTrace();
}
String[] observers=properties.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();
}
}