Java 设计模式_观察者模式

Java 设计模式_观察者模式

---

本文由 Luzhuo 编写,转发请保留该信息.
原文: http://blog.csdn.net/Rozol/article/details/76285929

---

定义对象之间的一种一对多依赖关系, 让多个观察者对象同时监听某一特定对象. 使得每当该特定对象状态发生改变时, 其相关依赖的观察者对象都会收到通知, 使他们能够进行自我更新等操作
观察者模式分为: 观察者模式 / 回调模式

观察者模式

/**
 * 观察者接口
 * @author Luzhuo
 */
public interface Observer {
    /**
     * 更新接口, 用于通知观察者数据已更新
     * @param state
     */
    void update(String message);
}

/**
 * 具体的观察者对象
 * @author Luzhuo
 */
public class ContentObserver implements Observer{

    /**
     * 需手动调用Observable对象的注册方法
     */
    public ContentObserver(){ }

    public ContentObserver(Observable observable) {
        observable.register(this);
    }

    @Override
    public void update(String message) {
        System.out.println("观察者收到信息: " + message);
    }
}

• 定义观察者ContentObserver , 用于观察被观察的对象

/**
 * 被观察的对象抽象类
 * @author Luzhuo
 */
public abstract class Observable {
    /**
     * 保存注册的观察者对象
     */
    private List observers = new ArrayList<>();

    /**
     * 注册观察者对象
     * @param observer
     */
    public void register(Observer observer){
        observers.add(observer);
    }

    /**
     * 注销观察者对象
     * @param observer
     */
    public void unRegister(Observer observer){
        observers.remove(observer);
    }

    /**
     * 通知所有注册的观察者对象
     * @param newState
     */
    public void notifyObservers(String newState){
        for (Observer observer : observers){
            observer.update(newState);
        }
    }
}

/**
 * 被观察的对象具体类
 * @author Luzhuo
 */
public class ContentObservable extends Observable{
    private String mMessage;

    public String getMessage(){
        return mMessage;
    }

    public void change(String message){
        System.out.println("被观察者收到信息: " + message);

        mMessage = message;
        // 状态发生改变, 通知所有已注册的观察者
        notifyObservers(message);
    }
}

• 定义被观察对象ContentObservable ,首先要把观察者添加到自己(被观察对象)的集合中, 当自己发生改变时,通过调用每个观察者的 update 接口告知数据改变

public class Test {
    public static void main(String[] args) {
        // 创建被观察的对象
         ContentObservable observable = new ContentObservable();
         // 创建观察者对象, 并将观察者注册到被观察者对象上, 以便被观察者发生变化时通知观察者
         Observer observer = new ContentObserver(observable);

         // 创建多个观察者
         new ContentObserver(observable);
         new ContentObserver(observable);

         // 被观察者状态发生改变
         observable.change("change");

         // 注销观察者
         observable.unRegister(observer);

         observable.change("change111");
    }
}

使用系统自带的观察者模式

/**
 * 具体观察者对象
 * @author Luzhuo
 */
public class TargetObserver implements Observer{

    /**
     * 需手动调用Observable对象的注册方法
     */
    public TargetObserver(){ }

    public TargetObserver(Observable observable) {
        observable.addObserver(this);
    }

    @Override
    public void update(Observable o, Object arg) {
        String message = ((TargetObservable)o).getMessage();
        System.out.println("观察者收到消息: " + message);
    }
}

• 定义观察者对象TargetObserver

public class TargetObservable extends Observable{
    private String message;

    public String getMessage(){
        return message;
    }

    public void change(String message){
        System.out.println("被观察者收到信息: " + message);

        this.message = message;
        this.setChanged();
        this.notifyObservers(message);
    }
}

• 定义被观察者对象.
• 可见, 不管是定义观察者对象,还是定义被观察者对象, (甚至使用方法)都与自己写的观察者模式代码相差无几

public class Test {
    public static void main(String[] args) {
         // 创建被观察者对象
         TargetObservable observable = new TargetObservable();
         // 创建观察者对象
         Observer observer = new TargetObserver(observable);

         // 创建多个观察者
         new TargetObserver(observable);
         new TargetObserver(observable);

         // 被观察者状态发生改变
         observable.change("start");
         observable.change("stop");

         // 注销观察者
         observable.deleteObserver(observer);

         observable.change("run");
    }
}

回调模式

/**
 * 回调接口, 一般用于异步中, 属于简洁型的观察者模式
 * @author Luzhuo
 */
public class AsyncTask {

    // 定义回调接口的成员变量
    private Callback callback;

    /**
     * 声明回调接口
     * @author Luzhuo
     */
    public interface Callback{
        public abstract void onCallback();
    }

    /**
     * 设置回调接口对象成员变量
     * @param callback
     */
    public void setCallbackListener(Callback callback){
        this.callback = callback;
    }

    /**
     * 调用回调接口对象中的方法
     */
    public void call(){
        callback.onCallback();
    }
}

• 回调模式可算是一种迷你型的观察者模式, 非常轻巧, 经常用于异步任务的回调

public class Test {
    public static void main(String[] args) {
        AsyncTask task = new AsyncTask();
        task.setCallbackListener(callback);
        task.call();
    }

    private static AsyncTask.Callback callback = new AsyncTask.Callback() {

        @Override
        public void onCallback() {
            System.out.println("这是一个异步任务的回调.");
        }
    };
}