在学Dubbo之前，还得先学一下观察者模式

Subject：抽象被观察者（目标）：
一个目标可以被多个观察者观察。目标变化时，目标会通知所有登记的观察者拥有一个抽象观察者的引用
Observer：抽象观察者：
得到目标的通知时更新自己。更新方法：Updata();
Concrete Subject：具体被观察者
将状态存入具体现察者对象。自己变化时，给所有登记的观察者发出通知
Concrete Observer：具体观察者
拥有一个指向具体目标的引用

1.1别名

发布-订阅（Publish/Subscribe）模式
模型-视图（Model/View）模式
源-监听器（Source/Listener）模式
从属者（Dependents）模式。

1.2注意

• 是一对多的单向依赖：多个观察者对象同时观察一个目标对象， 观察者依赖于目标。
• 相互观察时注意死循环
  • 若 A、B观察C，B、C观察A，则需要两套观察模式，否则死循环

• 通知的顺序：同时

  • 多个观察者是平行的（虽然是循环，但几乎同时完成）

    1.3优缺点

    1.3.1优点

• 实现了观察者和被观察者之间的抽象耦合。

• 动态联动
• 广播通信。被观察者会向所有的登记的观察者发出通知。

  1.3.2缺点

  可能会引起无谓的操作。
  由于采用广播方式，不管观察者需不需要，每个观察者都会被调用update方法

  1.4一个接口一个父类

  1.4.1 Observer接口

  Observer为java.util包下的一个接口，源码如下：

public interface Observer {
    void update(Observable o, Object arg);
}

该接口约定了观察者的行为

当前接口代表观察者，要与被观察对象交互，需要持有被观察对象Observable的引用，因此update方法一个参数的类型是Observable
与调用者通信，则是使用Object类型的参数。该参数是调用者调用Observable实例的notifyObservers(Object obj)方法时传入的，也可以不传。

1.4.2 Observable类

java.util.Observable
该类实现了被观察者的功能
该类的成员变量和方法如下：

public class Observable {
    private boolean changed = false;
    private Vector<Observer> obs;
    public Observable(){};
    protected synchronized void setChanged(){};
    protected synchronized void clearChanged(){};
    public synchronized void addObserver(Observer o){};
    public synchronized void deleteObserver(Observer o) {};
    public synchronized void deleteObservers(){};
    public synchronized boolean hasChanged(){};
    public synchronized int countObservers(){};
    public void notifyObservers(){};
    public void notifyObservers(Object arg){};
}

1.5一个观察者模式的实例《办公室摸鱼记》

要求：
办公时间摸鱼， 在老板到来时，前台负责通知同事进入工作状态

• 观察者：两个同事，需要实现Observer接口
• 被观察者有两个：前台和老板，应该继承Observeable类
  • 前台通知：摸鱼的人改为工作状态
  • 老板通知：摸鱼的人被老板发现并且批评

    1.5.1 第一步：观察者继承父类

    ```java import java.util.Observable; import java.util.Observer;

@Data @Allargsconstructor public abstract class Observers implements Observer{

protected String name;
@Override
public abstract void update(Observable o, Object arg);
public abstract void see();
public abstract void exit();
public abstract void criticize();

<a name="H7UJ3"></a>
## 1.5.2 第二步：两个被观察者实现接口
```java
import java.util.Observable;
public class Boss extends Observable {
    private int state=0;//离开
    public void com() {
        System.out.println("我大老板回来了");
        state=2;//回来
        setChanged();//必须要写
        notifyObservers(state);//发出通知
    }
}

import java.util.Observable;
public class Secretary extends Observable{
    private int state=0;//老板离开
    public void see() {
        System.out.println("老板回来了");
        state=1;//老板回来啦
        setChanged();
        notifyObservers(state);
    }
}

1.5.3 第三步：写两个具体子类继承观察者父类

import java.util.Observable;
import java.util.Observer;
public class NBAObserver extends Observers{
    public NBAObserver(String name) {
        super(name);
        // TODO Auto-generated constructor stub
    }
    @Override
    public void update(Observable o, Object arg) {
        // TODO Auto-generated method stub
        Integer state=(Integer)arg;
        switch(state){
        case 0:
            see();break;
        case 1:
            exit();break;
        case 2:
            criticize();break;//老板通知
        }
    }
    @Override
    public void see() {
        // TODO Auto-generated method stub
        System.out.println(name+"看NBA");
    }
    @Override
    public void exit() {
        // TODO Auto-generated method stub
        System.out.println(name+"停止看NBA，开始工作");
    }
    @Override
    public void criticize() {
        // TODO Auto-generated method stub
        System.out.println(name+"你居然在工作时间看NBA，快工作！");
    }
}

import java.util.Observable;
public class StockObserver extends Observers{
    public StockObserver(String name) {
        super(name);
        // TODO Auto-generated constructor stub
    }
    @Override
    public void see() {
        // TODO Auto-generated method stub
        System.out.println(name+"看股票");
    }
    @Override
    public void exit() {
        // TODO Auto-generated method stub
        System.out.println(name+"停止看股票，开始工作");
    }
    @Override
    public void criticize() {
        // TODO Auto-generated method stub
        System.out.println(name+"你居然在工作时间看股票，快工作！");
    }
    @Override
    public void update(Observable o, Object arg) {
        // TODO Auto-generated method stub
        Integer state=(Integer)arg;
        switch(state){
        case 0:
            see();break;
        case 1:
            exit();break;//秘书通知
        case 2:
            criticize();break;//老板通知
        }
    }
}

1.5.4 第四步：main方法整合

public class Test {
    public static void main(String[] args) {
        NBAObserver nba=new NBAObserver("张三");
        StockObserver stock=new StockObserver("李四");
        Secretary s=new Secretary();
        s.addObserver(nba);
        s.addObserver(stock);
        s.see();
        Boss b=new Boss();
        b.addObserver(nba);
        b.addObserver(stock);
        b.com();
    }
}