设计模式——观察者模式

观察者模式（又称发布/订阅者模式）提供了避免组件之间紧密耦合的一种方法，将观察者和被观察者的对象分开。在该模式中，一个对象通过添加一个方法使自身变得可观察。当被观察的对象更改时，它会通知已注册的观察者，这些观察者收到通知后所执行的操作与被观察者的对象无关。这种模式使得对象可以互相对话，而不必了解原因。

添加和删除观察者的主动权在被观察者一方。

观察者模式在对象之间定义了一对多的依赖，这样一来，当一个对象改变状态，依赖它的对象会收到通知并自动更新。其实就是发布订阅模式，发布者发布信息，订阅者获取信息，订阅了就能收到信息，没订阅就收不到信息。

   

四个角色

1）抽象被观察者角色：一个抽象主题，把所有对观察者对象的引用保存在一个集合中，每个主题都可以有任意数量的观察者。抽象主题提供接口方法，可以增加、删除、通知观察者角色。一般用一个抽象类或者接口来实现。

2）抽象观察者角色：为所有的具体观察者定义一个接口方法，在得到主题通知是更新自己，相当于一个set方法。

3）具体被观察者角色：具体的主题，将有关状态存入具体观察者对象，当具体主题的内部状态改变时，所有登记注册的观察者发出通知。

4）具体观察者角色：具体观察者，实现了抽象观察者中的更新方法，从而使自身的状态与主题的状态相协调。

第一个场景例子：有一个微信公众号服务，不定时发布一些消息，关注公众号就可以收到推送消息，取消关注就收不到推送消息。

角色：被观察者接口

package com.test.observer;

public interface Observarable {
    /*
    被观察者接口
    声明了添加、删除、通知观察者的方法
     */
    public abstract void addObserver(Observer obs);
    public abstract void removeObserver(Observer obs);
    public abstract void notifyObserver();
}

 角色：观察者接口

package com.test.observer;

public interface Observer {
    /*
    观察者接口
    声明了一个方法，当被观察者调用notifyObserver()方法时，观察者的update()方法会被回调。
     */
    public abstract void update(String message);
}

 角色：实现被观察者接口的具体被观察者类

package com.test.observer;

import java.util.ArrayList;
import java.util.List;

public class WechatServer implements Observarable {
    /*
    定义被观察者，实现了Observerable接口，对Observerable接口的三个方法进行了具体实现，
    同时有一个List集合，用以保存注册的观察者，等需要通知观察者时，遍历该集合即可。
     */
    private List<Observer> list;
    private String message;
    public WechatServer(){
        this.list = new ArrayList<Observer>();
    }
    @Override
    public void addObserver(Observer obs) {
        this.list.add(obs);
    }

    @Override
    public void removeObserver(Observer obs) {
        if (!this.list.isEmpty()) {
            this.list.remove(obs);
        }
    }

    @Override
    public void notifyObserver() {
        for (Observer aList : list) {
            aList.update(message);
        }
    }

    public void setInfromation(String str){
        this.message = str;
        System.out.println("微信服务更新信息素： " + str);
        notifyObserver();
    }
}

 角色：实现观察者接口的观察者类

package com.test.observer;

public class User implements Observer {
    /*
    观察者，实现了update（)方法
     */
    private String name;
    private String message;

    public User(String name){
        this.name = name;
    }
    @Override
    public void update(String message) {  // 功能类似于set方法
        this.message = message;
        read();
    }

    public void read(){
        System.out.println(this.name + "收到推送的消息: " + this.message);
    }
}

 测试

package com.test.observer;

public class TestObserver {
    public static void main(String[] args){
        WechatServer ws = new WechatServer();
        Observer userZhang = new User("Zhang");
        Observer userLi = new User("Li");
        Observer userZhao = new User("Zhao");
        ws.addObserver(userZhang);
        ws.addObserver(userLi);
        ws.addObserver(userZhao);
        ws.setInfromation("Java是世界上最好的语言");
        System.out.println("----------------------------");
        ws.removeObserver(userZhang);
        ws.setInfromation("C语言是世界最好的语言");
    }
}

测试结果

第二个场景例子：天气预报

角色：被观察者接口

package coding.com.test.observer2;

public interface Subject {
    public abstract void addObserver(Observer obs);
    public abstract void removeObserver(Observer obs);
    public abstract void notifyObserver();
}

角色：观察者接口

package coding.com.test.observer2;

public interface Observer {
    public abstract void update(float temp);
}

角色：具体被观察者

package coding.com.test.observer2;

import java.util.List;
import java.util.ArrayList;

public class WeatherServer implements Subject {
    private List<Observer> list = new ArrayList<>();
    private float temp;

    @Override
    public void addObserver(Observer obs) {
        list.add(obs);
    }

    @Override
    public void removeObserver(Observer obs) {
        if (!list.isEmpty()){
            list.remove(obs);
        }
    }

    @Override
    public void notifyObserver() {
        for (Observer aList : list){
            aList.update(temp);
        }
    }
    public void setTemp(float temp){
        this.temp = temp;
        notifyObserver();
    }
}

角色：具体观察者1

package coding.com.test.observer2;

public class WeatherDisplay1 implements Observer {
    private float temp;
    @Override
    public void update(float temp) {
        this.temp = temp;
        showWeather();
    }
    public void showWeather(){
        System.out.println("display1: " + temp);
    }
}

角色：具体观察者2

package coding.com.test.observer2;

public class WeatherDisplay2 implements Observer {
    private float temp;
    @Override
    public void update(float temp) {
        this.temp = temp;
        showWeather();
    }

    public void showWeather(){
        System.out.println("Display2; " + temp);
    }
}

测试

package coding.com.test.observer2;

public class TestObserver {
    public static void main(String[] args){
        WeatherServer ws = new WeatherServer();
        WeatherDisplay1 wd1 = new WeatherDisplay1();
        WeatherDisplay2 wd2 = new WeatherDisplay2();
        ws.addObserver(wd1);
        ws.addObserver(wd2);
        ws.setTemp(12.57f);
    }
}

测试结果