1.观察者模式-----Head First (设计模式进阶)

迷南。 2023-06-08 04:53 18阅读 0赞

## 认识 ##

观察者模式:出版者(主题)+订阅者(观察者)

使用场景:出版者发生动作,通知订阅者发出相应的动作.这里动作是抽象的,可以是状态,也可以是其他的,出版者与订阅者一般为一对多的关系.

首先:我们来分析一下主题与观察者的职能:

*  主题:  
    改变状态,注册观察者与注销观察者(管理观察者与自己的关系),通知观察者状态改变.
 *  观察者:  
    更新自己的状态(动作)

那么,问题来了,为什么把管理两者关系的方法放在主题里面呢?为什么不放在观察者这里?  
  
首先,主题与观察者是一对多的关系,主题是主动方,观察者是被动方,如果将两者的关系放在观察者这里,就没办法保证在主题状态改变时通知注册了的观察者了,因为这时主题是不知道哪些观察者注册进来的.

## 实践 ##

先上代码:  
  
主题:

主题:
    /**
     * 主题 接口
     */
    public interface Subject {
    
        /**
         * 注册观察者
         */
        void regist(Observer observer);
    
        /**
         * 注销观察者
         */
        void logout(Observer observer);
    
        /**
         * 通知 观察者
         */
    
        void notifyAllObservers();
    
    }
    //抽象类
    public abstract class AbstractSubject implements Subject  {
    
        /**
         *  状态值
         */
        String status;
        /**
         *  观察者列表
         */
        LinkedHashSet<Observer>observers;
    
        public String getStatus() {
            return status;
        }
    
        public void setStatus(String status) {
            this.status = status;
        }
    
        public LinkedHashSet<Observer> getObservers() {
            return observers;
        }
    
        public void setObservers(LinkedHashSet<Observer> observers) {
            this.observers = observers;
        }
    
        public AbstractSubject(String status, LinkedHashSet<Observer> observers) {
            this.status = status;
            this.observers = observers;
        }
    }
    //具体实现
    public class ConSubject extends AbstractSubject {
    
    
        public ConSubject(String status, LinkedHashSet<Observer> observers) {
            super(status, observers);
        }
    
        @Override
        public void regist(Observer observer) {
            observers.add(observer);
        }
    
        @Override
        public void logout(Observer observer) {
            observers.remove(observer);
        }
    
        @Override
        public void notifyAllObservers() {
            for (Observer observer : observers) {
                observer.update();
            }
        }
    
        @Override
        public void setStatus(String status) {
            super.setStatus(status);
            notifyAllObservers();
        }
    
    }

观察者:

//接口
    public interface Observer {
    
    
        /**
         *  更新主题的变化
         */
    
        void update();
    }
    //具体实现类
    public class ConObserver implements Observer {
    
        private ConSubject subject;
    
        private String status;
    
        @Override
        public void update() {
            status=subject.getStatus();
            System.out.println("subject: "+subject+";status:"+status);
        }
    
        public ConObserver(ConSubject subject) {
            this.subject = subject;
            subject.regist(this);
        }
    
        public Subject getSubject() {
            return subject;
        }
    
        public void setSubject(ConSubject subject) {
            this.subject = subject;
        }
    
        public String getStatus() {
            return status;
        }
    
        public void setStatus(String status) {
            this.status = status;
        }
    
    
    }

测试demo:

public class Main {
    
        public static void main(String[] args){
    
            ConSubject subject=new ConSubject("wo",new LinkedHashSet<>());
            ConObserver conObserver=new ConObserver(subject);
            subject.setStatus("sss");
        }
    }

几个角色关系很简单,类图我就不画了,直接分析一下:  
首先我们从测试demo来分析,主题的构造方法初始化主题,我是用的linkedHashset来当盛放观察者的容器,原因是可以自动去重,以及是有序的,当然你可以换成其他的容器,然后是观察者的构造方法,传入主题对象.在构造方法中,我们将其本身通过传入的主题的方法注册到了主题的容器中.这里体现出组合的作用,然后,subject通过调用改变状态的方法setStatus来改变状态,并通知观察者状态已经改变,观察者调用update方法改变本身的状态.

## Java 内置的观察者模式接口 ##

