Java设计模式--观察者模式

观察者模式的定义为：在对象之间定义一对多的依赖，当对象改变时，依赖他的对象都会收到改变通知。
观察者模式在JDK里面是使用最多的模式之一，尤其是在Java图形界面编程的时候，经常会遇到定义一个按钮，当按钮按下时会改变其他的界面，这是观察者模式 的典型应用。

Paste_Image.png

subjet是抽象被观察主题，所有实现这个借口的类都可以被观察。
ConcreatSubject是具体的被观察对象。
Observer是抽象观察者，他只有一个update方法，当被观察的对象发生改变时会调用这个方法。
ConcreatObserver时具体的观察者

举例，在游戏中当英雄的血量发生改变时用户面板会立即收到改变的通知并重新显示当前血量。
抽象被观察主题：

public interface Subject {
    public void registerObserver(MyObserver myObserver);
    public void removeObserver(MyObserver myObserver);
    public void notifyObserve();
}

具体被观察类Hero

public class Hero implements Subject{

    private ArrayList<MyObserver> myObservers;
    private int bloodPoint;
    
    public Hero() {
        this.myObservers = new ArrayList<MyObserver>();
        this.bloodPoint = 0;
    }
    
    @Override
    public void registerObserver(MyObserver myObserver) {
        this.myObservers.add(myObserver);
    }
    @Override
    public void removeObserver(MyObserver myObserver) {
        this.myObservers.remove(myObserver);
    }

    @Override
    public void notifyObserve() {
        for(MyObserver myObserver : myObservers){
            myObserver.update(bloodPoint);
        }
    }
    
    private void booledChange(){
        notifyObserve();
    }
    
    public void setbloodPoint(int i){
        this.bloodPoint = i;
        booledChange();
    }
    
    public int getBooleadPoint(){
        return this.bloodPoint;
    }
}

观察者接口

public interface MyObserver {
    public void update(int booldPoint);
}

具体的观察者（用户面板）

public class ShowPanel implements MyObserver{
    private Subject subject;
    private int bloodPoint;
    
    public ShowPanel(Subject subject) {
        this.subject = subject;
        subject.registerObserver(this);
    }
    
    @Override
    public void update(int booldPoint) {
        this.bloodPoint = booldPoint;
        display();
    }
    
    public void display(){
        System.out.println("当前血量为"+bloodPoint);
    }
}

测试类：

public class Test {
    public static void main(String[] args) {
        Hero hero = new Hero();
        ShowPanel showPanel = new ShowPanel(hero);
        
        hero.setbloodPoint(10);
        hero.setbloodPoint(20);
        hero.setbloodPoint(30);
    }
}

每当Hero的血量发生改变时ShowPanel都会接到通知并显示当前血量，测试结果如下：

当前血量为10
当前血量为20
当前血量为30

这个例子基本上将观察者模式实现了一遍，但是在我们实际编程时大多不需要这么麻烦，因为Java API有内置的观察者模式，Java.util包里面包含了基本的Observer接口和Observable类，实际使用时只需要将观察者去实现Observer接口，被观察对象去继承Observable类即可。
Java自带的Observable与例子中写的略有不同，这是Observer接口的update方法

void update(Observable o, Object arg);

它包含了两个参数：被观察对象和一个arg参数
而Observable里面提供了两个notify方法：

public void notifyObservers() {
        notifyObservers(null);
    }
public void notifyObservers(Object arg) {
        /*
         * a temporary array buffer, used as a snapshot of the state of
         * current Observers.
         */
        Object[] arrLocal;
        synchronized (this) {
            if (!changed)
                return;
            arrLocal = obs.toArray();
            clearChanged();
        }

        for (int i = arrLocal.length-1; i>=0; i--)
            ((Observer)arrLocal[i]).update(this, arg);
    }

使用notifyObservers()方法时观察者可以根据被观察者提供的getter方法去拿到自己想要了解的参数，而我们的例子中只提供了血量改变值，当需要增加Hero类的属性时（如增加一个魔法值）update方法必须改变，这是非常不好的。
使用notifyObservers(Object arg)方法时被观察者自己推送了哪些值发生了改变，这样观察者不需要每一个值都去自己取，只需要解析arg参数就能知道哪些发生了改变。

总结：

使用场景：
一个对象（目标对象）的状态发生改变，所有的依赖对象（观察者对象）都将得到通知，进行广播通知。
优点：
1、观察者和被观察者是抽象耦合的。
2、建立一套触发机制。
缺点：
1、如果一个被观察者对象有很多的直接和间接的观察者的话，将所有的观察者都通知到会花费很多时间。
2、如果在观察者和观察目标之间有循环依赖的话，观察目标会触发它们之间进行循环调用，可能导致系统崩溃。
3、观察者模式没有相应的机制让观察者知道所观察的目标对象是怎么发生变化的，而仅仅只是知道观察目标发生了变化。