设计模式之观察者设计模式

简述：

使用过MQ的人对该模式应该不会陌生，简单来说就是发布和订阅的模式，一个被观察者，对应多个观察者，被观察者有状态更新的时候，通知所有观察者进行相关操作。

角色：

在观察者设计模式中，存在四种角色。
1.抽象被观察者角色
2.抽象观察者角色
3.具体被观察者角色
4.具体观察者角色
下面我们将通过自己手写实现观察者模式，和使用java内置观察者模式两种方法来学习使用。

手写观察者模式：

1.抽象被观察者角色

/**
 * 被观察者接口
 */
public interface ObserverAble<T> {
    /**
     * 订阅者存储list
     */
    List<Observer> saveList = new ArrayList<Observer>();
    /**
     * 注册订阅者
     */
    void register(T obs);
    /**
     * 删除订阅者
     */
    void remove(T obs);
    /**
     * 通知所有订阅者
     */
    void notice();
}

2.抽象观察者角色

/**
 * 观察者接口
 */
public interface Observer {
    /**
     * 更新观察者状态
     * @param observerAble
     */
    void update(ObserverAble observerAble);
}

3.具体被观察者角色

/**
 * 被观察者实现类
 */
public class OberverAbleImp implements ObserverAble<Observer> {

    private int type;


    public int getType() {
        return type;
    }

    public void setType(int type) {
        //当有类型发生改变时，进行通知
        this.type = type;
        this.notice();
    }

    /**
     * 注册观察者
     * @param obs
     */
    @Override
    public void register(Observer obs) {
        saveList.add(obs);
    }

    /**
     * 删除观察者
     * @param obs
     */
    @Override
    public void remove(Observer obs) {
        saveList.remove(obs);
    }

    /**
     * 通知所有观察者
     */
    @Override
    public void notice() {
        for (Observer x :
                saveList) {
            x.update(this);
        }
    }
}

4.具体观察者角色

/**
 * 观察者实现类
 */
public class ObserverImp implements Observer {
    int myType;

    /**
     * 更新自己本身的类型
     * @param observerAble
     */
    @Override
    public void update(ObserverAble observerAble) {
        this.myType=((OberverAbleImp)observerAble).getType();
    }

    public int getMyType() {
        return myType;
    }
}

5.测试

public class test {
    public static void main(String[] args) {
        //被观察者
        OberverAbleImp oberverAbleImp = new OberverAbleImp();
        //观察者
        ObserverImp observerA = new ObserverImp();
        ObserverImp observerB = new ObserverImp();
        ObserverImp observerC = new ObserverImp();
        //注册
        oberverAbleImp.register(observerA);
        oberverAbleImp.register(observerB);
        oberverAbleImp.register(observerC);
        //改变被观察者的type
        oberverAbleImp.setType(100);
        //打印观察者状态
        System.out.println(observerA.getMyType());
        System.out.println(observerB.getMyType());
        System.out.println(observerC.getMyType());
    }
}

使用java内置的方法：

在java的util包中，存在抽象方法Observable和接口Observer，顾名思义Observable就是被观察者，Observer是观察者；继承和实现这两个接口，就可以非常简单的实现观察者模式。

被观察者：

/**
 * 被观察者
 */
public class ObserverAbleInnerImp extends Observable {

    private int type;

    public int getType() {
        return type;
    }

    public void setType(int type) {
        this.type = type;
        //以下两个方法是抽象类Observable的方法，这里不做说明，需要的自己去看源码
        setChanged();  //表示目标对象已经做了更改
        notifyObservers(type);  //通知所有的观察者
    }
}

观察者：

/**
 * 观察者
 */
public class ObserverInnerImp implements Observer {

    private int mytype;

    //重写更新方法，被观察者的通知方法会调用该方法
    @Override
    public void update(Observable o, Object arg) {
        mytype=((ObserverAbleInnerImp)o).getType();
    }

    public int getMytype() {
        return mytype;
    }

    public void setMytype(int mytype) {
        this.mytype = mytype;
    }
}

测试:

public class test {
    public static void main(String[] args) {
        //被观察者
        ObserverAbleInnerImp observerAbleInnerImp = new ObserverAbleInnerImp();
        //观察者
        ObserverInnerImp observerInnerImpA = new ObserverInnerImp();
        ObserverInnerImp observerInnerImpB = new ObserverInnerImp();
        ObserverInnerImp observerInnerImpC = new ObserverInnerImp();
        //注册
        observerAbleInnerImp.addObserver(observerInnerImpA);
        observerAbleInnerImp.addObserver(observerInnerImpB);
        observerAbleInnerImp.addObserver(observerInnerImpC);
        //改变被观察者的type
        observerAbleInnerImp.setType(999999);
        //打印观察者状态
        System.out.println(observerInnerImpA.getMytype());
        System.out.println(observerInnerImpB.getMytype());
        System.out.println(observerInnerImpC.getMytype());
        //删除一个订阅者
        observerAbleInnerImp.deleteObserver(observerInnerImpB);
        //打印观察者状态
        System.out.println("删除后");
        observerAbleInnerImp.setType(888888);
        System.out.println(observerInnerImpA.getMytype());
        System.out.println(observerInnerImpB.getMytype());
        System.out.println(observerInnerImpC.getMytype());
    }
}