设计模式之观察者模式-蒲公英云

设计模式之观察者模式

心已赠人 2022-04-16 06:40 329阅读 0赞

当对象间存在一对多关系时，则使用观察者模式（Observer Pattern）。比如，当一个对象被修改时，则会自动通知它的依赖对象。观察者模式属于行为型模式。
即目标发生更改通知时，观察者对象会收到通知

观察者模式通用代码

分为
推模型——主动把某一数据推送给观察者
拉模型——观察者主动到目标对象中获取数据，一般这种模型的实现中，会把目标对象自身对象自身通过update方法传递给观察者

拉模型

目标对象，它自动观察他的观察值，并提供注册（添加）和删除观察者的接口

public class Subject {
    //用来保存注册的观察者对象
    private List<Observer> observers =new ArrayList<Observer>();
    /**
     * 添加集合中的指定观察者
     * @param observer
     */
    public void attach(Observer observer){
        observers.add(observer);
    }
    /**
     * 删除集合中指定观察者
     * @param observer
     */
    public void detach(Observer observer){
        observers.remove(observer);
    }
    /**
     * 通知所有注册的观察者对象
     */
    public void notifyObservers(){
        for(Observer observer:observers){
            observer.update(this);
        }
    }
}

观察者接口，定义一个更新的接口给那些在目标发生改变的时候被通知的对象

public interface Observer {
    /**
     * 更新的接口
     * @param subject 传入目标对象，方便获取相应的目标对象的状态
     */
    public void update(Subject subject);
    }

具体的目标对象，负责把有关状态存入到相应的观察者对象中

public class ConcreteSubject extends Subject{
    //目标对象的状态
    private String subjectState;
    public String getSubjectState() {
        return subjectState;
    }
    public void setSubjectState(String subjectState) {
        this.subjectState = subjectState;
        //状态设置了 使用父类通知观察者
        this.notifyObservers();
    }
}

具体的观察者对象，实现更新的方法，使自身的状态和目标的状态保持一致

public class ConcreteObserver implements Observer {
    //观察者名字
    private String observerName;
    //观察者的状态
    private String  observerState;
    private String  observerHandle;
    public String getObserverHandle() {
        return observerHandle;
    }
    public void setObserverHandle(String observerHandle) {
        this.observerHandle = observerHandle;
    }
    public String getObserverName() {
        return observerName;
    }
    public void setObserverName(String observerName) {
        this.observerName = observerName;
    }
    /**
     * 获取目标类的状态同步到观察者的状态中
     * @param subject 传入目标对象，方便获取相应的目标对象的状态
     */
    @Override
    public void update(Subject subject) {
        observerState =((ConcreteSubject)subject).getSubjectState();
        System.out.println(observerName+"收到了:"+observerState+",处理方式"+observerHandle);
    }
}

测试类

public class Client {
    public static void main(String[] args) {
        //1.创建目标
        ConcreteSubject concreteSubject=new ConcreteSubject();
        //2.创建观察者
        ConcreteObserver concreteObserver1=new ConcreteObserver();
        concreteObserver1.setObserverName("观察者一号");
        concreteObserver1.setObserverHandle("第一种处理方式");
        ConcreteObserver concreteObserver2= new ConcreteObserver();
        concreteObserver2.setObserverName("观察者二号");
        concreteObserver2.setObserverHandle("第二种处理方式");
        //3.注册观察者
        concreteSubject.attach(concreteObserver1);
        concreteSubject.attach(concreteObserver2);
        //目标设置状态
        concreteSubject.setSubjectState("目标状态改变");
    }
}

推模型

subject

public void notifyObservers(){
        for(Observer observer:observers){
            observer.update(this);
            //observer.update(content);
        }
    }
    改成——>
     public void notifyObservers(String content){
        for(Observer observer:observers){
                  observer.update(content);
        }
    }

observer

public void update(Subject subject);
 改成——>
 public void update(String Content);

ConcreteSubject

public void setSubjectState(String subjectState) {
        this.subjectState = subjectState;
        //状态设置了 使用父类通知观察者
        this.notifyObservers();
    }
   改成——>
 //public void setSubjectState(String content){
        this.subjectState = subjectState;
        //状态设置了 使用父类通知观察者
        this.notifyObservers(content);
    }

ConcreateObserver

public void update(Subject subject) {
        observerState =((ConcreteSubject)subject).getSubjectState();
        System.out.println(observerName+"收到了:"+observerState+",处理方式"+observerHandle);
    }
    改成——>
     public void update(String content) {
        //observerState=content;
        System.out.println(observerName+"收到了:"+observerState+",处理方式"+observerHandle);
    }