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

观察者模式

观察者模式，又叫发布-订阅模式，它属于行为型模式。它是定义一种一对多的依赖关系，一个主题对象可被多个观察者对象同时监听，使得每当主题对象状态变化时，所有依赖于它的对象都会得到通知并被自动更新。

观察者模式的核心是将观察者与被观察者解耦，以类似于消息/广播发送的机制联动两者，使被观察者的变动能通知到感兴趣的观察者们，从而做出相应的响应。

应用场景

1.当一个抽象模型包含两个方面内容，其中一个方面依赖于另一个方面；

2.其他一个或多个对象的变化依赖于另一个对象的变化；

3.实现类以广播机制的功能，无需知道具体收听者，只需分发广播，系统中感兴趣的对象会自动接收该广播；

4.多层级嵌套使用，形成一种链式触发机制，使得事件具备跨域（跨越两种观察者类型）通知。

例如：某商品无货时，只需要订阅到货通知，当产品到货时， 就可以向所有顾客发送消息通知，避免顾客重复、多次访问查询是否有货。

主要角色

1.抽象主题(Subject)

指被观察的对象(Observable)。该角色是一个抽象类或接口，定义了增加、删除、通知观察者对象的方法；

2.具体主题(ConcreteSubject)

具体被观察者，当其内状态变化时，会通知已注册的观察者；

3.抽象观察者(Observer)

定义了响应通知的更新方法

4.具体观察者(ConcrereObserver)

在得到状态更新时，会自动做出响应。

优缺点

优点：

1.观察者和被观察者是松耦合（抽象耦合)的，符合依赖倒置原则；

2.分离了表示层（观察者）和数据逻辑层（被观察者），并且建立了一套触发机制，使得数据的变化可以响应到多个表示层上；

3.实现了一对多的通讯机制，支持事件注册机制，支持兴趣分发机制，当被观察者触发事件时，只有感兴趣的观察者可以接收到通知。

缺点：

1.如果观察者数量过多，则事件通知会耗时较长；

2.事件通知呈线性关系，如果其中一个观察者处理事件卡壳，会影响后续的观察者接收该事件；

3.如果观察者和被观察者之间存在循环依赖，则可能造成两者之间的循环调用，导致系统崩溃。

基本使用

创建抽象主题

public interface ISubject<E> {
    void add(IObserver<E> observer);
    
    void notify(E event);
}

创建具体主题

public class ConcreteSubject<E> implements ISubject<E> {
    private List<IObserver<E>> observers = new ArrayList<IObserver<E>>();

    public void add(IObserver<E> observer) {
        if (observer != null && !observers.contains(observer)) {
            this.observers.add(observer);
        }
    }


    public void notify(E event) {
        System.out.println("准备通知观察者,通知内容：" + event);
        for (IObserver<E> observer : this.observers) {
            observer.update(event);
        }
    }
}

创建抽象观察者

public interface IObserver<E> {
    void update(E event);
}

创建具体观察者

public class ConcreteObserver<E> implements IObserver<E> {
    public void update(E event) {
        System.out.println("具体观察者得到通知,通知内容： " + event);
    }
}

客户端执行

    public static void main(String[] args) {
        // 被观察者
        ISubject<String> observable = new ConcreteSubject<String>();
        // 观察者
        IObserver<String> observer1 = new ConcreteObserver<String>();
        IObserver<String> observer2 = new ConcreteObserver<String>();
        // 新增观察者
        observable.add(observer1);
        observable.add(observer2);
        // 通知观察者
        observable.notify("hello world");
    }

准备通知观察者,通知内容：hello world
具体观察者得到通知,通知内容： hello world
具体观察者得到通知,通知内容： hello world

JDK中的Observer

JDK提供的一种观察者的实现方式，被观察者。

创建具体主题

@Data
public class ConcreteSubject extends Observable {
    private String name = "被观察者1号";

    private static final ConcreteSubject CONCRETE_SUBJECT = new ConcreteSubject();

    public static ConcreteSubject getInstance() {
        return CONCRETE_SUBJECT;
    }

    public void pushMsg(String msg) {
        System.out.println(this.name + "发布了一条新消息：" + msg + " ,准备通知观察者");
        setChanged();
        notifyObservers(msg);
    }
}

创建具体观察者

public class ConcrereObserver implements Observer {

    private String name;

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

    public void update(Observable o, Object arg) {
        ConcreteSubject concreteSubject = (ConcreteSubject) o;
        String msg = (String) arg;
        System.out.println(this.name + "收到了新消息：" + msg + "，准备响应： " + concreteSubject.getName());
    }
}

客户端执行

    public static void main(String[] args) {
        // 创建被观察者
        ConcreteSubject concreteSubject = ConcreteSubject.getInstance();
        // 创建观察者
        ConcrereObserver concrereObserver1 = new ConcrereObserver("观察者1号");
        ConcrereObserver concrereObserver2 = new ConcrereObserver("观察者2号");

        // 新增观察者
        concreteSubject.addObserver(concrereObserver1);
        concreteSubject.addObserver(concrereObserver2);

        // 通知观察者
        concreteSubject.pushMsg("hello world");
    }

被观察者1号发布了一条新消息：hello world ,准备通知观察者
观察者2号收到了新消息：hello world，准备响应： 被观察者1号
观察者1号收到了新消息：hello world，准备响应： 被观察者1号

Guava API实现观察者模式

添加依赖

	    <dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
            <version>20.0</version>
        </dependency>

创建监听事件

public class MyEvent {

    @Subscribe
    public void observer(String msg) {
        System.out.println("收到消息：" + msg);
    }
}

客户端执行

    public static void main(String[] args) {
        EventBus eventBus = new EventBus();

        MyEvent myEvent = new MyEvent();
        eventBus.register(myEvent);
        eventBus.post("hello world");
    }

收到消息：hello world