《java与模式》-3 观察者模式

简介：
观察者模式又叫：发布-订阅模式、模型-视图模式、源-监听模式或从属模式。
定义了一种一对多的依赖关系，让多个观察者同时监听同一个主题对象，这个主题对象在状态上发生变化时，会通知所有的观察者，使他们能够自动更新自己

角色

• 抽象主题：Observable类，注册、保存、删除观察者，通知观察者
• 抽象观察者：Observer接口，只有update方法
• 具体主题角色：继承Observable，在状态改变时调用父类方法通知观察者
• 具体观察者角色：实现Observer的update方法

具体主题角色（被观察者）

package observer2.my;
import java.util.Observable;
/**
 - 被观察者
 */
public class MyObservable extends Observable {
    public void change(String str){
        // 带参数
        notifyHandlers();
        // 不带参数
        notifyHandlers(str);
    }
    /**
     * 通知所有观察者(处理者)
     */
    public void notifyHandlers() {
        // 如果有改变,后面才能执行 setChanged -->true
        setChanged();
        notifyObservers();
    }
    /**
     * 通知所有观察者(处理者)
     */
    public void notifyHandlers(Object params) {
        setChanged();
        notifyObservers(params);
    }
}

观察者

package observer2.my;
import java.util.Observable;
import java.util.Observer;
/**
 - 观察者:
 -   当事件发生的时候 执行对应方法
 */
public class MyObserve implements Observer {
    public MyObserve(Observable observable) {
        // 直接注册到 被观察者的集合
        observable.addObserver(this);
    }
    @Override
    public void update(Observable o, Object arg) {
        System.out.println("我收到了" + arg);
    }
}

测试

public class Test {
    public static void main(String[] args) {
        MyObservable myObservable = new MyObservable(); // 被观察者
        MyObserve m1 = new MyObserve(); // 观察者
        MyObserve m2 = new MyObserve(); // 观察者
        MyObserve m3 = new MyObserve(); // 观察者
        myObservable.change("哈哈哈");
    }
}

结果：
- 我收到了null
- 我收到了null
- 我收到了null
- 我收到了哈哈哈
- 我收到了哈哈哈
- 我收到了哈哈哈

观察者基类

import java.util.Observable;
import java.util.Observer;
/**
 * 观察者基类
 */
public abstract class BaseObserver implements Observer {
    /**
     * 同步执行
     */
    private boolean sync = true;
    @Override
    public void update(Observable observable, Object arg) {
        try {
            if (isSync()) {
                this.update((BaseObservable) observable, arg);
            } else {
                ObserverExecutor observerExecutor = new ObserverExecutor(this, (BaseObservable) observable, arg);
                new Thread(observerExecutor).start();
            }
        } catch (Exception e) {
            // logger.error("观察事件执行异常:", e);
        }
    }
    public boolean isSync() {
        return sync;
    }
    public void setSync(boolean sync) {
        this.sync = sync;
    }
    /**
     * 事件触发
     *
     * @param observable
     * @param arg
     */
    protected abstract void update(BaseObservable observable, Object arg);
}

/**
 * 观察者执行器
 */
class ObserverExecutor implements Runnable {
    /**
     * 观察者
     */
    private BaseObserver observer;
    /**
     * 被观察对象
     */
    private BaseObservable observableObject;
    /**
     * 执行参数
     */
    private Object arguments;

    public ObserverExecutor(BaseObserver observer, BaseObservable observableObject, Object arguments) {
        this.observer = observer;
        this.observableObject = observableObject;
        this.arguments = arguments;
    }
    @Override
    public void run() {
        observer.update(observableObject, arguments);
    }
}

消费者(被观察者)基类

import java.util.Observable;
/**
 * 消费者(被观察者)基类
 */
public abstract class BaseObservable extends Observable {
    /**
     * 通知所有观察者(处理者)
     */
    public void notifyHandlers() {
        setChanged();
        notifyObservers();
    }
    /**
     * 通知所有观察者(处理者)
     */
    public void notifyHandlers(Object params) {
        setChanged();
        notifyObservers(params);
    }
}