觀察者模式-Observer

觀察者模式很好理解，簡單來說就是：當一個對象變化時，其它依賴該對象的對象都會收到通知，並且隨着變化！對象之間是一種一對多的關系。

 

1. 自己手工創建Observer模式

首先，創建觀察者接口：

public interface Observer {
    void update();
}

Publisher接口：

public interface Publisher {
    void add(Observer observer);

    void delete(Observer observer);

    void notifyObservers();

    void operation();
}

基本功能實現（為了線程安全我們可以選擇Vector）：

import java.util.ArrayList;
import java.util.List;

public abstract class PublisherAdapter implements Publisher {
    private List<Observer> observers = new ArrayList<Observer>();

    @Override
    public void add(Observer observer) {
        observers.add(observer);
    }

    @Override
    public void delete(Observer observer) {
        observers.remove(observer);
    }

    @Override
    public void notifyObservers() {
        for (Observer observer : observers)
            observer.update();
    }

}

實現類：

public class PublisherImpl extends PublisherAdapter {

    @Override
    public void operation() {
        System.out.println("this is operation");
        notifyObservers();
    }

}

測試類：

public class Main {

    public static void main(String[] args) {
        Publisher impl = new PublisherImpl();
        impl.add(new Observer() {
            
            @Override
            public void update() {
                System.out.println("observer 1 receive");
            }
        });
        impl.add(new Observer() {
            
            @Override
            public void update() {
                // TODO Auto-generated method stub
                System.out.println("observer 2 receive");
            }
        });
        impl.operation();
    }

}

測試結果：

this is operation
observer 1 receive
observer 2 receive

 

2. 使用java.util.Observer接口

這個接口只定義了一個方法：update()。當被觀察者（observable）對象的狀態發生變化時，這個方法就會被調用。通過調用被觀察者對象的notifyObservers()方法通知所有的觀察對象。

可以定義被觀察者：

import java.util.Observable;

public class Publisher extends Observable {
    public void operation() {
        System.out.println("this is operation");
        this.setChanged();
        this.notifyObservers();
    }
}

則測試方法為：

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

public class Main {

    public static void main(String[] args) {
        Publisher publisher = new Publisher();
        publisher.addObserver(new Observer() {

            @Override
            public void update(Observable o, Object arg) {
                System.out.println("observer 1 receive");
            }
        });
        publisher.addObserver(new Observer() {

            @Override
            public void update(Observable o, Object arg) {
                System.out.println("observer 2 receive");
            }
        });
        publisher.operation();
    }

}

當然，若要獲得被觀察者的信息，可以將Observable o轉換為Publisher類型：

Publisher p = (Publisher)o;

 

3. 分析Observer與Observable

如前所述，Observer接口只定義了一個方法：update()。當被觀察者對象的狀態發生變化時，這個方法就會被調用。java.util.Observer接口定義如下：

package java.util;

public interface Observer {
    void update(Observable o, Object arg);
}

 

被觀察者類都是java.util.Observable類的子類。java.util.Observable提供公開的方法支持觀察者對象，這些方法中有兩個非常重要：一個是setChanged()，被調用之后會設置一個內部標記變量，代表被觀察者對象的狀態發生了變化；另一個是notifyObservers()，這個方法被調用時，會調用所有登記過的觀察者對象的update()方法。

package java.util;

public class Observable {
    private boolean changed = false;
    private Vector 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);
    }

    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();
    }
}

 

可用如下類圖表示（圖片來自於網絡）：

一個Observable類代表一個被觀察者對象。一個被觀察者對象可以有多個觀察者，一個觀察者是一個實現Observer接口的對象。在被觀察者對象發生變化時，它會調用notifyObservers方法，此方法再調用所有觀察者的update()方法。

同時，發通知的順序在這里並沒有指明。Observerable類所提供的缺省實現會按照Observers對象被登記的次序通知它們（遍歷Vector），當然，我們可以在子類中改變這一次序。子類還可以在單獨的線程里通知觀察者對象、或者在一個公用的線程里按照次序執行。

當一個可觀察者對象剛剛創立時，它的觀察者集合是空的。兩個觀察者對象在它們的equals()方法返回true時，被認為是兩個相等的對象。

 

4. 觀察者模式總結

來自於：http://www.cnblogs.com/forlina/archive/2011/06/23/2088121.html

優點：

　　第一、觀察者模式在被觀察者和觀察者之間建立一個抽象的耦合。被觀察者角色所知道的只是一個具體觀察者列表，每一個具體觀察者都符合一個抽象觀察者的接口。被觀察者並不認識任何一個具體觀察者，它只知道它們都有一個共同的接口。 由於被觀察者和觀察者沒有緊密地耦合在一起，因此它們可以屬於不同的抽象化層次。
　　第二、觀察者模式支持廣播通訊。被觀察者會向所有的登記過的觀察者發出通知

缺點：
　　第一、如果一個被觀察者對象有很多的直接和間接的觀察者的話，將所有的觀察者都通知到會花費很多時間。
　　第二、如果在被觀察者之間有循環依賴的話，被觀察者會觸發它們之間進行循環調用，導致系統崩潰。在使用觀察者模式是要特別注意這一點。
　　第三、如果對觀察者的通知是通過另外的線程進行異步投遞的話，系統必須保證投遞是以自恰的方式進行的。
　　第四、雖然觀察者模式可以隨時使觀察者知道所觀察的對象發生了變化，但是觀察者模式沒有相應的機制使觀察者知道所觀察的對象是怎么發生變化的。