设计模式（19）：观察者模式 Observer

观察者模式貌似就是传说中的Listener吧~

观察者模式 Observer

观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态上发生变化时，会通知所有观察者对象，使他们能够自动更新自己。

问题：

A large monolithic design does not scale well as new graphing or monitoring requirements are levied.

意图：

• Define a one-to-many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically.
• Encapsulate the core (or common or engine) components in a Subject abstraction, and the variable (or optional or user interface) components in an Observer hierarchy.
• The “View” part of Model-View-Controller.

例：这个模式比较像SQL里面的trigger,但实际用起来比较郁闷，说白了就是两个对象互调，就像AWT里面的我把按钮点一下，想要调用一个方法，需要ADDLISTENER之类的玩意。这种代码苦逼啊

代码1：观察者（监听器）接口，以类不同类型的实现

public interface Observer {
    public void update(Subject sub);
}
public class LogicObserver  implements Observer{
    @Override
    public void update(Subject sub) {
        if(sub.getState()==Subject.TRAN_ERROR)
        System.out.println("警告，对象"+ sub.toString()+"出了逻辑问题" );
    }
}
public class SafeObserver implements Observer{
    @Override
    public void update(Subject sub) {
        if(sub.getState()==Subject.SAFE_ERROR)
        System.out.println("警告，对象"+ sub.toString()+"出了安全问题" );
    }
}

代码2：需要监听的对象，简单来几个实例

import java.util.ArrayList;
/**
 *  @author xdnote.com
 * 需要监听的对象，实现Subject类，并通过addListener注册
 * */
public class Subject {

    public static int SAFE_ERROR = 1;

    public static int TRAN_ERROR = 2;

    private int state =0;

    public int getState() {
        return state;
    }

    public void setState(int state) {
        this.state = state;
        this.notice();
    }

    private ArrayList<Observer> listeners = new ArrayList<Observer>();

    public void addListener(Observer listener){
        this.listeners.add(listener);
    }

    private void notice(){
        for(int i=0,j=this.listeners.size();i<j;i++){
            listeners.get(i).update(this);
        }
    }
}
public class Subject1 extends Subject{

    @Override
    public String toString() {
        return "对象 Subject1 ";
    }
}
public class Subject2 extends Subject{

    @Override
    public String toString() {
        return "对象 Subject2 ";
    }
}

代码3：客户端调用

public static void main(String[] args) {
    Subject sub1 = new Subject1();
    sub1.addListener(new SafeObserver());
    sub1.setState(Subject.SAFE_ERROR);
    sub1.setState(Subject.TRAN_ERROR);

    sub1.addListener(new LogicObserver());
    sub1.setState(Subject.TRAN_ERROR);

    Subject2 sub2 = new Subject2();
    sub2.setState(Subject.TRAN_ERROR);
    sub2.addListener(new LogicObserver());
    sub2.setState(Subject.TRAN_ERROR);
}

小结

观察者模式 Observer

• 使用频率：低
  说实话，写了这么多的代码，行为型的模式真的都见得少，构造型的模式到处可见，主要是逻辑型的东西都喜欢自己解决，懒得去写那么多的模式去弄，或根本就没有考虑到模式，还是或者说，编程时更趋向于自己感知中认为安全的写法（也就是最基础的写法）呢？

• 利弊影响：中
  这个模式有点恶心，需要被观查者“配合”才能实现。