Java设计模式(6)之观察者模式学习总结

    观察者模式：在观察者模式中，存在着对象之间的一对多的依赖关系，即一个对象的状态发生改变时，所有依赖于该对象的对象都会得到通知，并对自身的状态进行更新；
    观察者模式的学习中，对象之间的一对多的依赖关系是学习观察者模式的切入点，而被依赖对象（目标对象）的状态改变会对依赖对象（观察者对象）状态产生影响是观察者模式的关键所在；只有对象之间形成一对多的依赖关系，才能实现被依赖对象与依赖对象之间的状态更新的交互作用；
    生活中，其实存在很多观察者模式的应用场景，比如天气预报短信通知，当你在手机上开通了短信通知天气服务之后，每天你都会收到当天的天气信息的短信通知；再比如，你的手机上安装了腾讯体育APP，那么你只要接受该APP提供的推送即时消息通知的服务，那么一旦有更新的体育信息，将会向你的手机推送相关信息；
    下面通过一个生活中的场景，进行相关的观察者模式设计代码：

    package com.pattern.observer;
    import java.util.ArrayList;
    import java.util.List;
    /**
     * 抽象目标类
     * @author Administrator
     */
    public  class Subject {
        //订阅者列表，用于存放订阅者对象
        private List<Observer> list = new ArrayList<Observer>();
        //添加订阅者
        public void add(Observer o) 
        {
            list.add(o);
        }
        //删除指定订阅者
        public void delete(Observer o)
        {
            list.remove(o);
        }
        //通知所有订阅者
        public void notifyAllObservers() 
        {
            for (Observer observer : list)
             {
                //将目标对象传入观察者对象的update方法
                observer.update(this);
            }
        }
    }


    package com.pattern.observer;
    /**
     * 具体目标类
     * @author Administrator
     */
    public class WeatherSubject extends Subject {
        //目标对象的状态信息
        private String information;
        public String getInformation() 
        {
            return information;
        }
        //设置或更新目标状态信息
        public void setInformation(String information)
         {
            this.information = information;
            //更新状态信息后，调用通知方法，通知所有订阅者，使其进行各自的状态更新
            this.notifyAllObservers();
        }   
    }


    package com.pattern.observer;
    /**
     * 观察者接口
     * @author Administrator
     */
    public interface Observer {
        //更新观察者状态
        public abstract void update(Subject subject);
    }


    package com.pattern.observer;
    /**
     * 具体观察者类
     * @author Administrator
     */
    public class ConcreteObserver implements Observer {
        //观察者的名字
        private String observerName;
        //观察者的待更新状态信息
        private String information;
        //接收到信息后的响应信息
        private String hint;

        public ConcreteObserver(String name,String hint)
         {
            observerName = name;
            this.hint = hint;
        }

        @Override
        public void update(Subject subject) 
            information =((WeatherSubject)subject).getInformation();
            System.out.println(observerName+"收到了"+information+"的通知"+","+hint);
        }

    }


    package com.pattern.observer;
    //测试类
    public class TestObserverPattern {

        public static void main(String[] args) {
            //1.创建目标对象
            WeatherSubject subject = new WeatherSubject(); 
            //2.创建观察者对象
            ConcreteObserver observerOne = new ConcreteObserver("Tom", "已收到，考虑是否去购物");
            ConcreteObserver observerTwo = new ConcreteObserver("Jake", "已收到，考虑是否去旅游");
            //3.添加观察者
            subject.add(observerOne);
            subject.add(observerTwo);
            //4.更新目标状态信息
            subject.setInformation("天气晴朗");
        }
    }

    在设计观察者模式的时候，由于对于向观察者对象传送的消息内容的不同，观察者模式又分为推模型和拉模型；

    拉模型：将目标对象传给观察者对象，观察者对象需要目标对象的哪一部分的状态信息，就通过该目标对象获取信息；当观察者对象对更新信息的需求发生变化时，拉模型可以很好地应对变化的场景；在上述的例子中，采用的是拉模型进行观察者模型的设计； 

    推模型：将指定的更新信息通知给观察者对象，当观察者对更新信息有了不同的要求之后，这种方式将会显得难以适应变化的要求；

    如果想将上述例子通过推模型实现，只需要对具体观察者类中的update进行修改和对具体目标类中的notifyAllObservers进行重写；修改如下： 

    public void notifyAllObservers() 
    {
        for (Observer observer : list)
         {
            //将传入观察者对象的update方法
            observer.update(information);
        }
    }

    public void update(String information) 
    {
        this.information = information;
        System.out.println(observerName+"收到了"+information+"的通知"+","+hint);
    }

    在Java中，其实提供了观察者模式的实现，利用java.util包下的Observable类和Observer接口就可以大大简化我们自己设计观察者模式的步骤；利用Java提供的观察者模式的实现将上述例子重新进行设计：

    /**
     *目标类的设计
     */
    package com.pattern.observerInJava;
    import java.util.Observable;

    public class ConcreteSubject extends Observable  
    {
        private String weatherInfor;//天气信息
        public String getWeatherInfor() 
        {
            return weatherInfor;
        }
        public void setWeatherInfor(String weatherInfor)  
        {
            this.weatherInfor = weatherInfor;
            //使用Java提供的观察者模式，在进行通知观察者更新信息之前所必需的一步
            this.setChanged();
            //设置拉模型，将目标对象直接传到观察者方法中
            this.notifyObservers();
            //设置推模型，将具体需要通知的信息传到观察着方法中
            this.notifyObservers(weatherInfor);
        }   
    }


    /**
     *观察者类的设计
     */
    package com.pattern.observerInJava;
    import java.util.Observable;
    import java.util.Observer;

    public class ConcreteObserver1 implements Observer 
    {
        private String observerName;
        private String weatherInfor;

        public ConcreteObserver1(String name) 
        {
            observerName = name;
        }
        @Override
        public void update(Observable o, Object arg)  
        {
            //采用拉模型进行观察者消息的更新
            weatherInfor = ((ConcreteSubject)o).getWeatherInfor();
            System.out.println(observerName+"从目标处拉取了更新的信息");
            System.out.println(observerName+"收到了"+weatherInfor);
            //采用推模型进行观察者消息的更新
            System.out.println(observerName+"接收到了推动的更新的信息");
            System.out.println(observerName+"收到了"+weatherInfor);
        }
    }


    /**
     *测试类的设计
     */
    package com.pattern.observerInJava;
    import com.pattern.observerInJava.ConcreteObserver1;
    public class TestObserverInJava
    {
        public static void main(String[] args)  
        {
            //1.创建目标对象
            ConcreteSubject subject = new ConcreteSubject(); 
            //2.创建观察者对象
            ConcreteObserver1 observerOne = new ConcreteObserver1("Tom");
            ConcreteObserver1 observerTwo = new ConcreteObserver1("Jake");
            //3.添加观察者
            subject.addObserver(observerOne);
            subject.addObserver(observerTwo);
            //4.更新目标状态信息
            subject.setWeatherInfor("天气晴朗");
        }
    }

    进一步地提出问题，当不同的观察者对象对目标对象的更新信息中感兴趣的方面不同，比如观察者对象A只对下雨天和阴天感兴趣，观察者对象B只对下雨天感兴趣，这时，将需要根据不同的需求向不同的观察者对象发送相应的更新信息；
    这里可以使用面向接口编程的思想进行解决，设计一个抽象目标类，在该类中实现其具体实现类中公有的部分，而将notifyAllObservers方法放在其具体实现类中进行实现，在该方法中根据需求的不同进行不同的处理；
    notifyAllObservers方法的具体实现可参考如下代码：
    public void notifyAllObservers() 
    {
        for (Observer observer : list)
         {
             //如果天气为下雨天，则只向观察者A、B推送更新信息
            if("下雨天".equals(weatherInfor))
            {
                if(observer.getObserverName.equals("A"))
                {
                    observer.update(this);
                }
                if(observer.getObserverName.equals("B"))
                {
                    observer.update(this);
                }
            }
            //如果天气为阴天，则指向观察者A推送更新信息
            if("阴天".equals(weatherInfor))
            {
                if(observer.getObserverName.equals("A"))
                {
                    observer.update(this);
                }
            }
        }
    }


    在当自己进行观察者模式设计的时候，这里给出一些适用于观察者模式设计的注意点：
        ①命名上的建议:
            目标接口定义为Subject
            观察者接口定义为Observer
            观察者接口中的的更新方法定义为update
        ②触发通知的时机应该在更新完目标对象的状态信息之后通知
        ③通知的顺序:观察者之间是平行的，在观察者模式中不需要指定通知的顺序 
    观察者模式设计流程分析:
        准备阶段 1、创建目标对象 2、创建观察者对象 3、在目标对象中注册观察者对象
        运行阶段 1、改变目标对象的状态 2、通知所有已注册观察者对象进行相应的处理 3、回调目标对象，获取相应数据

    观察者优点及适用场景:
    优点:
    ①观察者模式实现了观察者和目标之间的抽象耦合；
    ②观察者模式实现了动态联动；
    ③观察者模式支持广播通信；
    使用场景:
    ①在一个业务场景中，某一方面的操作需要依赖另一方面状态的改变；
    ②在更改一个对象的状态同时，需要连带着修改其他对象的状态，并且需要被连带修改的对象的个数不知道；
    ③当需要实现通知对象和被通知对象之间的松散耦合的时候，选用观察者模式；