观察者模式

一、概念

观察者模式又称为发布订阅模式，观察者模式定义了一对多的依赖关系，让多个观察者同时监视着被观察者的状态

二、简单实现观察者模式

• 被观察者需要继承Observable类
• 观察者需要实现Observer接口，实现upate方法

1、被观察者代码：

import java.util.Observable;
import java.util.Observer;

public class Observered extends Observable {

    //Observered开启线程安全的单例模式
    private static Observered observered;

    private Observered(){}

    public static Observered getInstance() {
        if (observered == null) {
            synchronized (Observered.class) {
                if (observered == null) {
                    observered = new Observered();
                }
            }
        }
        return observered;
    }

    /**
     * 添加观察者
     *
     * @param observer
     */
    public void addObserver (Observer observer) {
        this.addObserver(observer);
    }

    /**
     * 添加变更
     *
     * @param change
     */
    public void addChange (String change) {
        System.out.println("被观察者有更改，change = " + change);
        this.addChange(change);
        this.setChanged();
        this.notifyObservers(change);
    }
}

2、观察者1、2、3

观察者Obsever1

import java.util.Observable;
import java.util.Observer;

public class Obsever1 implements Observer {
    @Override
    public void update(Observable o, Object arg) {
        String change = (String)arg;
        System.out.println("Obsever1 收到变更通知：change = " + change);
    }
}

观察者Obsever2

import java.util.Observable;
import java.util.Observer;

public class Obsever2 implements Observer {
    @Override
    public void update(Observable o, Object arg) {
        String change = (String)arg;
        System.out.println("Obsever2 收到变更通知：change = " + change);
    }
}

观察者Obsever3

import java.util.Observable;
import java.util.Observer;

public class Obsever3 implements Observer {
    @Override
    public void update(Observable o, Object arg) {
        String change = (String)arg;
        System.out.println("Obsever3 收到变更通知：change = " + change);
    }
}

4、客户端

public class Client {
    public static void main(String[] args) {
        //1、生成被观察者
        Observered observered = Observered.getInstance();
        //2、添加观察者
        Obsever1 obsever1 = new Obsever1();
        Obsever2 obsever2 = new Obsever2();
        Obsever3 obsever3 = new Obsever3();
        observered.addObserver(obsever1);
        observered.addObserver(obsever2);
        observered.addObserver(obsever3);
        
        //3、添加变更消息
        observered.addChange("德哥来了，各地准备迎接");

    }
}

三、被观察者Observable源码解析（使用重量级锁）

来源：java.util.Observable

package java.util;
@Deprecated(since="9")
public class Observable {
    private boolean changed = false;		//被观察者变更标志
    private Vector<Observer> obs;			//观察者列表（线程安全）

    public Observable() {
        obs = new Vector<>();
    }
    
	/**
	*	添加观察者
	*/
    public synchronized void addObserver(Observer o) {
        if (o == null)
            throw new NullPointerException();
        if (!obs.contains(o)) {
            obs.addElement(o);
        }
    }

   /**
   * 删除观察者
   */
    public synchronized void deleteObserver(Observer o) {
        obs.removeElement(o);
    }

    /**
    * 变更通知所有观察者
    */
    public void notifyObservers() {
        notifyObservers(null);
    }

    public void notifyObservers(Object arg) {
        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);		//调用观察者实现的update接口
    }

    /**
     * 删除所有观察者
     */
    public synchronized void deleteObservers() {
        obs.removeAllElements();
    }

    /**
     * 线程安全下改变被观察者的变更标志
     */
    protected synchronized void setChanged() {
        changed = true;
    }
    
    /**
     * 线程安全下清除被观察者的变更标志
     */
    protected synchronized void clearChanged() {
        changed = false;
    }

    
    public synchronized boolean hasChanged() {
        return changed;
    }

    public synchronized int countObservers() {
        return obs.size();
    }
}

四、观察者Observer源码解析

package java.util;
@Deprecated(since="9")
public interface Observer {
 	/**
 	* 回调接口，所有观察者需要实现该接口
 	*/
    void update(Observable o, Object arg);
}