//主题 java 只提供了抽象类Observable,并没有提供接口
    //这里都是java.util包下的接口和类
    public class WeatherData extends Observable {
    
        private float temperature;
    
        private float humidity;
    
        private float pressure;
    
        public void setState(float temperature,float humidity,float pressure){
            this.temperature=temperature;
            this.humidity=humidity;
            this.pressure=pressure;
            //标注已改变,设置改变按钮的状态 ,该状态值用于开启通知时作为控制,否则就会不可控,
            // 例如在这里我们可以设置当温度超过12度,再通知观察者变化,也就是控制灵敏度
            setChanged();
            //通知观察者状态已经改变
            notifyObservers();
        }
    
        public float getTemperature() {
            return temperature;
        }
    
        public void setTemperature(float temperature) {
            this.temperature = temperature;
        }
    
        public float getHumidity() {
            return humidity;
        }
    
        public void setHumidity(float humidity) {
            this.humidity = humidity;
        }
    
        public float getPressure() {
            return pressure;
        }
    
        public void setPressure(float pressure) {
            this.pressure = pressure;
        }
    }
    // 展示类(功能类)
    public interface DisplayElement {
    
        /**
         * 展示主题数据
         */
        void display();
    }
    //观察者  
    public class CurrentConditionsDisplay implements Observer,DisplayElement {
    
        private float temperature;
    
        private float humidity;
    
        Observable weatherData;
    
    
        public float getTemperature() {
            return temperature;
        }
    
        public void setTemperature(float temperature) {
            this.temperature = temperature;
        }
    
        public float getHumidity() {
            return humidity;
        }
    
        public void setHumidity(float humidity) {
            this.humidity = humidity;
        }
    
        @Override
        public void update(Observable o, Object arg) {
            if (o instanceof WeatherData){
                WeatherData weatherData=(WeatherData)o;
                this.humidity=weatherData.getHumidity();
                this.temperature=weatherData.getTemperature();
                display();
            }
    
        }
    
    
        @Override
        public void display() {
            System.out.println("temperature:"+this.temperature+";humidity:"+this.humidity);
        }
    
    
        public CurrentConditionsDisplay(Observable weatherData) {
            this.weatherData = weatherData;
            weatherData.addObserver(this);
        }
    }
    //测试demo
    public class Main {
    
        public static void main(String[] args){
    
            WeatherData weatherData=new WeatherData();
            CurrentConditionsDisplay currentConditionsDisplay=new CurrentConditionsDisplay(weatherData);
            weatherData.setState(1.2f,2.2f,3.2f);
            weatherData.setState(1.5f,2.3f,3.5f);
    
        }
    }

我们还是从测试demo来分析,其实,我们可以对比自己写的与java内置的有什么不同.  
  
首先,主题只有抽象类observable,使用的容器是Vector,多了一个布尔型参数changed.  
  
那么,为什么只有抽象类,而没有接口呢?那么抽象类相比于接口来说无疑不够灵活,不能多继承也限制了其扩展,只不过,因为主题是必须拥有观察者的容器作为属性的,所以,即使定义了接口,也必须继承这个抽象类,个人认为出于这种情况的考虑,所以没有定义接口.  
  
另外,使用的是Vector容器,这点可以从源码来看,为了更安全,防止出现多线程问题.当然,你可以使用其他的,具体看业务场景.  
  
最后,参数changed 有什么作用?我们打开源码,可以看到,有一个setChanged的方法,当主题改变时,我们为了控制其通知的灵敏度(如果当温度状态变化太小,我们需要超过某个阈值的时候再通知观察者,就需要这么一个作为开关作用的属性)而设置,否则,只要主题状态改变,就会通知到观察者.

## 总结 ##

封装变化,多组合,少继承,面向接口编程.

观察者模式与发布订阅模式的区别:

1.在观察者模式中，观察者是知道Subject的，Subject一直保持对观察者进行记录。然而，在发布订阅模式中，发布者和订阅者不知道对方的存在。它们只有通过消息代理进行通信。

2.在发布订阅模式中，组件是松散耦合的，正好和观察者模式相反。

3.观察者模式大多数时候是同步的，比如当事件触发，Subject就会去调用观察者的方法。而发布-订阅模式大多数时候是异步的（使用消息队列）。

4.观察者模式需要在单个应用程序地址空间中实现，而发布-订阅更像交叉应用模式。

具体的解释可以查看博文:https://blog.csdn.net/Firvana\_Mutex/article/details/82696406