【设计模式实践系列】观察者模式

观察者模式

观察者模式属于行为模式，一个目标物件管理所有依赖于它的观察者物件，并且在它本身的状态改变时主动发出通知，它定义了对象之间的一种一对多的依赖关系。

在观察者模式中，主题是通知的发布者，它发出通知时并不需要知道谁是它的观察者，可以有任意数目的观察者订阅并接收通知。

意图： 定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。

主要解决： 一个对象状态改变给其他对象通知的问题，而且要考虑到易用和低耦合，保证高度的协作。

何时使用： 一个对象（目标对象）的状态发生改变，所有的依赖对象（观察者对象）都将得到通知，进行广播通知。

优点： 1、观察者和被观察者是抽象耦合的。 2、建立一套触发机制。

缺点： 1、如果一个被观察者对象有很多的直接和间接的观察者的话，将所有的观察者都通知到会花费很多时间。 2、如果在观察者和观察目标之间有循环依赖的话，观察目标会触发它们之间进行循环调用，可能导致系统崩溃。 3、观察者模式没有相应的机制让观察者知道所观察的目标对象是怎么发生变化的，而仅仅只是知道观察目标发生了变化。

主要角色

1. 抽象主题（Subject）：
   它把所有观察者对象的引用保存到一个聚集里，每个主题都可以有任何数量的观察者。 抽象主题提供一个接口，可以增加和删除观察者对象。
2. 具体主题（Concrete Subject）：
   将有关状态存入具体观察者对象；在具体主题内部状态改变时，给所有登记过的观察者发出通知。
3. 抽象观察者（Observer）：
   为所有的具体观察者定义一个接口，在得到主题通知时更新自己。
4. 具体观察者（Concrete Observer）：
   实现抽象观察者角色所要求的更新接口，以便使本身的状态与主题状态协调

演示案例

模拟消费者订阅手机降价的通知，一旦有手机降价就调用消费者提供的方法。

抽象主题（Subject）：

public interface SpecialOffer {

    void addCustomer(Customer customer);

    void deleteCustomer(Customer customer);

    void notifyCustomer(String msg);

}

具体主题（Concrete Subject）：

public class SpecialPhone implements SpecialOffer {

    List<Customer> customerList = new ArrayList<>();

    @Override
    public void addCustomer(Customer customer) {
        customerList.add(customer);
    }

    @Override
    public void deleteCustomer(Customer customer) {
        customerList.remove(customer);
    }

    @Override
    public void notifyCustomer(String msg) {
        for (Customer customer : customerList) {
            customer.buy("发布通知：" + msg);
        }
    }
}

抽象观察者（Observer）：

public interface Customer {

    void buy(String msg);

}

具体观察者（Concrete Observer）：

public class CommonCustomer implements Customer {
    @Override
    public void buy(String msg) {
        System.out.println("------《普通》 消费用户");
        System.out.println(msg);
    }
}

public class VIPCustomer implements Customer {
    @Override
    public void buy(String msg) {
        System.out.println("------《VIP》 消费用户");
        System.out.println(msg);
    }
}

public class Test {
    public static void main(String[] args) {
        Customer vipC = new VIPCustomer();
        Customer commonC = new CommonCustomer();

        SpecialOffer phone = new SpecialPhone();

        phone.addCustomer(vipC);
        phone.addCustomer(commonC);

        phone.notifyCustomer("您关注的手机降价了。");
    }
}

JDK自带的观察者模式

早在JDK1.0版本时，在java.util包下就提供了观察者模式相关的类。

Observable

Observer

还是刚才的案例，替换为JDK自带的类。

import java.util.Observable;

public class SpecialPhone extends Observable {
    public void buy(String msg){
        this.setChanged();
        this.notifyObservers(msg);
    }
}

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

public class CommonCustomer implements Observer {

    @Override
    public void update(Observable o, Object arg) {
        System.out.println("------《普通》 消费用户");
        System.out.println(arg);
    }
}

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

public class VIPCustomer implements Observer {

    @Override
    public void update(Observable o, Object arg) {
        System.out.println("------《VIP》 消费用户");
        System.out.println(arg);
    }
}

public class Test {

    public static void main(String[] args) {
        SpecialPhone specialPhone = new SpecialPhone();
        CommonCustomer commonC = new CommonCustomer();
        VIPCustomer vipC = new VIPCustomer();

        specialPhone.addObserver(commonC);
        specialPhone.addObserver(vipC);

        specialPhone.buy("您关注的手机降价了。");

    }
}