折腾Java设计模式之观察者模式

时间 2019-11-09

标签折腾 java 设计模式观察者栏目 Java 繁體版

原文原文链接

观察者模式

Define a one-to-many dependency between objects where a state change in one object results in all its dependents being notified and updated automatically.html

直译过来就是，定义对象间的一对多依赖关系，当一个对象的状态变动会自动通知和更新全部依赖项。像发布/订阅模式，事件通知模式，数据源/监听模式等都是性质同样。java

观察者模式UML

UML类和时序图

类图：Subject类不会直接更新从属对象的状态。相反，Subject引用了用于更新状态的观察者接口（update()），这使得Subject独立于依赖对象的状态更新方式。Observer1和Observer2类经过将状态与Subject的状态同步来实现Observer接口。git

时序图：Observer1和Observer2对象调用Subject1上的attach(this)来注册本身。假如Subject1的状态发生变动，Subject1自己调用notify()。notify()对已注册的Observer1和Observer2对象调用update()，后者从Subject1请求已更改的数据（getState()）以更新（同步）其状态。github

UML类图

观察者模式角色

Subject（目标）：目标又称为主题，它是指被观察的对象。在目标中定义了一个观察者集合，一个观察目标能够接受任意数量的观察者来观察，它提供一系列方法来增长和删除观察者对象，同时它定义了通知方法notify()。目标类能够是接口，也能够是抽象类或具体类。编程

ConcreteSubject（具体目标）：具体目标是目标类的子类，一般它包含有常常发生改变的数据，当它的状态发生改变时，向它的各个观察者发出通知；同时它还实现了在目标类中定义的抽象业务逻辑方法（若是有的话）。若是无须扩展目标类，则具体目标类能够省略。设计模式

Observer（观察者）：观察者将对观察目标的改变作出反应，观察者通常定义为接口，该接口声明了更新数据的方法update()，所以又称为抽象观察者。缓存

ConcreteObserver（具体观察者）：在具体观察者中维护一个指向具体目标对象的引用，它存储具体观察者的有关状态，这些状态须要和具体目标的状态保持一致；它实现了在抽象观察者Observer中定义的update()方法。微信

观察者模式描述了如何创建对象与对象之间的依赖关系，以及如何构造知足这种需求的系统。观察者模式包含观察目标和观察者两类对象，一个目标能够有任意数目的与之相依赖的观察者，一旦观察目标的状态发生改变，全部的观察者都将获得通知。做为对这个通知的响应，每一个观察者都将监视观察目标的状态以使其状态与目标状态同步，这种交互也称为发布-订阅(Publish-Subscribe)。观察目标是通知的发布者，它发出通知时并不须要知道谁是它的观察者，能够有任意数目的观察者订阅它并接收通知。异步

干货源码解析

源码地址编程语言

博客订阅的功能，抽象主题中维护订阅关系，同时引入普通和vip观察者。

//抽象主题
@Data
public abstract class Subject {

    //主题订阅者们
    private List<Observer> observerList = Lists.newArrayList();

    //订阅
    public void register(Observer observer) {
        observerList.add(observer);
    }

    //取消订阅
    public void remove(Observer observer) {
        observerList.remove(observer);
    }

    //发布东西
    public abstract void publish(String msg);
}


//抽象观察者
@Slf4j
@Data
@AllArgsConstructor
public abstract class Observer {

    //观察者名称
    private String name;

    //更新状态，由主题调度
    public void update(Object subject, Object args) {
        log.info("{}获取到变动通知：{}", name, args);
    }
}

//博客主题
@Slf4j
public class Blog extends Subject {

    @Override
    public void publish(String msg) {
        log.info("发布msg:{}", msg);
        //通知订阅者
        getObserverList().forEach(observer -> observer.update(this, msg));
    }
}

//普通用户观察者
@Slf4j
public class NormalObserver extends Observer {

    public NormalObserver(String name) {
        super(name);
    }

    @Override
    public void update(Object subject, Object args) {
        super.update(subject, args);
        log.info("{}获取到变动通知：普通用户能够不缓存", getName());
    }
}

//vip用户观察者
@Slf4j
public class VipObserver extends Observer {

    public VipObserver(String name) {
        super(name);
    }

    @Override
    public void update(Object subject, Object args) {
        super.update(subject, args);
        log.info("{}获取到变动通知：vip能够缓存", getName());
    }
}


@Slf4j
public class Application {

