zoukankan      html  css  js  c++  java
  • 观察者模式(Observer Pattern)

    观察者模式,主要就是一个地方的改变,需要通知多个其他依赖方,例如,一个订单的状态发生变更,后续的物流、保险等许多系统都需要用到这个变化值,那么就可以考虑使用观察者模式(这里不考虑跨系统问题)

    在JDK中,Swing API就用到了观察者模式,放一个按钮被触发时,所有需要依赖该通知的地方,都会收到通知事件,收到通知事件后,做相应的处理。

    在观察者模式中,一般存在三个对象,一个是通知对象,一个是主题Subject,一个是具体的需要被通知的对象。

    接下来就演示一个观察者模式

    示例:一个天气监测站,每有数据更新,则通知各个显示站,显示站根据自己的需求进行展示内容

    首先,创建一个主题接口,用来注册、移除观察者,同时可以通知观察者

    package lcl.mm.pattern.observer.demo1;
    
    public interface Subject {
        /**
         * 注册一个观察者
         * @param o
         */
        public void registerObserver(MyObserver o);
    
        /**
         * 移除一个观察者
         * @param o
         */
        public void removeOberver(MyObserver o);
    
        /**
         * 通知观察者
         */
        public void notifyObserver();
    }

    然后,创建一个展示内容的接口

    package lcl.mm.pattern.observer.demo1;
    
    public interface DisplayElement {
        public void display();
    }

    接着,创建一个更新接口

    package lcl.mm.pattern.observer.demo1;
    
    public interface MyObserver {
        public void update(int temp,int humidity, int pressure);
    }

    创建一个通知的对象,该对象实现Subject接口,对注册、移除和通知观察者接口进行实现,观察通知着的实现是循环所有观察者进行调用更新方法,然后还提供一个供天气监测站调用的接口

    package lcl.mm.pattern.observer.demo1;
    
    import java.util.ArrayList;
    
    public class WeatherData implements Subject{
    
        private ArrayList<MyObserver> observers = new ArrayList<>();
        private int temperature;
        private int humidity;
        private int pressure;
    
        @Override
        public void registerObserver(MyObserver o) {
            observers.add(o);
        }
    
        @Override
        public void removeOberver(MyObserver o) {
            int i = observers.indexOf(o);
            if(i>=0){
                observers.remove(i);
            }
        }
    
        @Override
        public void notifyObserver() {
            for (MyObserver o:observers) {
                o.update(temperature,humidity,pressure);
            }
        }
    
        /**
         * 数据变更
         */
        public void setChangeed(int temperature,int humidity, int pressure){
            this.temperature = temperature;
            this.humidity = humidity;
            this.pressure = pressure;
            this.notifyObserver();
        }
    }

    最后就是创建观察者对象,该对象实现数据更新接口和显示接口,在显示接口实现方法中,按照自己的需求显示内容;在更新接口实现方法中,按照自己的需求做数据更新并调用显示方法(这里写了两个观察者)

    package lcl.mm.pattern.observer.demo1;
    
    import lombok.extern.slf4j.Slf4j;
    
    @Slf4j
    public class CurrentConditionDisplay implements MyObserver,DisplayElement {
    
        private int temperature;
        private int humidity;
        private int pressure;
        private WeatherData weatherData;
    
        @Override
        public void display() {
            log.info("CurrentConditionDisplay:{},{},{}",temperature,humidity,pressure);
        }
    
        @Override
        public void update(int temp, int humidity, int pressure) {
            this.temperature = temp;
            this.humidity = humidity;
            this.pressure = pressure;
            display();
        }
    
        public CurrentConditionDisplay(WeatherData weatherData){
            this.weatherData = weatherData;
            weatherData.registerObserver(this);
        }
    }
    package lcl.mm.pattern.observer.demo1;
    
    import lombok.extern.slf4j.Slf4j;
    
    @Slf4j
    public class TotalConditionDisplay implements MyObserver,DisplayElement {
    
        private int temperature;
        private int humidity;
        private int pressure;
        private WeatherData weatherData;
    
        @Override
        public void display() {
            log.info("TotalConditionDisplay:{},{},{}",temperature,humidity,pressure);
        }
    
        @Override
        public void update(int temp, int humidity, int pressure) {
            this.temperature = temp*10;
            this.humidity = humidity*10;
            this.pressure = pressure*10;
            display();
        }
    
        public TotalConditionDisplay(WeatherData weatherData){
            this.weatherData = weatherData;
            weatherData.registerObserver(this);
        }
    }

    最后,就是测试,写一个测试方法,通知上述两个观察者,然后再演示剔除一个观察者后再通知所有观察者

        @Test
        void observerTest1(){
            WeatherData weatherData = new WeatherData();
            CurrentConditionDisplay currentConditionDisplay = new CurrentConditionDisplay(weatherData);
            TotalConditionDisplay totalConditionDisplay = new TotalConditionDisplay(weatherData);
            log.info("register observer:CurrentConditionDisplay,TotalConditionDisplay");
            weatherData.setChangeed(1,2,3);
            weatherData.setChangeed(4,5,6);
            log.info("remove register currentConditionDisplay");
            weatherData.removeOberver(currentConditionDisplay);
            weatherData.setChangeed(5,6,7);
        }

    输出结果

     其实,在jdk中,已经提供了观察者模式的相关类java.util.Observable和java.util.Observer,那么使用JDK提供的实现类来写上述观察者模式,写法如下:

    显示的接口,与上述一致

    package lcl.mm.pattern.observer.demo2;
    
    public interface DisplayElement2 {
        public void display();
    }

    创建一个传输数据对象,该对象需要继承java.util.Observable,在该类的调用前notifyObservers()通知观察者之前,需要先调用setChanged();将变更状态置为true,否则不会通知观察者。这是为了给我们提供一个灵活的更新限制,比如说,小于5的情况下,我们就不更新。

    package lcl.mm.pattern.observer.demo2;
    
    import java.util.Observable;
    
    public class WeatherData2 extends Observable {
    
        private int temperature;
        private int humidity;
        private int pressure;
    
        public void changed(int temperature, int humidity, int pressure){
            this.temperature = temperature;
            this.humidity = humidity;
            this.pressure = pressure;
            notifyChanged();
        }
    
        private void notifyChanged(){
            setChanged();
            notifyObservers();
        }
    
        public int getTemperature(){
            return temperature;
        }
    
        public int getHumidity(){
            return  humidity;
        }
    
        public int getPressure(){
            return pressure;
        }
    }

    然后,写两个观察者,需要实现java.util.Observer接口和自己创建的展示接口

    package lcl.mm.pattern.observer.demo2;
    
    import lombok.extern.slf4j.Slf4j;
    
    import java.util.Observable;
    import java.util.Observer;
    
    @Slf4j
    public class CurrentConditionDisplay2 implements Observer, DisplayElement2 {
    
        private int temperature;
        private int humidity;
        private int pressure;
        private Observable observable;
        @Override
        public void display() {
            log.info("CurrentConditionDisplay2:{},{},{}",temperature,humidity,pressure);
        }
    
        public CurrentConditionDisplay2(Observable observable){
            this.observable = observable;
            observable.addObserver(this);
        }
    
    
        @Override
        public void update(Observable o, Object arg) {
            if(o instanceof WeatherData2){
                WeatherData2 weatherData = (WeatherData2) o;
                this.temperature = weatherData.getTemperature();
                this.humidity = weatherData.getHumidity();
                this.pressure = weatherData.getPressure();
                display();
            }
        }
    }
    package lcl.mm.pattern.observer.demo2;
    
    import lombok.extern.slf4j.Slf4j;
    
    import java.util.Observable;
    import java.util.Observer;
    
    @Slf4j
    public class TotalConditionDisplay2 implements Observer, DisplayElement2 {
    
        private int temperature;
        private int humidity;
        private int pressure;
        private Observable observable;
    
        @Override
        public void display() {
            log.info("TotalConditionDisplay2:{},{},{}",temperature,humidity,pressure);
        }
    
    
        public TotalConditionDisplay2(Observable observable){
            this.observable = observable;
            observable.addObserver(this);
        }
    
        @Override
        public void update(Observable o, Object arg) {
            if(o instanceof WeatherData2){
                WeatherData2 weatherData = (WeatherData2) o;
                this.temperature = weatherData.getTemperature();
                this.humidity = weatherData.getHumidity();
                this.pressure = weatherData.getPressure();
                display();
            }
        }
    }

    最后,编写测试方法

        @Test
        void observerTest2(){
            WeatherData2 weatherData = new WeatherData2();
            log.info("register observer:CurrentConditionDisplay,TotalConditionDisplay");
            CurrentConditionDisplay2 currentConditionDisplay2 = new CurrentConditionDisplay2(weatherData);
            TotalConditionDisplay2 totalConditionDisplay2 = new TotalConditionDisplay2(weatherData);
            weatherData.changed(1,2,3);
            weatherData.changed(4,5,6);
    
            
            log.info("remove register currentConditionDisplay");
            weatherData.deleteObserver(currentConditionDisplay2);
            weatherData.changed(7,8,9);
        }

    测试:

  • 相关阅读:
    jQuery笔记之工具方法—Ajax 优化回调地狱
    jQuery笔记之工具方法—高级方法Ajax
    jQuery笔记之 Ajax回调地狱
    jQuery笔记之工具方法extend插件扩展
    jQuery同时监听两个事件---实现同时操控两个按键
    jQuery笔记之工具方法
    肖sir_多测师 _高级讲师 第二个月21讲解jmeter性能测试之安装badboy(002)
    肖sir_多测师 _高级讲师 第二个月21讲解jmeter之实战性能测试(001)
    肖sir_多测师 _高级讲师 第二个月20讲解jmeter之实战操作mysql(004)
    肖sir_多测师 _高级讲师 第二个月20讲解jmeter接口之实战(003)
  • 原文地址:https://www.cnblogs.com/liconglong/p/13222595.html
Copyright © 2011-2022 走看看