个人Java设计模式-观察者模式

相信你们都有看过《喜洋洋与灰太狼》，说的是灰太狼和羊族的“斗争”，而每次的结果都是灰太狼一飞冲天，伴随着一句“我还会回来的......”。为灰太狼感到悲哀，抓不到羊，在家也被老婆平底锅虐待。灰太狼为何会这么背？

很简单，灰太狼自己就有“暴露行踪”的属性，羊咩咩就能知晓灰太狼要干吗，不背才怪呢。

为了帮助灰太狼摆脱被老婆平底锅抽的悲剧，发起了“解救灰太狼”的行动，必需要知道观察者模式。

1、观察者模式

定义

观察者模式又叫作发布-订阅模式，定义了对象间一对多的依赖关系，使得当对象状态发生变化时，全部依赖它的对象都会收到通知而且自动更新本身。

特色

1）被观察者须要持有一个或者多个观察者对象。

2）系统中一个模块的变化，某些模块也会跟随着变化。

UML

从上面的UML能够看出来，观察者模式设计到的角色有以下四个：

- 抽象被观察者角色：定义了动态增长、删除以及通知观察者对象的方法，职责就是管理和通知观察者。持有观察者对象的集合。

- 具体被观察者角色：通常继承抽象被观察者，实现本身自己的业务逻辑，当状态发生改变时发起通知。

- 抽象观察者角色：提供一个接口，定义了观察者收到通知时更新本身的方法。

- 具体观察者角色：实现抽象观察者接口，处理不一样具体观察者的不一样业务逻辑。

2、实战

灰太狼具备被观察者属性，喜洋洋这些羊咩咩一直都在观察者灰太狼，因此羊咩咩们是观察者。OK，角色肯定了，看看具体是怎么实现的...

抽象被观察者代码以下：

public abstract class Subject {

    /**
     * 观察者对象的集合
     */
    private List<Observer> observerList = new ArrayList<>();

    /**
     * 登记观察者
     *
     * @param observer
     */
    public void attach(Observer observer) {
        observerList.add(observer);
        System.out.println("增长了观察者：" + observer.getName());
    }

    /**
     * 删除观察者
     *
     * @param observer
     */
    public void dettach(Observer observer) {
        observerList.remove(observer);
        System.out.println("删除了观察者：" + observer.getName());
    }

    /**
     * 通知全部观察者
     */
    public void notifyObserver() {
        for (Observer observer : observerList) {
            observer.update("灰太狼要搞事情了");
        }
    }

}
复制代码

灰太狼是具体被观察者，继承抽象被观察者，代码以下：

public class Wolf extends Subject {

    public void invade(){

        System.out.println("灰太狼：我要搞事情了");
        // 通知全部观察者
        notifyObserver();
    }

}
复制代码

抽象观察者代码以下：

public interface Observer {

    String getName();

    /**
     * 通知更新方法
     *
     * @param msg
     */
    public void update(String msg);

}
复制代码

喜羊羊是具体观察者，实现抽象观察者，代码以下：

public class PleasantSheep implements Observer{

    @Override
    public String getName() {
        return "喜羊羊";
    }

    /**
     * 具体业务逻辑
     */
    @Override
    public void update(String msg) {
        System.out.println("喜羊羊收到通知：" + msg);
    }

}
复制代码

接下来看客户端如何把观察者模式跑起来，代码以下：

public class Client {

    public static void main(String[] args) {
        // 灰太狼--被观察者
        Wolf wolf = new Wolf();
        // 喜羊羊--观察者
        Observer pleasantSheep = new PleasantSheep();
        // 登记观察者
        wolf.attach(pleasantSheep);
        // 灰太狼入侵
        wolf.invade();
    }

}
复制代码

运行客户端代码，结果以下：

增长了观察者：喜羊羊

灰太狼：我要搞事情了

喜羊羊收到通知：灰太狼要搞事情了

看到了吧，灰太狼这不是自找虐吗！搞事情还要发通知，活该被平底锅拍飞。灰太狼不止通知了喜羊羊，还通知了懒羊羊。

懒羊羊也是具体观察者，代码以下：

public class LazySheep implements Observer {

    @Override
    public String getName() {
        return "懒羊羊";
    }

    @Override
    public void update(String msg) {
        System.out.println("懒羊羊收到通知：" + msg);
    }
    
}
复制代码

客户端代码以下：

public class Client {

    public static void main(String[] args) {
        // 灰太狼--被观察者
        Wolf wolf = new Wolf();

        // 喜羊羊--观察者
        Observer pleasantSheep = new PleasantSheep();
        // 登记观察者
        wolf.attach(pleasantSheep);

        // 懒羊羊--观察者
        Observer lazySheep = new LazySheep();
        // 登记观察者
        wolf.attach(lazySheep);
        
        // 灰太狼入侵
        wolf.invade();
    }

}
复制代码

上面客户端代码建立了一个懒羊羊观察者，添加了观察者集合中，这样懒羊羊也会受到通知，运行结果以下：

增长了观察者：喜羊羊

增长了观察者：懒羊羊

灰太狼：我要搞事情了

喜羊羊收到通知：灰太狼要搞事情了

懒羊羊收到通知：灰太狼要搞事情了

那如何帮助灰太狼摆脱这个命运呢，把观察者从集合中移除就OK了，代码以下：

public class Client {

    public static void main(String[] args) {
        // 灰太狼--被观察者
        Wolf wolf = new Wolf();

        // 喜羊羊--观察者
        Observer pleasantSheep = new PleasantSheep();
        // 登记观察者
        wolf.attach(pleasantSheep);

        // 懒羊羊--观察者
        Observer lazySheep = new LazySheep();
        // 登记观察者
        wolf.attach(lazySheep);

        // 灰太狼入侵
        wolf.invade();
        
        // 删除观察者
        wolf.dettach(pleasantSheep);
        
        wolf.invade();
    }

}
复制代码

再次运行客户端，结果以下：

增长了观察者：喜羊羊

增长了观察者：懒羊羊

灰太狼：我要搞事情了

喜羊羊收到通知：灰太狼要搞事情了

懒羊羊收到通知：灰太狼要搞事情了

删除了观察者：喜羊羊

灰太狼：我要搞事情了

懒羊羊收到通知：灰太狼要搞事情了

能够看到，把喜羊羊从观察者集合中移除了，它就不会再收到通知。

3、观察者模式的优缺点

优势

1）观察者和被观察者之间抽象耦合。观察者模式容易扩展，被观察者只持有观察者集合，并不须要知道具体观察者内部的实现。

2）对象之间的保持高度的协做。当被观察者发生变化时，全部被观察者都会通知到，而后作出相应的动做。

缺点

1）若是观察者太多，被观察者通知观察者消耗的时间不少，影响系统的性能。

2）当观察者集合中的某一观察者错误时就会致使系统卡壳，所以通常会采用异步方式。

4、比较

跟代理模式对比：观察者模式和代理模式主要区别在它们功能不同，观察者模式强调的是被观察者反馈结果，而代理模式是同根负责作一样的事情。

总结

在Java中已经提供了Observable类以及一个Observer接口，也就是说Java已经实现了观察者模式的定义，可看出观察者模式在程序系统中的使用率是很高的，不单是Java，Android中也常常看到观察者模式的运用，好比OnClickListener，Rxjava等。下一篇会补上属于建立型模式的原型模式，下回分解，再见。

设计模式Java源码GitHub下载：github.com/jetLee92/De…