設計模式之觀察者模式

　　今天放假，又有時間繼續啃《java設計模式》這本書了。每次學會一種設計模式內心都會有一種小小的成就感，但是懂是懂了，不知道會不會用。主要是現在沒有什么項目經驗，設計模式學了也派不上用場。不管怎樣，學了總比沒學好，以后總會派上用場的。

　　首先，何為觀察者模式？觀察者模式是關於多個對象想知道一個對象中數據的變化的情況一種模式。比如說現在幾乎所有的高校附近都會有大學生兼職中心，也就是兼職中介吧（大一大二的時候還去過，加會員還交了100大洋呢。），兼職中心每天都會把兼職信息通知給所有的會員。這就是一個觀察者模式，這里會員也就是觀察者，兼職中心就是被觀察者，也稱作主題。

　　觀察者模式結構中包括四種角色：

　　一、主題：主題是一個接口，該接口規定了具體主題需要實現的方法，比如添加、刪除觀察者以及通知觀察者更新數據的方法。

　　二、觀察者：觀察者也是一個接口，該接口規定了具體觀察者用來更新數據的方法。

　　三、具體主題：具體主題是一個實現主題接口的類，該類包含了會經常發生變化的數據。而且還有一個集合，該集合存放的是觀察者的引用。

　　四：具體觀察者：具體觀察者是實現了觀察者接口的一個類。具體觀察者包含有可以存放具體主題引用的主題接口變量，以便具體觀察者讓具體主題將自己的引用添加到具體主題的集合中，讓自己成為它的觀察者，或者讓這個具體主題將自己從具體主題的集合中刪除，使自己不在時它的觀察者。

　　在上面的兼職中心的例子中，兼職中心就是一個具體主題，它可以更新各種兼職信息，並且通知給它的會員，當然還可以增加會員和刪除會員。會員就是一個觀察者，它關注着兼職中心的信息，能夠及時收到兼職中心更新過來的信息。

　　代碼如下：

　　1.主題

package com.observer;

public interface Subject {
    void addObserver(Observer o);
    void deleteObserver(Observer o);
    void notifyObservers();
}

　　2.具體主題

package com.observer;

import java.util.ArrayList;

public class SeekJobCenter implements Subject {
    String mess;
    boolean changed;
    ArrayList<Observer> personList;
    public SeekJobCenter() {
        personList = new ArrayList<Observer>();
        mess = "";
        changed = false;
    }
    //添加求職者
    public void addObserver(Observer o) {
        if(!(personList.contains(o))){
            personList.add(o);
        }
    }
    //刪除求職者
    public void deleteObserver(Observer o) {
        if(personList.contains(o)){
            personList.remove(o);
        }
    }
    //通知所有求職者
    public void notifyObservers() {
        if(changed){
            for (int i = 0; i < personList.size(); i++) {
                Observer o = personList.get(i);
                o.hearTelephone(mess);
            }
            changed = false;
        }
    }
    //刷新信息
    public void giveNewMess(String str){
        if(str.equals(mess)){
            changed = false;
        }else{
            mess = str;
            changed = true;
        }
    }

}

　　3.觀察者

package com.observer;

public interface Observer {
    public void hearTelephone(String mess);
}

　　4.具體觀察者

　　在該例子中，具體觀察者有兩個，一個關注兼職中心的所有信息，另一個只關注“促銷員”和“發單員”的兼職信息。

　　UniversityStudent.java

package com.observer;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.RandomAccessFile;

