观察者模式

观察者模式——定义了对象之间的一对多关系，这样一来，当一个对象改变状态时，它的所有依赖者都会收到通知并自动更新。

何时使用：一个对象（目标对象）的状态发生改变，所有的依赖对象（观察者对象）都将得到通知，进行广播通知。

关键代码：在抽象类中有一个ArrayList存放观察者们

注意事项：

1、JAVA中已经有了观察者模式的支持类

2、避免循环引用

3、如果顺序执行，某一观察者错误会导致系统卡壳，一般采用异步方式。

代码实现观察者模式（“推”方式）：

1、观察者接口

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

观察者1

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

观察者2

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

2、被观察者接口

public interface Observable {
    //注册新观察者
    public void registerObserver(Observer observer);
    //删除观察者
    public void removeObserver(Observer observer);
    //通知所有观察者
    public void notifyObservers();
}

被观察者

public class Subject implements Observable{
    private String msg;
    private List<Observer> observerList = new ArrayList<>();

    public void setMsg(String msg) {
        this.msg = msg;
    }

    @Override
    public void registerObserver(Observer observer) {
        observerList.add(observer);
    }
    @Override
    public void removeObserver(Observer observer) {
        int i = observerList.indexOf(observer);
        observerList.remove(i);
    }
    @Override
    public void notifyObservers() {
        for(Observer observer : observerList) {
            observer.update(msg);
        }
    }
}

3、测试

public class Run {
    public static void main(String[] args) {
        Subject s = new Subject();
        s.setMsg("Hello World!");
        FirstObserver firstObserver = new FirstObserver();
        SecondObserver secondObserver = new SecondObserver();
        s.registerObserver(firstObserver);
        s.registerObserver(secondObserver);

        s.notifyObservers();
    }
}

输出：

FirstObserver get msg : Hello World!
SecondObserver get msg : Hello World!

利用JAVA内置的观察者模式实现（“拉”方式）

1、观察者

实现java.util.Observer接口

public class FirstObserver implements Observer {

    private String msg;

    @Override
    public void update(Observable o, Object arg) {
        if(o instanceof Subject) {
            Subject subject = (Subject) o;
            this.msg = subject.getMsg();
            display();
        }
    }

    public void display() {
        System.out.println("FirstObserver get msg : " + msg);
    }
}
public class SecondObserver implements Observer {
    private String msg;

    @Override
    public void update(Observable o, Object arg) {
        if(o instanceof Subject) {
            Subject subject = (Subject) o;
            //从被观察者“拉”取自身需要的数据
            this.msg = subject.getMsg();
            display();
        }
    }

    public void display() {
        System.out.println("SecondObserver get msg : " + msg);
    }
}

2、被观察者

继承import java.util.Observable类，在通知所有观察者前必须setChanged()表示状态已改变，这样保证在更新观察者时有更大的弹性。

public class Subject extends Observable {
    private String msg;

    public void statusChanged() {
        setChanged();
        notifyObservers();
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }

    public String getMsg() {
        return msg;
    }
}

3、测试

public class Run {
    public static void main(String[] args) {
        Subject s = new Subject();
        s.setMsg("Hello World!");
        FirstObserver firstObserver = new FirstObserver();
        SecondObserver secondObserver = new SecondObserver();
        s.addObserver(firstObserver);
        s.addObserver(secondObserver);

        s.statusChanged();
    }
}

输出

输出次序与上面的不同，这是由于notifyObservers()的实现方式不同。

SecondObserver get msg : Hello World!
FirstObserver get msg : Hello World!

注意：

1、Observable是一个类，这限制了复用的潜力。

2、Observable将关键方法保护了起来，setChanged()被定义为protected。这意味着除非集成Observable，否则无法创建Observable实例并组合到自己的对象中来。这违反了第二个设计原则“多用组合，少用继承”。