观察者模式

观察者模式定义了一种一对多的依赖关系,让多个观察者对象同时监听某个主题对象,如果这个主题在状态上发生了变化,会通知所有的观察者对象,让他们自动更新自己

观察者模式有如下四个角色
1. 被观察接口
2. 具体的被观察者
3. 观察者接口
4. 具体的观察者接口

类图关系如下

原生观察者模式

通过程序实例理解观察者模式

被观察者接口包括注册观察者,移除观察者,通知观察者

public interface Watched {
    void addWatcher(Watcher watcher);

    void remove(Watcher watcher);

    void notifyWatchers(String str);
}

具体的被观察者

public class ConcreteWatched implements Watched {

    //存放所有的观察者
    private List<Watcher> list = new ArrayList<>();

    @Override
    public void addWatcher(Watcher watcher) {
        list.add(watcher);
    }

    @Override
    public void remove(Watcher watcher) {
        list.remove(watcher);
    }

    @Override
    public void notifyWatchers(String str) {
        list.stream().forEach(watcher -> watcher.update(str));
    }
}

观察者

public interface Watcher {
    void update(String str);
}

具体的观察者

public class ConcreteWatcher implements Watcher {
    @Override
    public void update(String str) {
        System.out.println("receive msg -> " + str);
    }
}

测试

public void testOrgin() {
    Watched watched=new ConcreteWatched();
    for (int i = 0; i < 10; i++) {
        watched.addWatcher(new ConcreteWatcher());
    }
    watched.notifyWatchers("第一条信息");
}

JDK对观察者模式的支持

利用jdk对观察者模式的支持我们首先得继承Observable类,在希望发送数据的时候,我们首先得调用setChanged()方法,然后执行notifyObservers(Object msg)方法,向所有的观察者发送信息,notifyObservers方法传参的时候这是推消息的形式,当notifyObservers不传参的时候就是拉消息的形式。发送消息的时候必须使用setChanged()方法，设置变化,否则notifyObservers不会发送消息,为什么要这样设计呢,比如如果我们传递的消息和上一次发送的消息一样那么就不需要再次通知观察者

下面是一个具体的例子

被观察者

public class ConcreateWatched extends Observable {
    //上一次发送的消息
    private String lastReceivedMsg;

    @Setter
    @Getter
    private String msg;

    public void isMessageSend() {
        //如果这次消息和上次收到的消息相同那么不发送
        if (!msg.equals(lastReceivedMsg)) {
            setChanged();
            notifyObservers(msg);
        }
    }

    public void msgChanged(String msg) {
        lastReceivedMsg = this.msg;
        this.msg = msg;
        isMessageSend();
    }
}

观察者

public class Watcher implements Observer {

    @Override
    public void update(Observable obs, Object arg) {
        if (obs instanceof ConcreateWatched) {
            display(arg);
        }
    }

    public void display(Object msg) {
        System.out.println("received from watched -> " + msg);
    }

}

测试

ConcreateWatched observable=new ConcreateWatched();
for (int i = 0; i < 10; i++) {
    observable.addObserver(new Watcher());
}
observable.msgChanged("第一条信息");

JDK类型的局限性

1. Observable是一个类,所以如果我们继承Observable类,那么就限制了我们通过继承拥有其它超类的可能性
2. setChanged()是protected类型的,我们无法创建Observable实例并组合到自己的对象中来,只能利用继承来调用这个方法
   上面这两点都违反了设计模式的原则 多用组合少用继承