观察者模式又叫做：发布--订阅（Publish/Subscirbe)模式；
观察者模式：定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态发生变化的时候，会通知所有观察者对象，使它们能够更新自己；
观察者模式UML图.png
一、Subject类，可以为主题或者抽象通知者，一般用一个抽象类或者一个接口实现。他把所有的观察者对象的引用保存在一个集合里；每个主题可以有任意数量的观察者对象，可以增加或删除观察者对象；
/**
* Created by serenitynanian on 2018/6/7.
* 主题或抽象通知者，被观察者 一般是一个抽象类或者是一个接口实现
* 缺点：通知者SubjectClass-----依赖-----观察者ObserverClass
*/
public abstract class SubjectClass {
//针对抽象编程，减少与具体类的耦合
private List<ObserverClass> list = new ArrayList<ObserverClass>();
//被观察者的状态
private String actionStatus ;
public String getActionStatus() {
return actionStatus;
}
public void setActionStatus(String actionStatus) {
this.actionStatus = actionStatus;
}
abstract void attach(ObserverClass observerClass);
abstract void detach(ObserverClass observerClass);
abstract void notifyAllObserver();
}
二、Observer类，抽象观察者，为所有具体的观察者定义一个接口，在得到主题通知时更新自己；这个接口叫做更新接口。抽象观察者通常是一个抽象类或者一个接口实现；更新接口通产有个更新的方法；
/**
* Created by serenitynanian on 2018/6/7.
* 观察者
*/
public abstract class ObserverClass {
protected String name;
protected SubjectClass subjectClass ;
/**
*
* @param name
* @param subjectClass 为抽象通知者，减少与具体类的耦合
*/
public ObserverClass(String name, SubjectClass subjectClass) {
this.name = name;
this.subjectClass = subjectClass;
}
public abstract void update();
}
三、具体Subject
import java.util.ArrayList;
import java.util.List;
/**
* Created by serenitynanian on 2018/6/7.
*/
public class ConcreteSubject extends SubjectClass {
//针对抽象编程，减少与具体类的耦合
private List<ObserverClass> list = new ArrayList<ObserverClass>();
/**
* 添加观察者
* @param observerClass //针对抽象编程，减少与具体类的耦合
*/
@Override
public void attach(ObserverClass observerClass) {
if (null != list) {
list.add(observerClass);
}
}
/**
* 移除观察者
* @param observerClass //针对抽象编程，减少与具体类的耦合
*/
@Override
public void detach(ObserverClass observerClass) {
if (null != list) {
list.remove(observerClass);
}
}
/**
* 通知所有观察者
*/
@Override
public void notifyAllObserver() {
for (int i = 0; i < list.size(); i++) {
ObserverClass observerClass = list.get(i);
observerClass.update();
}
}
}
四、具体观察者
/**
* Created by serenitynanian on 2018/6/7.
*/
public class ConcreteObserver1 extends ObserverClass {
public static final String TAG = ConcreteObserver1.class.getSimpleName();
/**
* @param name
* @param subjectClass 为抽象通知者，减少与具体类的耦合
*/
public ConcreteObserver1(String name, SubjectClass subjectClass) {
super(name, subjectClass);
}
@Override
public void update() {
System.out.println(name+"------已经被告知---->"+subjectClass.getActionStatus());
}
}
/**
* Created by serenitynanian on 2018/6/7.
*/
public class ConcreteObserver2 extends ObserverClass {
public static final String TAG = ConcreteObserver2.class.getSimpleName();
/**
* @param name
* @param subjectClass 为抽象通知者，减少与具体类的耦合
*/
public ConcreteObserver2(String name, SubjectClass subjectClass) {
super(name, subjectClass);
}
@Override
public void update() {
System.out.println(name+"------已经被告知---->"+subjectClass.getActionStatus());
}
}
五、具体调用
/**
* Created by serenitynanian on 2018/6/7.
*/
public class ClientTest {
public static void main(String[] args) {
ConcreteSubject subjectClass = new ConcreteSubject();
ObserverClass observerClass1 = new ConcreteObserver1("1号观察者",subjectClass);
ObserverClass observerClass2 = new ConcreteObserver2("2号观察者", subjectClass);
subjectClass.attach(observerClass1);
subjectClass.attach(observerClass2);
subjectClass.setActionStatus("这是一条新通知");
subjectClass.notifyAllObserver();
}
}
六、总结
- 1.将一个系统分割成由许多相互协作的类有一个很不好的副作用，就是需要维护相关对象间的一致性。我们希望不希望为了维护相关对象的一致性，而使各类紧密耦合，这样会给维护、扩展和重用都带来不便；
- 2.观察者模式就是解除耦合，让耦合双方都依赖于抽象，而不是依赖于具体；从而使各自一边的变化都不会影响到另一边；
- 3.一个抽象模型有两个方面，当一个方面依赖另一个方面，这时就可以使用观察者模式将两者封装在独立的对象中，从而使它们独立的复用或改变而不影响到另一方；
七、缺点
- 1.抽象通知者----依赖----抽象观察者，万一没有了抽象观察者这样的接口，通知功能就不能进行；
- 2.通知者下发通知，每个观察者都进行同一个方法的回调，不能按照各自的逻辑，回调各自不同的方法；
八、解决缺点---事件委托
如果通知者和观察者之间，它们根本不相互知道，由客户端决定来通知谁，那么问题就都解决了；
