设计模式-观察者模式

1.观察者模式介绍

    观察者模式是一个使用频率非常高的模式，它最常用的是GUI系统、订阅-发布系统。因为这个模式的重要作用就是解耦，将被观察者和观察者解耦，使得它们之间的依赖性更小，甚至做到毫无依赖。

2.观察者模式的定义

    定义对象间一种一对多的依赖关系，使得每当一个对象改变状态，则所有依赖于它的对象都会得到通知并被自动更新。

3.观察者模式的使用场景

    关联行为场景

        关联行为是可以拆分的，而不是“组合”的关系

    事件多级触发场景

    跨系统的消息交换场景

        如 消息队列、事件总线的处理机制

4.观察者模式的UML类图

5.具体实现

    抽象主题角色类

    /**     * 抽象主题类     * Created by Teaphy     * 2016/4/24.     */    public abstract class Subject {        // 用来保存注册的观察者对象        private List<Observer> listsObserver = new ArrayList<>();        /**         * 注册观察者对象         * @param observer    观察者对象         */        public void attach(Observer observer){            listsObserver.add(observer);            System.out.println("Attached an observer");        }        /**         * 删除观察者对象         * @param observer    观察者对象         */        public void detach(Observer observer){            listsObserver.remove(observer);        }        /**         * 通知所有注册的观察者对象         */        public void nodifyObservers(String newState){            for(Observer observer : listsObserver){                observer.update(newState);            }        }    }

    具体主题角色类

    /**     * 具体主题类     * Created by Teaphy     * 2016/4/24.     */    public class ConcreteSubject extends Subject {        private String msg;        public String getMsg() {            return msg;        }        public void setMsg(String msg) {            this.msg = msg;        }        public void publish(String msg) {            nodifyObservers(msg);        }    }

    抽象观察者角色类

    /**     * 抽象观察者角色类     * Created by Teaphy     * 2016/4/24.     */    public interface Observer {        /**         * 更新接口         * Created By         * on 2016/4/24         * @param msg 更新信息         */        void update(String msg);    }

    具体观察者角色

   /**     * 具体观察者角色     * Created by Teaphy     * 2016/4/24.     */    public class ObserverA implements Observer {        /**         * 更新观察者信息         */        public void update(String msg) {            System.out.println("ObserverA - msg = [" + msg + "]");        }    }            /**     * 具体观察者角色     * Created by Teaphy     * 2016/4/24.     */    public class ObserverB implements Observer {        /**         * 更新观察者信息         */        public void update(String msg) {            System.out.println("ObserverB - msg = [" + msg + "]");        }    }            /**     * 具体观察者角色     * Created by Teaphy     * 2016/4/24.     */    public class ObserverC implements Observer {        /**         * 更新观察者信息         */        public void update(String msg) {            System.out.println("ObserverC - msg = [" + msg + "]");        }    }

    测试

    /**     * Created by Teaphy     * 2016/4/24.     */    public class TestObserver {        public static void main(String[] args) {            //创建主题对象            ConcreteSubject cs = new ConcreteSubject();            // 添加观察者对象            cs.attach(new ObserverA());            cs.attach(new ObserverB());            cs.attach(new ObserverC());            // 发布新版本            cs.publish("英语");        }    }

     输出结果

    Attached an observer    Attached an observer    Attached an observer    ObserverA - msg = [英语]    ObserverB - msg = [英语]    ObserverC - msg = [英语]

6.推模型和拉模型

    在观察者模式中，又分为推模型和拉模型两种方式。
　　● 推模型
            主题对象向观察者推送主题的详细信息，不管观察者是否需要，推送的信息通常是主题对象的全部或部分数据。
　　●拉模型
            主题对象在通知观察者的时候，只传递少量信息。如果观察者需要更具体的信息，由观察者主动到主题对象中获取，相当于是观察者从主题对象中拉数据。一般这种模型的实现中，会把主题对象自身通过update()方法传递给观察者，这样在观察者需要获取数据的时候，就可以通过这个引用来获取了。
    根据上面的描述，发现前面的例子就是典型的推模型，下面给出一个拉模型的实例。    

    拉模型的抽象观察者类

    拉模型通常都是把主题对象当做参数传递。
  

 /**     * 抽象观察者角色类     * Created by Teaphy     * 2016/4/24.     */    public interface ObserverPull {        /**         * 更新接口         * Created By         * on 2016/4/24         * @param subjectPull 传入主题对象，方面获取相应的主题对象的状态         */        void update(SubjectPull subjectPull);    }

    拉模型的具体观察者类

   

/**     * 具体观察者角色     * Created by Teaphy     * 2016/4/24.     */    public class ObserverPullA implements ObserverPull {        private String msg;        public String getMsg() {            return msg;        }        public void setMsg(String msg) {            this.msg = msg;        }        /**         * 更新观察者信息         */        public void update(SubjectPull subjectPull) {            setMsg(((ConcreteSubjectPull)subjectPull).getMsg());        }    }

    拉模型的抽象主题类

    拉模型的抽象主题类主要的改变是nodifyObservers()方法。在循环通知观察者的时候，也就是循环调用观察者的update()方法的时候，传入的参数不同了

/**     * 抽象主题类     * Created by Teaphy     * 2016/4/24.     */    public abstract class SubjectPull {        // 用来保存注册的观察者对象        private List<ObserverPull> listsObserver = new ArrayList<>();        /**         * 注册观察者对象         * @param observer    观察者对象         */        public void attach(ObserverPull observer){            listsObserver.add(observer);            System.out.println("Attached an observer");        }        /**         * 删除观察者对象         * @param observer    观察者对象         */        public void detach(ObserverPull observer){            listsObserver.remove(observer);        }        /**         * 通知所有注册的观察者对象         */        public void nodifyObservers(){            for(ObserverPull observer : listsObserver){                observer.update(this);            }        }    }

    拉模型的具体主题类

　　跟推模型相比，有一点变化，就是调用通知观察者的方法的时候，不需要传入参数了
  

 /**     * 具体主题类     * Created by Teaphy     * 2016/4/24.     */    public class ConcreteSubjectPull extends SubjectPull {        private String msg;        public String getMsg() {            return msg;        }        public void setMsg(String msg) {            this.msg = msg;        }        public void publish(String msg) {            setMsg(msg);            //状态发生改变，通知各个观察者            nodifyObservers();        }    }

    测试

    /**     * Created by Teaphy     * 2016/4/24.     */    public class TestObserverPull {        public static void main(String[] args) {            //创建主题对象            ConcreteSubjectPull cs = new ConcreteSubjectPull();            ObserverPullA observerPullA = new ObserverPullA();            ObserverPullB observerPullB = new ObserverPullB();            ObserverPullC observerPullC = new ObserverPullC();            // 添加观察者对象            cs.attach(observerPullA);            cs.attach(observerPullB);            cs.attach(observerPullC);            // 发布新版本            cs.publish("英语周报20160414期");            System.out.println("ObserverPullA - " + observerPullA.getMsg());            System.out.println("ObserverPullB - " + observerPullB.getMsg());            System.out.println("---------------------------------");            // 发布新版本            cs.publish("英语周报20160424期");            System.out.println("ObserverPullA - " + observerPullA.getMsg());            System.out.println("ObserverPullC - " + observerPullC.getMsg());        }    }

    输出结果

    ObserverPullA - 英语周报20160414期    ObserverPullB - 英语周报20160414期    ---------------------------------    ObserverPullA - 英语周报20160424期    ObserverPullC - 英语周报20160424期

7.两种模式的比较

       1.推模型是假定主题对象知道观察者需要的数据；而拉模型是主题对象不知道观察者具体需要什么数据，没有办法的情况下，干脆把自身传递给观察者，让观察者自己去按需要取值。

        2.推模型可能会使得观察者对象难以复用，因为观察者的update()方法是按需要定义的参数，可能无法兼顾 没有考虑到的使用情况。这就意味着出现新情况的时候，就可能提供新的update()方法，或者是干脆重新实现观察者；而拉模型就不会造成这样的情况，因为拉模型下，update()方法的参数是主题对象本身，这基本上是主题对象能传递的最大数据集合了，基本上可以适应各种情况的需要。