观察者（Observer）模式
1、啥是观察者模式
观察者模式，顾名思义就是他将会观察一个对象，那个对象就是被观察者，当被观察者中观察者感兴趣的状态或者行为发生变动时，观察者就会马上接到通知。说到这里突然想到一个绝妙的例子来说明这个现象。在公司里大家都是看老板脸色吃饭，老板去上厕所了，老板回家了，老板在打电话了，这些信息我们都想知道，这样我们就可以偷个懒，打把农药，刷个朋友圈，在这里一个很重要的点就是我们需要及时知道老板在干吗，好啦这时候我们就需要观察者模式了，老板就是我们的被观察者。
观察者模式的类图如下
2、举个栗子？？？
我们已经知道观察者模式的基本概念以及类图，这里选择公司上班的例子demo，让观察者模式呈现的更加立体。
首先需要一个观察者与被观察者的接口
public interface Observer {
String update(String stirng);
}
public interface Observable {
void registObserver(Observer observer);
void removeObserver(Observer observer);
void notifyAllObserver();
}
接着老板观察者作为安插在老板旁边的内线作为被观察者，需要继承Observable接口
public class BossObserver implements Observable{
List<Observer> observerList = new ArrayList<>();
@Override
public void registObserver(Observer observer) {
observerList.add(observer);
}
@Override
public void removeObserver(Observer observer) {
observerList.remove(observer);
}
@Override
public void notifyAllObserver() {
for (Observer observer:observerList) {
observer.update("上厕所去了");
}
}
}
员工们作为观察者，要时刻留意老板观察者传回来的信息。
public class XiaoLi implements Observer{
@Override
public String update(String string) {
System.out.println("小李，老板"+string);
return string;
}
}
public class XiaoMing implements Observer{
@Override
public String update(String string) {
System.out.println("小明，老板"+string);
return string;
}
}
public class XiaoZhang implements Observer{
@Override
public String update(String string) {
System.out.println("小张，老板"+string);
return string;
}
}
在这里三个员工作为观察者时刻关注老板动向
public class MainActivity extends AppCompatActivity implements View.OnClickListener {
private Button button;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
button = (Button) findViewById(R.id.button);
button.setOnClickListener(this);
}
@Override
public void onClick(View v) {
Observable boss = new Boss();
Observer xiaoming = new XiaoMing();
Observer xiaoli = new XiaoLi();
Observer xiaozhang = new XiaoZhang();
boss.registObserver(xiaoming);
boss.registObserver(xiaoli);
boss.registObserver(xiaozhang);
boss.notifyAllObserver();
}
}
老板刚上厕所，员工就已经收到消息了。如图所示：
通过这个例子，应当对观察者模式有了一个直观的感受。其实jdk中已经替我们实现过观察者。
3、jdk中的观察者
public interface Observer {
/**
* This method is called whenever the observed object is changed. An
* application calls an <tt>Observable</tt> object's
* <code>notifyObservers</code> method to have all the object's
* observers notified of the change.
*
* @param o the observable object.
* @param arg an argument passed to the <code>notifyObservers</code>
* method.
*/
void update(Observable o, Object arg);
}
public class Observable {
private boolean changed = false;
private final ArrayList<Observer> observers;
/** Construct an Observable with zero Observers. */
public Observable() {
observers = new ArrayList<>();
}
public synchronized void addObserver(Observer o) {
if (o == null)
throw new NullPointerException();
if (!observers.contains(o)) {
observers.add(o);
}
}
public synchronized void deleteObserver(Observer o) {
observers.remove(o);
}
public void notifyObservers() {
notifyObservers(null);
}
public void notifyObservers(Object arg) {
Observer[] arrLocal;
synchronized (this) {
if (!hasChanged())
return;
arrLocal = observers.toArray(new Observer[observers.size()]);
clearChanged();
}
for (int i = arrLocal.length-1; i>=0; i--)
arrLocal[i].update(this, arg);
}
public synchronized void deleteObservers() {
observers.clear();
}
protected synchronized void setChanged() {
changed = true;
}
protected synchronized void clearChanged() {
changed = false;
}
public synchronized boolean hasChanged() {
return changed;
}
public synchronized int countObservers() {
return observers.size();
}
}
仔细看看这两个类，其实和我们写的挺类似的，可是原生的观察者我们最起码能看到两个缺点
1、首先，他的observable是一个类，且并没有提供接口，你必须设计一个类继承它。如果某类相同时具有observable类和另外一个超类的行为就会陷入两难。
2、在原生的observable中有个很关键的方法setChanged()方法，必须先调用它观察者模式才能起效果。但是这个方法被保护protected起来了,除非你继承自observable，否则你无法创建observable实例并组合到自己的对象中。违反了“多用组合，少用继承”的原则。
4、实际中的应用
在前几天开发android项目的过程中，有这么一个需求，需要从网络读取数据到本地显示，大家知道网络请求属于耗时操作，我们必须在子线程中去实现，可是项目必须在打开的时候马上显示数据，且数据请求在子线程中，我们无法准确知道什么时候能读取到数据，这时候观察者模式就起作用了。我们可以，创建一个接口listener，在网络请求成功并获取到数据后调用此接口listener，将数据传入接口中，然后给activity调用，在读取成功的接口里进行数据展示的操作。在这里每一个需要数据且注册了接口的就是观察者，发送数据接口的就是被观察者，一旦获取数据成功，就可以通知各个观察者通过接口接收数据了。
