设计模式--观察者模式

设计模式--观察者模式

1 概述

---

1.1 定义
观察者模式(Observer Design),也叫发布订阅模式：定义对象间一对多的依赖关系，使得每当一个对象状态改变时，它的所有依赖者都会收到通知并自动更新。

1.2 应用
消息队列的处理机制，如EJB的消息队列。(原理基本相同)

1.3 类图

组合模式涉及的角色如下：

• Subject被观察者抽象角色：定义被观察者需要实现的行为，如动态的添加、删除观察者、通知观察者。
• ConcreteSubject被观察者具体角色：被观察者抽象角色的具体实现，定义自己的业务逻辑，并通知观察者。
• Observer观察者抽象角色：定义观察者的抽象行为。
• ConcteteObserver观察者具体角色：具体的观察者，实现自己的业务逻辑。

2 详解

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

public class ConcreteObserver implements Observer {
    @Override
    public void update(Object arg) {
        System.out.println("I accept arg: " + arg);
    }
}

public abstract class Subject {
    // 定义一个观察者数组(Vector线程安全)
    private Vector<Observer> vector = new Vector<>();

    // 添加观察者
    public synchronized void addObserver(Observer observer) {
        vector.addElement(observer);
    }

    // 删除一个观察者
    public synchronized void removeObserver(Observer observer) {
        vector.removeElement(observer);
    }

    // 清空观察者
    public synchronized void clear(Observer observer) {
        vector.removeAllElements();
    }

    // 通知观察者
    public synchronized void notifyObservers(Object arg) {
        for(Observer observer : vector) {
            observer.update(arg);
        }
    }
}

public class ConcreteSubject extends Subject {
    // 定义自己的业务逻辑并通知观察者
    public void operate() {
        System.out.println("I do some operations and notify observes");
        notifyObservers(null);
    }
}

public class Client {
    public static void main(String[] args) {
        // 创建观察者
        Observer observer = new ConcreteObserver();
        Observer observer1 = new ConcreteObserver();

        // 创建被观察者并添加观察者
        ConcreteSubject subject = new ConcreteSubject();
        subject.addObserver(observer);
        subject.addObserver(observer1);

        // 被观察者活动并通知观察者
        subject.operate();
    }
}output:
I do some operations and notify observes
I accept arg: null
I accept arg: null

JDK中自带了有观察者模式：java.util.Observable是被观察者抽象角色，java.util.Observer是观察者抽象角色。你只需要实现自己的观察者与被观察者就可使用。

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

public class Observable {
    // 标识：标识被观察者是否改变
    private boolean changed = false;
    private Vector<Observer> 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 synchronized void deleteObservers() {
        obs.removeAllElements();
    }
    // 通知所有观察者
    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);
    }
    // 设置该被观察者改变标识为true
    protected synchronized void setChanged() {
        changed = true;
    }
    // 设置该被观察者改变标识为false
    protected synchronized void clearChanged() {
        changed = false;
    }

    public synchronized boolean hasChanged() {
        return changed;
    }
    
    public synchronized int countObservers() {
        return obs.size();
    }

小结一下

1. 观察者模式就是使用的回调机制，它更注重发布-订阅。被观察者一般有许多的观察者，被观察者会通知所有的观察者。在现实生活中就像微信工作号一样，只要你关注了它，它就会给你推送消息。
2. JDK中的观察者能够是线程安全的。但是当我们观察者处理通知时间较长时，会发生阻塞，因为其通知观察者是采用了同步的方式，而不是异步方式。
3. 不足：观察者模式中被观察者是一个抽象类，只能单继承，当然可以使用设配器模式。观察者模式中的观察者响应是固定的，即update()方法。

3 应用

public class People implements Observer {
    private WeChat weChat;
    private String name;

    People(String name, WeChat weChat) {
        this.name = name;
        this.weChat = weChat;
    }

    // 订阅微信公众号
    public boolean order (String name) {
        return weChat.order(this, name);
    }

    // 接受微信公众号发送的消息
    public void recieveMessage(Observable o, Object arg) {
        System.out.println(name + "接收到微信公众号「" + o + "」的信息：" + arg);
    }

    @Override
    public void update(Observable o, Object arg) {
        recieveMessage(o, arg);
    }
}

/**
 * 微信公众号
 */
public class WeChatPublicMessage extends Observable {
    private String name;

    WeChatPublicMessage(String name) {
        super();
        this.name = name;
    }

    // 发布消息
    public void publish(String message) {
        setChanged();
        notifyObservers(message);
    }
    
    @Override
    public String toString() {
        return name;
    }

}

public class WeChat {
    public static HashMap<String, WeChatPublicMessage> map = new HashMap<>();

    // 订阅微信公众号
    public boolean order(People people, String name) {
        WeChatPublicMessage weChatPublicMessage = map.get(name);
        if(weChatPublicMessage == null) {
            return false;
        }
        // 该微信公众号添加订阅人
        weChatPublicMessage.addObserver(people);
        return true;
    }
}

public class Client {
    public static void main(String[] args) {
        WeChatPublicMessage weChatPublicMessage = new WeChatPublicMessage("小道消息");
        WeChatPublicMessage weChatPublicMessage1 = new WeChatPublicMessage("侠客岛");
        WeChatPublicMessage weChatPublicMessage2 = new WeChatPublicMessage("财新网");
        WeChat.map.put("小道消息", weChatPublicMessage);
        WeChat.map.put("侠客岛", weChatPublicMessage1);
        WeChat.map.put("财新网", weChatPublicMessage2);

        People people = new People("张三", new WeChat());
        People people1 = new People("李四", new WeChat());

        people.order("小道消息");
        people.order("财新网");
        people.order("侠客岛");
        people1.order("财新网");

        weChatPublicMessage.publish("今天三星S8发布");
        weChatPublicMessage1.publish("韩美举行大规模的军演，朝鲜发出严正抗议");
        weChatPublicMessage2.publish("第一季度中国GDP同比增长6.6%");
    }
}output:
张三接收到微信公众号「小道消息」的信息：今天三星S8发布
张三接收到微信公众号「侠客岛」的信息：韩美举行大规模的军演，朝鲜发出严正抗议
李四接收到微信公众号「财新网」的信息：第一季度中国GDP同比增长6.6%
张三接收到微信公众号「财新网」的信息：第一季度中国GDP同比增长6.6%