再战设计模式(十七)之行为型-观察者模式

观察者模式

主要内容是:用于1->N的通知,当一个对象subject(目标对象subject)的状态变化时,他需要及时的告知一系列的对象(观察者,observer),让他们做出响应

1.推每次都会把通知以广播的形式发送给所有观察者,所有的观察者只能被动的接受

2.拉: 观察者只要知道有情况即可,至于什么时候获取内容.获取什么内容,都可以自主决定

角色

observer:

接口或者抽象类,当subject发生变化时,observer对象通过一个方法函数得到通知

subject :

目标对象,里面有所有的观察者,当状态修改的时候更新所有观察者

被观察者的对象,当被观察者的状态发生变化时,需要通知队列中所有观察者对象,subject需要维持(添加,删除,通知)一个观察者队列列表

concreteSubject :

被观察者具体的实现,包含一些基本属性的状态和其他操作

concreteObserver:

具体的观察者实现,得到通知后完成一些具体的业务逻辑操作

类图:

代码:

观察者接口:

public interface Observer {

    void update(Subject subject);
}

/*
*目标对象父类
*/

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

public class Subject {



    private List<Observer> list = new ArrayList<>();

    public void registerObserver(Observer obj){
        list.add(obj);


    }

    public void removeObserver(Observer observer){
        list.remove(observer);
    }


    protected void notifyAllObserve(){
        for (Observer observer : list) {
            observer.update(this);
        }
    }

}


/**
 * 具体对象
 */
public class ConcreteSubject extends  Subject {

    private int state;

    public int getState() {
        return state;
    }

    public void setState(int state) {
        this.state = state;
        //通知所有观察者.
        this.notifyAllObserve();
    }
}


/**
 * 具体的子类
 */
public class ObserverAImpl implements Observer {

    private int mystate;//需要和目标对象的state保持一致
    @Override
    public void update(Subject subject) {
        mystate= ((ConcreteSubject)subject).getState();
    }


    public int getMystate() {
        return mystate;
    }

    public void setMystate(int mystate) {
        this.mystate = mystate;
    }
}


调用者:
public class Client {

    public static void main(String[] args) {

        ConcreteSubject subject =  new ConcreteSubject();
        ObserverAImpl observer3 =  new ObserverAImpl();
        ObserverAImpl observer1 =  new ObserverAImpl();
        ObserverAImpl observer2 =  new ObserverAImpl();

        subject.registerObserver(observer1);
        subject.registerObserver(observer3);
        subject.registerObserver(observer2);

        subject.setState(20);

        System.out.println("---------------");
        System.out.println(observer1.getMystate());
        System.out.println(observer2.getMystate());
        System.out.println(observer3.getMystate());
    }
}

当我们的具体对象状态一改变的时候,所有观察者的状态都会改变

使用jdk的observer实现代码如下:

//目标对象
public class ConcreteSubject extends Observable {


    public  int state;

    /**
     * 目标对象的状态改变
     * @param state
     */
    public void setState(int state) {
        this.state = state;
        setChanged();//表示目标对象已经修改了
        notifyObservers(state);//通知所有观察者
    }

    public int getState() {
        return state;
    }
}


public class ObserverA implements Observer {

    public int mystate;
    @Override
    public void update(Observable o, Object arg) {

        mystate = ((ConcreteSubject) o).getState();
    }

    public int getMystate() {
        return mystate;
    }

    public void setMystate(int mystate) {
        this.mystate = mystate;
    }
}



public class Client {
    public static void main(String[] args) {

        ConcreteSubject subject = new ConcreteSubject();

        ObserverA o1 = new ObserverA();
        ObserverA o2 = new ObserverA();
        ObserverA o3= new ObserverA();


        subject.addObserver(o1);
        subject.addObserver(o2);
        subject.addObserver(o3);

        subject.setState(200);
        System.out.println(o1.getMystate());
        System.out.println(o2.getMystate());
        System.out.println(o3.getMystate());
        System.out.println("=============");
        subject.setState(3000);
        System.out.println(o1.getMystate());
    }
}

效果和我们写的是一样的.代码更为简洁