设计模式之观察者模式

观察者模式：当对象间存在一对多关系时，则使用观察者模式（Observer Pattern）。比如，当一个对象被修改时，则会自动通知它的依赖对象。观察者模式属于行为型模式。
定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。

观察者模式

情景

观察者模式可以想象成一场演出，演出者相当于被观察者，观众相当于观察者，演出者状态（唱，跳等）发生变化，观察者做出不同反应（呐喊，发呆等），当然演出者需要出售门票给观众，观众有了票也可以决定去不去观看演出，甚至在演出厅里是否观看演出。

具体实现

我们需要一个被观察者，一些观察者，两者互相连接（使用容器）。还需要一个实现模式类，得出结果。

实体对象，被观察者Cabbage类

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

public class Cabbage {

    //加入观察者
    private List<Observer> observers=new ArrayList<Observer>();

    //状态
    private String state;

    public void setState(String state) {
        this.state = state;
        notifyAllObserver(state);
    }
    
    public void attach(Observer observer){
        observers.add(observer);
    }

    //状态发生变化，通知观察者
    public void notifyAllObserver(String state){
        for (Observer observer:observers) {
            observer.updateState(state);
        }
    }
}

抽象观察者类，Observer
本抽象类是具体实现类的父类。在子类的构造方法中决定是否介入对实体的观察（就行是否决定去看演出一样）

public abstract class Observer {

    protected Cabbage cabbage;

    public abstract void updateState(String state);
}

实体观察者类SungObserver
实体观察者类中可以控制复杂逻辑，比如观察所有状态都做出反应，或者观察到相关状态才做出反应等。（相当于观众坐在演艺厅里面，对不同演出是否反应等）。

public class SungObserver extends Observer {

    public SungObserver(Cabbage cabbage) {
        this.cabbage=cabbage;
        this.cabbage.attach(this);
    }

    @Override
    public void updateState(String state) {

        System.out.println("SungObserver"+"开始观察了");

        if("sung".equals(state)){
            System.out.println("SungObserver观察到Cabbage开始"+state);
        }else {
            System.out.println("SungObserver"+"没有观察到任何行为，结束观察");
        }
    }
}

实体观察者类JumpObserver

public class JumpObserver extends Observer {

    public JumpObserver(Cabbage cabbage) {
        this.cabbage=cabbage;
        this.cabbage.attach(this);
    }

    @Override
    public void updateState(String state) {
        System.out.println("JumpObserver"+"开始观察了");

        if("jump".equals(state)){
            System.out.println("JumpObserver观察到Cabbage开始"+state);
        }else {
            System.out.println("JumpObserver"+"没有观察到任何行为，结束观察");
        }
    }
}

模式具体实现
创建对象 new JumpObserver(cabbage);决定是否将其设置为观察者（相当于是否发放门票给观察者）。

public class ObserverPattern {
    public static void main(String[] args) {
        Cabbage cabbage=new Cabbage();
        //创建一个JumpObserver
        new JumpObserver(cabbage);

        System.err.println("JumpObserver成为观察者");

        //只有一个JumpObserver,所以只能观察到jump
        cabbage.setState("jump");
        cabbage.setState("sung");

        new SungObserver(cabbage);
        System.err.println("SungObserver成为观察者");
        cabbage.setState("jump");

        new RapObserver(cabbage);
        System.err.println("RapObserver成为观察者");
        cabbage.setState("rap");

    }
}

结果如下

JumpObserver成为观察者
JumpObserver开始观察了
JumpObserver观察到Cabbage开始jump
JumpObserver开始观察了
JumpObserver没有观察到任何行为，结束观察
SungObserver成为观察者
JumpObserver开始观察了
JumpObserver观察到Cabbage开始jump
SungObserver开始观察了
SungObserver没有观察到任何行为，结束观察
RapObserver成为观察者
JumpObserver开始观察了
JumpObserver没有观察到任何行为，结束观察
SungObserver开始观察了
SungObserver没有观察到任何行为，结束观察
RapObserver开始观察了
RapObserver观察到Cabbage开始rap