行为型设计模式之--观察者模式

随着水果店做的时间变长，会有一些回头客，他们想要知道水果店定期的一些折扣信息，那么这些顾客就可以像订阅微信公众号一样来订阅水果店的折扣信息，当水果店有折扣时，通知这些订阅了消息的顾客即可。

我们可以通过观察者模式实现上面的需求：

首先我们的被订阅者，也就是消息的发布者，本例是水果店：

抽象接口：

public abstract class Attentions {
    //关注客户列表
    protected List<Observer> observers = new ArrayList();

    //关注顾客
    public void add(Observer observer) {
        observers.add(observer);
    }

    //取消关注
    public void remove(Observer observer) {
        observers.remove(observer);
    }

    //发通知
    public abstract void notifyObservers();
}

实现类： 

public class MangoAttention extends Attentions{

    @Override
    public void notifyObservers() {
        //遍历观察者集合，调用每一个顾客的购买方法
        for(Observer obs : observers) {
            obs.update();
        }
    }

    //芒果到货了
    public void perform(){
        this.notifyObservers();
    }
}

观察者接口，以及实现对象：

public interface Observer {
    void update();
}

public class CustomerObserver implements Observer {

    private String name;

    public CustomerObserver(String name){
        this.name = name;
    }

    @Override
    public void update() {
        System.out.println(name + "购买青芒");
    }
}

最终调用者：

/**
 * 观察者模式
 * 顾客关注了芒果，降价时通知他们
 */
public class ObserverClient {
    public static void main(String[] args) {
        MangoAttention attentions = new MangoAttention();//目标

        attentions.add(new CustomerObserver("deer"));
        attentions.add(new CustomerObserver("james"));
        attentions.add(new CustomerObserver("lison"));
        attentions.add(new CustomerObserver("mark"));
        //到货
        attentions.perform();

    }
}

其实javaJDK中也为我们实现了观察者模式的工具类，我们可以直接使用：

被观察者，发布消息的对象：

import java.util.Observable;

public class Mango extends Observable {
    private String name;

    public Mango(String name){
        this.name = name;
    }

    //芒果到货了
    public void perform(){
        this.setChanged();
        this.notifyObservers();
    }
}

观察者，或者说是订阅者：

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

public class Customer implements Observer {

    private String name;

    public Customer(String name){
        this.name = name;
    }

    @Override
    public void update(Observable o, Object arg) {
        System.out.println(name + "购买青芒");
    }
}

最终的调用：

/**
 * 观察者模式
 * 顾客关注了芒果商品，到货时通知他们
 */
public class JdkObserverClient {
    public static void main(String[] args) {
        Mango attentions = new Mango("芒果");

        attentions.addObserver(new Customer("deer"));
        attentions.addObserver(new Customer("james"));
        attentions.addObserver(new Customer("lison"));
        attentions.addObserver(new Customer("mark"));

        attentions.perform();
    }
}

可以看到，观察者和被观察者中import的类都是JDK中的Observable和Observer。JDK中提供的被观察者的实现会有对多线程的处理，一般情况可以直接使用JDK为我们提供的观察者模式。