设计模式之观察者模式

 首先，何为观察者模式？观察者模式的关于多个对象像知道一个对象中数据的变化的情况一种模式，比如说现在几乎所有的高校附近都会有大学生兼职中心，也就是兼职中介吧，兼职中心每天都会把兼职信息通知给所有的会员。这就是一个观察者模式，这里会员也是观察者，兼职中心就是被观察者，也称作主题。

       观察者模式结构中包括四种角色：

        一、主题：主题是一个接口，该接口规定了具体主题需要实现的方法，比如添加、删除观察者以及通知观察者更新数据的方法。

       二、观察者：观察者也是一个接口，该接口规定了具体观察者用来更新数据的方法。

       三、具体主题：具体主题是一个实现主题接口的类，该类包含了会经常发生变化的数据，而且还有一个集合，该集合存放的是观察者的引用。

       四、具体观察者：具体观察者是实现了观察者接口的一个类。具体观察者包含有可以存放具体主题引用的主题接口变量，以便具体观察者让具体主题将自己的引用添加到具体主题的集合中，让自己成为它的观察者，或者让这个具体主题将自己从具体主题的集合中删除，使自己不再是它的观察者。

       在上面的兼职中心的例子中，兼职中心就是一个具体主题，它可以更新各种兼职信息，并且通知它的会员，当然还可以增加会员和删除会员。会员就是一个观察者，它关注着兼职中心的信息，能够及时收到兼职中心更新过来的信息。

      

      代码如下：

 

      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.具体观察者

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.具体主题

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日游.

适合观察者模式的情况:

1、当一个对象的数据更新时需要通知其他的对象，但这个对象又不希望和被通知的那些对象形成紧耦合。

2、当一个对象的数据更新时，这个对象需要让其他对象也各自更新自己的数据，但这个对象不知道具体有多少个对象要更新数据。