java设计模式-观察者模式

观察者模式

当对象间存在一对多关系时，则使用观察者模式（Observer Pattern）。比如，当一个对象被修改时，则会自动通知它的依赖对象。观察者模式属于行为型模式。

设计原则：为了交互对象之间的松耦合设计而努力。

观察者模式-在对象之间定义一对多的依赖，这样一来，当一个对象改变状态，依赖它的对象都会收到通知，并自动更新

设计背景

报社的业务就是出版报纸，向某一家报社订阅报纸，只要他们有新报纸出版，就会给你送来。只要你是他们的订户，你就会一直收到新报纸。只要你不想再看报纸的时候，取消订阅，他们就不会再送新报纸来。只要报社还在运营，就会一直有人向他们订阅报纸或取消订阅报纸。

模式结构和定义

subject为主题接口（被观察者），Observe为观察者接口，将主题作为成员变量。将自己注册到主题的观察者列表中，每当主题中的状态改变时，主题会调用notifyObservers()方法循环调用所有的观察者的update方法，通知所有的观察者。

应用实例

示例1:自己实现观察者模式

/**
* 主题（被观察者）
*
* @author shengyong.huang
* @date 2019/9/4
*/
public class Subject {
    /**
     * 观察者列表
     */
    List<Observer> observers = new ArrayList<>();
    /**
     * 被观察的状态
     */
    int state;
    /**
     * 获取状态
     *
     * @return
     */
    public int getState() {
        return state;
    }
    /**
     * 改变状态
     *
     * @param state
     */
    public void setState(int state) {
        this.state = state;
        // 状态被改变，通知所有观察者
        notifyAllObservers();
    }
    /**
     * 注册为观察者
     *
     * @param observer
     */
    public void attach(Observer observer) {
        observers.add(observer);
    }
    /**
     * 通知所有观察者
     */
    public void notifyAllObservers() {
        for (Observer observer : observers) {
            observer.update();
        }
    }
}
/**
* 观察者父类
*
* @author shengyong.huang
* @date 2019/9/4
*/
public abstract class Observer {
    /**
     * 主题（被观察者）
     */
    protected Subject subject;
    /**
     * 当观察值被改变时调用
     */
    public abstract void update();
}
/**
* 观察者A
*
* @author shengyong.huang
* @date 2019/9/4
*/
public class ObserverA extends Observer {
    /**
     * 构造方法中向主题注册自己
     *
     * @param subject 主题对象
     */
    public ObserverA(Subject subject) {
        this.subject = subject;
        this.subject.attach(this);
    }
    @Override
    public void update() {
        System.out.println("ObserverA receive " + subject.getState());
    }
}
/**
* 观察者B
*
* @author shengyong.huang
* @date 2019/9/4
*/
public class ObserverB extends Observer {
    /**
     * 构造方法中向主题注册自己
     *
     * @param subject 主题对象
     */
    public ObserverB(Subject subject) {
        this.subject = subject;
        this.subject.attach(this);
    }
    @Override
    public void update() {
        System.out.println("ObserverB receive " + subject.getState());
    }
}
/**
* 观察者C
*
* @author shengyong.huang
* @date 2019/9/4
*/
public class ObserverC extends Observer {
    /**
     * 构造方法中向主题注册自己
     *
     * @param subject 主题对象
     */
    public ObserverC(Subject subject) {
        this.subject = subject;
        this.subject.attach(this);
    }
    @Override
    public void update() {
        System.out.println("ObserverC receive " + subject.getState());
    }
}
/**
* 测试方法
*
* @author shengyong.huang
* @date 2019/9/4
*/
public class TestMain {
    public static void main(String[] args) {
        // 主题对象（被观察者）
        Subject subject = new Subject();
        // 新建观察者对象，并向主题对象注册
        Observer observerA = new ObserverA(subject);
        Observer observerB = new ObserverB(subject);
        Observer observerC = new ObserverC(subject);
        // 改变主题对象中的状态，同时通知所有观察者
        subject.setState(0);
        subject.setState(1);
    }
}

示例2:使用JAVA自带的Observable和类Observer实现

import java.util.Observable;
/**
* java内置主题对象
*
* @author shengyong.huang
* @date 2019/9/4
*/
public class BuiltInSubject extends Observable {
    /**
     * 状态值
     */
    private int state;
    /**
     * 获取状态
     * @return
     */
    public int getState() {
        return state;
    }
    /**
     * 改变状态
     * @param state 状态值
     */
    public void setState(int state) {
        this.state = state;
        // 状态值改成成功，必须调用setChanged，将changed设置为true，标志状态已更新，否则调用notifyObservers不起作用
        // notifyObservers方法中对changed变量有做判断，每次通知完成之后会把changed设置为false。
        setChanged();
        // 直接通知不传参数
//        notifyObservers();
        // 通知并且传递参数
        notifyObservers("参数对象");
    }
}
import java.util.Observable;
import java.util.Observer;
/**
* java内置观察者对象
*
* @author shengyong.huang
* @date 2019/9/4
*/
public class BuiltInObserverA implements Observer {
    /**
     * 内置主题对象
     */
    private Observable observable;
    /**
     * 构造方法中向主题对象注册自己
     *
     * @param observable 主题对象
     */
    public BuiltInObserverA(Observable observable) {
        this.observable = observable;
        observable.addObserver(this);
    }
    @Override
    public void update(Observable o, Object arg) {
        System.out.println(observable.countObservers());
        if (o instanceof BuiltInSubject) {
            BuiltInSubject subject = (BuiltInSubject) o;
            System.out.println("ObserverA receive " + subject.getState() + " arg :" + arg);
        }
    }
}
import java.util.Observer;
/**
* 测试方法
*
* @author shengyong.huang
* @date 2019/9/4
*/
public class BuiltInTestMain {
    public static void main(String[] args) {
        BuiltInSubject builtInSubject = new BuiltInSubject();
        Observer builtInObserverA = new BuiltInObserverA(builtInSubject);
        builtInSubject.setState(0);
        builtInSubject.setState(1);
    }
}

优点和不足

优点

• 观察者和被观察者是抽象耦合的。
• 建立一套触发机制。

缺点

• 如果一个被观察者对象有很多的直接和间接的观察者的话，将所有的观察者都通知到会花费很多时间。 那么一个观察者卡顿，会影响整体的执行效率，在这种情况下，一般会采用异步实现。
• 如果在观察者和观察目标之间有循环依赖的话，观察目标会触发它们之间进行循环调用，可能导致系统崩溃

使用场景

• 事件多级触发场景。
• 跨系统的消息交换场景，如消息队列、事件总线的处理机制。