public class UniversityStudent implements Observer{
    Subject subject;
    File myFile;
    public UniversityStudent(Subject subject,String fileName) {
        this.subject = subject;
        subject.addObserver(this);
        myFile = new File(fileName);
    }
    public void hearTelephone(String mess) {
        try {
            RandomAccessFile out = new RandomAccessFile(myFile,"rw");
            out.seek(out.length());
            byte[] b = mess.getBytes();
            out.write(b);
            System.out.println("我是會員一");
            System.out.println("我向文件"+myFile.getName()+"寫入如下內容：");
            System.out.println(mess);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    
}

　　UniversityStudent2.java

package com.observer;

import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;

public class UniversityStudent2 implements Observer {
    Subject subject;
    File myFile;
    public UniversityStudent2(Subject subject,String fileName) {
        this.subject = subject;
        subject.addObserver(this);
        myFile = new File(fileName);
    }
    public void hearTelephone(String mess) {
        try {
            boolean boo = mess.contains("促銷員")||mess.contains("發單員");
            if(boo){
                RandomAccessFile out = new RandomAccessFile(myFile,"rw");
                out.seek(out.length());
                byte[] b = mess.getBytes();
                out.write(b);
                System.out.println("我是會員二");
                System.out.println("我向文件"+myFile.getName()+"寫入如下內容：");
                System.out.println(mess);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

下面寫一個測試程序：

package com.observer;

public class Application {
    /**
     * @param args
     */
    public static void main(String[] args) {
        SeekJobCenter center = new SeekJobCenter();
        UniversityStudent zhanglin = new UniversityStudent(center,"zhanglin.txt");
        UniversityStudent2 wangHao = new UniversityStudent2(center,"wanghao.txt");
        center.giveNewMess("XX公司需要10個促銷員。");
        center.notifyObservers();
        center.giveNewMess("XX公司需要8個發單員。");
        center.notifyObservers();
        center.giveNewMess("XX公司需要9個臨時工。");
        center.notifyObservers();
        center.giveNewMess("XX公司需要9個臨時工。");
        center.notifyObservers();
    }

}

　　運行結果如下：

我是會員一
我向文件zhanglin.txt寫入如下內容：
XX公司需要10個促銷員。
我是會員二
我向文件wanghao.txt寫入如下內容：
XX公司需要10個促銷員。
我是會員一
我向文件zhanglin.txt寫入如下內容：
XX公司需要8個發單員。
我是會員二
我向文件wanghao.txt寫入如下內容：
XX公司需要8個發單員。
我是會員一
我向文件zhanglin.txt寫入如下內容：
XX公司需要9個臨時工。

　　兼職中心這個例子使用的事觀察者模式中的“推”數據方式，也就是說具體主題將變化后的信息全部發送給具體觀察者。這種方式往往適用於具體主題認為具體觀察者需要這些變化后的全部數據時。

　　設計模式中還有另外一種方式也就是“拉”數據方式。如果使用這種方式，具體主題信息一更新，它只會通知所有的觀察者：“我的信息已經更新”，具體觀察者就可以調用相關方法，獲得自己需要的那部分信息。

　　下面看另外一個例子：

　　問題描述：一家商店每天都發布當天打折商品的名字、原價和折后價，有兩位顧客對此信息很感興趣，但是一位顧客只關心打折商品的名稱，而另一位顧客只關心原價和折后價。

　　1.主題：

package com.observer1;

public interface Subject {
    void addObserver(Observer o);
    void deleteObserver(Observer o);
    void notifyObservers();
}

　　2.具體主題：

package com.observer1;

import java.util.ArrayList;

public class ShopSubject implements Subject {
    String goodsName;
    double oldPrice,newPrice;
    ArrayList<Observer> customerList;
    public ShopSubject() {
        customerList = new ArrayList<Observer>();
    }
    public void addObserver(Observer o) {
        if(!(customerList.contains(o))){
            customerList.add(o);
        }
    }

    public void deleteObserver(Observer o) {
        if(customerList.contains(o)){
            customerList.remove(o);
        }
    }

    public void notifyObservers() {
        for (int i = 0; i < customerList.size(); i++) {
            Observer o = customerList.get(i);
            o.update();
        }
    }
    //設置打折商品
    public void setDiscountGoods(String name,double oldP,double newP){
        goodsName = name;
        oldPrice = oldP;
        newPrice = newP;
        //設置完通知顧客
        notifyObservers();
    }
    public String getGoodsName() {
        return goodsName;
    }
    public double getOldPrice() {
        return oldPrice;
    }
    public double getNewPrice() {
        return newPrice;
    }
    

}

　　3.觀察者：

　　這里不是由具體主題直接更新數據過來，所以update()方法不需要傳參數過來。

package com.observer1;

public interface Observer {
    public void update();
}

　　4.具體觀察者：

CustomerOne對象的顧客只對打折商品的名字感興趣，對其他信息不感興趣。

CustomerOne.java

package com.observer1;

public class CustomerOne implements Observer {
    Subject subject;
    String goodsName,personName;
    public CustomerOne(Subject subject,String personName) {
        this.personName = personName;
        this.subject = subject;
        subject.addObserver(this);
    }
    public void update() {
        if(subject instanceof ShopSubject){
            goodsName = ((ShopSubject)subject).getGoodsName();
            System.out.println(personName+"只對打折商品的名字感興趣：");
            System.out.println("打折商品的名字是："+goodsName);
        }
    }

}

CustomerTwo的對象的顧客只對商品原價和折后價感興趣，對商品名稱不感興趣。　　

CustomerTwo.java

package com.observer1;

public class CustomerTwo implements Observer {
    Subject subject;
    String personName;
    double oldPrice,newPrice;
    public CustomerTwo(Subject subject,String personName) {
        this.personName = personName;
        this.subject = subject;
        subject.addObserver(this);
    }
    public void update() {
        if(subject instanceof ShopSubject){
            oldPrice = ((ShopSubject)subject).getOldPrice();
            newPrice = ((ShopSubject)subject).getNewPrice();
            System.out.println(personName+"只對打折商品的原價和折后價感興趣：");
            System.out.println("打折商品的原價是："+oldPrice);
            System.out.println("打折商品的折后價是："+newPrice);
        }
    }

}

　　下面寫一個測試程序：

package com.observer1;

public class Application {
    public static void main(String[] args) {
        ShopSubject shop = new ShopSubject();
        CustomerOne boy  = new CustomerOne(shop,"小明");
        CustomerTwo girl = new CustomerTwo(shop,"小紅");
        shop.setDiscountGoods("Photo數碼相機", 2345.6, 2020.0);
        shop.setDiscountGoods("三星手機", 2999.0, 2499.0);
    }
}

運行結果為：

小明只對打折商品的名字感興趣：
打折商品的名字是：Photo數碼相機
小紅只對打折商品的原價和折后價感興趣：
打折商品的原價是：2345.6
打折商品的折后價是：2020.0
小明只對打折商品的名字感興趣：
打折商品的名字是：三星手機
小紅只對打折商品的原價和折后價感興趣：
打折商品的原價是：2999.0
打折商品的折后價是：2499.0

 

 

觀察者與多主題

　　上面兩個例子所講的都是一個具體主題多個觀察者的情況。還有一種情況就是一個具體觀察者觀察多個主題，當觀察的任何具體主題的信息發生變化時，該觀察者都能得到通知。在使用多主題時，主題應該采用拉數據方式，觀察者接口可以將更新數據方法的參數類型設置為主題接口類型，比如update(Subject subject),即具體主題數據發生改變時，將自己的引用傳遞給具體觀察者，然后具體觀察者讓這個具體主題調用相關方法獲得信息。

　　下面是一個簡單的多主題例子

　　問題描述：李先生計划去旅游，那么他需要關注旅行社的信息，同時還要關注旅行地區的天氣問題。

　　根據觀察者模式，李先生就是一個具體觀察者，而氣象站和旅行社就是他觀察的兩個具體主題。主要代碼如下：

　　1.主題

package com.observer2;

public interface Subject {
    void addObserver(Observer o);
    void deleteObserver(Observer o);
    void notifyObservers();
}

　　2.觀察者

package com.observer2;

public interface Observer {
    public void update(Subject subject);
}

　　3.具體主題：

TravelAgency.java

package com.observer2;

import java.util.ArrayList;

public class TravelAgency implements Subject{
    String tourStartTime;
    String tourMess;
    ArrayList<Observer> personList;
    public TravelAgency() {
        personList = new ArrayList<Observer>();
    }
    public void addObserver(Observer o) {
        if(o == null){
            return;
        }else{
            if(!(personList.contains(o))){
                personList.add(o);
            }
        }
    }
    public void deleteObserver(Observer o) {
        if(personList.contains(o)){
            personList.remove(o);
        }
        
    }
    public void notifyObservers() {
        for (int i = 0; i < personList.size(); i++) {
            Observer o = personList.get(i);
            o.update(this);
        }
    }
    public void giveMess(String time,String mess){
        tourStartTime = time;
        tourMess = mess;
        notifyObservers();
    }
    public String getTourStartTime() {
        return tourStartTime;
    }
    public String getTourMess() {
        return tourMess;
    }
}

WeaherStation.java

package com.observer2;

import java.util.ArrayList;

public class WeaherStation implements Subject{
    String forecastTime,forcastMess;
    int maxPemperature,minTemperature;
    ArrayList<Observer> personList;
    public WeaherStation() {
        personList = new ArrayList<Observer>();
    }
    public void addObserver(Observer o) {
        if(o == null){
            return;
        }else{
            if(!(personList.contains(o))){
                personList.add(o);
            }
        }
    }
    public void deleteObserver(Observer o) {
        if(personList.contains(o)){
            personList.remove(o);
        }
        
    }
    public void notifyObservers() {
        for (int i = 0; i < personList.size(); i++) {
            Observer o = personList.get(i);
            o.update(this);
        }
    }
    public void doForeCast(String t,String mess,int max,int min){
        forecastTime = t;
        forcastMess = mess;
        minTemperature = min;
        maxPemperature = max;
        notifyObservers();
    }
    public String getForecastTime() {
        return forecastTime;
    }
    public String getForcastMess() {
        return forcastMess;
    }
    public int getMaxPemperature() {
        return maxPemperature;
    }
    public int getMinTemperature() {
        return minTemperature;
    }
    
    
}

具體觀察者：

package com.observer2;

public class Person implements Observer {
    Subject subjectOne,subjectTwo; //可依賴的主題
    String forecastTime,forecastMess;
    String tourStartTime,tourMess;
    int maxTemperature,minTemperature;
    public Person(Subject one,Subject two) {
        this.subjectOne = one;
        this.subjectTwo = two;
        subjectOne.addObserver(this);
        subjectTwo.addObserver(this);
    }
    public void update(Subject subject) {
        if(subject instanceof WeaherStation){
            WeaherStation ws = (WeaherStation)subject;
            forecastTime = ws.getForecastTime();
            forecastMess = ws.getForcastMess();
            maxTemperature = ws.getMaxPemperature();
            minTemperature = ws.getMinTemperature();
            System.out.print("預報日期："+forecastTime+",");
            System.out.print("天氣狀況："+forecastMess+",");
            System.out.print("最高溫度："+maxTemperature+",");
            System.out.println("最低溫度："+minTemperature+".");
        }else if(subject instanceof TravelAgency){
            TravelAgency ta = (TravelAgency)subject;
            tourStartTime   = ta.getTourStartTime();
            tourMess        = ta.getTourMess();
            System.out.print("旅游開始日期："+tourStartTime+",");
            System.out.println("旅游信息："+tourMess+".");
        }
    }

}

下面寫一個測試程序：

package com.observer2;

public class Application {
    public static void main(String[] args) {
        WeaherStation weaherStation = new WeaherStation();//具體主題
        TravelAgency travelAgency   = new TravelAgency(); //具體主題 
        Person boy = new Person(weaherStation,travelAgency);

        weaherStation.doForeCast("10日", "陰有小雨", 28, 20);
        travelAgency.giveMess("10日", "黃山2日游");
        weaherStation.doForeCast("11日", "晴轉多雲", 30, 21);
        travelAgency.giveMess("11日", "麗江1日游");
    }

}

運行結果如下：

預報日期：10日,天氣狀況：陰有小雨,最高溫度：28,最低溫度：20.
旅游開始日期：10日,旅游信息：黃山2日游.
預報日期：11日,天氣狀況：晴轉多雲,最高溫度：30,最低溫度：21.
旅游開始日期：11日,旅游信息：麗江1日游.

 

適合使用觀察者模式的情況：

　　①、當一個對象的數據更新時需要通知其他的對象，但這個對象又不希望和被通知的那些對象形成緊耦合。

　　②、當一個對象的數據更新時，這個對象需要讓其他對象也各自更新自己的數據，但這個對象不知道具體有多少個對象要更新數據。