    public static void main(String[] args) {
        Blog blog = new Blog();
        VipObserver wang = new VipObserver("老王99");
        VipObserver lee = new VipObserver("老李");
        NormalObserver four = new NormalObserver("小四");
        NormalObserver twoEgg = new NormalObserver("二蛋");
        log.info("---------------------begin--------------------");

        // 用户订阅博客，普通和vip用户
        new Thread(() -> {
            blog.register(wang);
            sleep(2);
            blog.register(lee);
            sleep(2);
            blog.register(four);
        }).start();

        // 博客线程每隔2秒发布一次文章, 总共发布4次
        new Thread(() -> {
            IntStream.rangeClosed(1, 4).forEach(i -> {
                blog.publish(String.format("新把戏第%s次", i));
                sleep(2);
            });
        }).start();

        // 有用户退出订阅博客，也有二蛋加入订阅
        new Thread(() -> {
            sleep(3);
            blog.remove(lee);
            sleep(2);
            blog.register(twoEgg);
        }).start();
    }

    private static void sleep(int seconds) {
        try {
            TimeUnit.SECONDS.sleep(seconds);
        } catch (InterruptedException e) {
            log.error("error : ", e);
        }
    }
}
复制代码

jdk内置的Obverser和Observable

@Slf4j
public class ObserverApplication {

    public static void main(String[] args) {
        log.info("Enter Text: ");
        EventSource eventSource = new EventSource();

        eventSource.addObserver((obj, arg) -> {
            log.info("Received response: {}", arg);
        });

        eventSource.addObserver((obj, arg) -> {
            log.info("Received response2: {},,{}", arg, obj
            );
        });

        new Thread(eventSource).start();
    }
}

class EventSource extends Observable implements Runnable {
    public void run() {
        while (true) {
            String response = new Scanner(System.in).next();
            setChanged();
            notifyObservers(response);
        }
    }
}
复制代码

Java中的使用

它使得一个对象能够灵活的将消息发送给感兴趣的对象

java.util.EventListener

javax.servlet.http.HttpSessionBindingListener

javax.servlet.http.HttpSessionAttributeListener

javax.faces.event.PhaseListener

Listener从名字上看就明白是监听的意思了。

JDK中内置的Obverser和Observable

jdk中内置的观察者模式。便是java.util.Observer(接口)和java.util.Observable(类)。

简单的说说这个。观察者接口(java.util.Observer)，主题(java.util.Observable)。实现观察者接口和继承主题。经过抽象主题的addObserver()注册观察者，deleteObserver()移除观察者。

首先经过调用主题类的setChange()告知状态变动，随后调用notifyObservers方法（可传可不传参数）去通知观察者，最后由于主题在notifyObservers时会主动调用观察者的update()方法，改方法有2个参数，第一个为主题对象，第二个为可变参数。

总结

观察者模式是一种使用频率很是高的设计模式，JDK中就带有实现。不管是移动应用、Web应用或者桌面应用，观察者模式几乎无处不在，它为实现对象之间的联动提供了一套完整的解决方案，凡是涉及到一对一或者一对多的对象交互场景均可以使用观察者模式。观察者模式普遍应用于各类编程语言的GUI事件处理的实现，在基于事件的XML解析技术（如SAX2）以及Web事件处理中也都使用了观察者模式。

观察者模式的优势

(1) 观察者模式能够实现表示层和数据逻辑层的分离，定义了稳定的消息更新传递机制，并抽象了更新接口，使得能够有各类各样不一样的表示层充当具体观察者角色。 (2) 观察者模式在观察目标和观察者之间创建一个抽象的耦合。观察目标只须要维持一个抽象观察者的集合，无须了解其具体观察者。因为观察目标和观察者没有紧密地耦合在一块儿，所以它们能够属于不一样的抽象化层次。 (3) 观察者模式支持广播通讯，观察目标会向全部已注册的观察者对象发送通知，简化了一对多系统设计的难度。 (4) 观察者模式知足“开闭原则”的要求，增长新的具体观察者无须修改原有系统代码，在具体观察者与观察目标之间不存在关联关系的状况下，增长新的观察目标也很方便。

观察者模式的缺点

(1) 若是一个观察目标对象有不少直接和间接观察者，将全部的观察者都通知到会花费不少时间。 (2) 若是在观察者和观察目标之间存在循环依赖，观察目标会触发它们之间进行循环调用，可能致使系统崩溃。 (3) 观察者模式没有相应的机制让观察者知道所观察的目标对象是怎么发生变化的，而仅仅只是知道观察目标发生了变化。

注意事项

一、JAVA 中已经有了对观察者模式的支持类。二、避免循环引用。三、若是顺序执行，某一观察者错误会致使系统卡壳，通常采用异步方式。

参考

欢迎关注