观察者模式

• 定义：定义对象间一种一对多的依赖关系，每当一个对象状态改变时，则所有依赖于它的对象都会得到通知并被自动更新

• 有如下角色：
  • Subject：抽象主题（抽象被观察者）。抽象主题角色把所有观察者对象保存在一个集合里，每个主题都可以有任意数量的的观察者。抽象主题提供一个接口可以增加和删除观察者对象
  • ConcreteSubject：具体主题（具体被观察者），该角色将有关状态存入具体观察者对象，在具体主题的内部状态发生改变时，给所有注册过的观察者发送通知
  • Observer：抽象观察者。是观察者的抽象类。它定义了一个更新接口，使得在得到主题更改通知时更新自己
  • ConcreteObserver：具体观察者，实现抽象观察者定义的更新接口，以便在得到主题更改通知时更新自身的状态
• 观察者模式的简单实现
  • 抽象被观察者

    public interface Subject {
        void attach(Observer observer);
        void notify(String msg);
        void unattach(Observer observer);
    }
    

  • 具体被观察者

    public class Boss implements Subject {
    
    
        private List<Observer> observerList = new ArrayList<>();
    
        @Override
        public void attach(Observer observer) {
            if (!observerList.contains(observer)){
                observerList.add(observer);
            }
        }
    
        @Override
        public void notify(String msg) {
            for (Observer o :
                    observerList) {
                o.update(msg);
            }
        }
    
        @Override
        public void unattach(Observer observer) {
            if (observerList.contains(observer)){
                observerList.remove(observer);
            }
        }
    }
    

  • 抽象观察者

    public interface Observer {
        void update(String msg);
    }
    

  • 具体观察者

    public class Employee implements Observer {
        @Override
        public void update(String msg) {
            System.out.println("Employee received msg:"+msg);
        }
    }
    

    public class HR implements Observer {
        @Override
        public void update(String msg) {
            System.out.println("HR received msg:"+msg);
        }
    }
    

  • 客户端调用

       Observer observer1 = new Employee();
            Observer observer2 = new HR();
    
            Subject boss = new Boss();
            boss.attach(observer1);
            boss.attach(observer2);
    
            boss.notify("I am your boss, I am coming");
    

 

• 使用场景
  • 关联行为场景。需要注意的是，关联行为是可拆分的，而不是组合关系
  • 事件多级触发场景
  • 跨系统的消息交换场景，如消息队列、事件总线的处理机制
• 优点
  • 观察者和被观察者是抽象耦合，容易扩展
  • 方便建立一套触发机制
• 缺点
  • 在应用观察者模式时需要考虑一下开发效率和运行效率的问题。程序中包含一个被观察者、多个观察者，开发调试等内容会比较复杂，而且在java中消息的通知一般是顺序执行的，那么一个观察者卡顿，会影响整体效率，在这种情况下，一般采用异步机制

 

• Java系统的Observer 、Observable
  • 只需要被观察者集成Observable，然后在设置数据变化的部分加上 setChanged(),然后notifyObservers就可以

    public class Lizhanwei extends Observable {
    
    
    
        public void setData(Msg msg){
            setChanged();
            notifyObservers(msg);
        }
    }
    

    　　

  • 观察者继承Observer(java.util).并构造函数加入被观察者参数

    public class QQUser implements Observer {
        @Override
        public void update(Observable observable, Object o) {
            String from = observable.getClass().getSimpleName();
            Msg msg = (Msg)o;
    
            System.out.println("QQUser收到来自："+from+"的消息，消息内容"+msg.toString());
        }
    
        public QQUser(Observable observable) {
            observable.addObserver(this);
        }
    }