设计模式之观察者模式

Observer（观察者模式）

一、观察者模式简介

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

核心：

• 1、在抽象类里有一个 ArrayList 存放观察者系列
  
• 2、定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新
• 3、一个对象（目标对象）的状态发生改变，所有的依赖对象（观察者对象）都将得到通知，进行广播通知

二、观察者模式优缺点比较

优点：

• 1、观察者和被观察者是抽象耦合的
• 2、建立一套触发机制

缺点：

• 1、如果一个被观察者对象有很多的直接和间接的观察者的话，将所有的观察者都通知到会花费很多时间
• 2、如果在观察者和观察目标之间有循环依赖的话，观察目标会触发它们之间进行循环调用，可能导致系统崩溃
• 3、观察者模式没有相应的机制让观察者知道所观察的目标对象是怎么发生变化的，而仅仅只是知道观察目标发生了变化

使用场景：

• 1、聊天室程序、网络游戏
• 2、邮件订阅、监听器等

注意事项：1、JAVA 中已经有了对观察者模式的支持类。 2、避免循环引用。 3、如果顺序执行，某一观察者错误会导致系统卡壳，一般采用异步方式。

三、UML类图

四、设计实现

  步骤1：创建抽象目标对象Subject

public abstract class Subject { 
    
    protected List<Observer> lists = new ArrayList<>();
    
    public void register(Observer o) {
         lists.add(o);
    }
    
    public void removeObserver(Observer o) {
        lists.remove(o);
    }
    
    public void notifyObservers() {
        for(Observer o: lists ) {
            o.update(this);
        }
    }
    
    public abstract void setState(int num);
 
}

 步骤2：创建具体目标对象ConcreteSubject

public class ConcreteSubject extends Subject{
    private int  num;

    public int getState() {
        return num;
    }

    public void setState(int state) {
        this.num = state;
        this.notifyObservers();
    }

}

步骤3：创建观察者接口

public interface Observer {
    void update(Subject s);
}

步骤4：创建实现观察者接口的具体观察类

public class ObserverA implements Observer {
    
    private int  state;
    
    public ObserverA(Subject s) {
          s.register(this);
    }

    public int getState() {
        return state;
    }

    public void setState(int state) {
        this.state = state;
    }
    
    @Override
    public void update(Subject s) {
        this.state = ((ConcreteSubject)s).getState();
    }
}

步骤5：调用者测试

public class ObserverDemo {    
    public static void main(String[] args) {
        ConcreteSubject subject = new ConcreteSubject();
        ObserverA os1 = new ObserverA(subject);
        ObserverA os2 = new ObserverA(subject);
        ObserverA os3 = new ObserverA(subject);
        subject.setState(100);
        System.out.println(os1.getState());
        System.out.println(os2.getState());
        System.out.println(os3.getState());
        System.out.println("----------------------------------------");
        subject.setState(3000);
        System.out.println(os1.getState());
        System.out.println(os2.getState());
        System.out.println(os3.getState());
    }
}

步骤6：运行程序，观察结果

 五、JAVASE观察者模式实现（java.util包）

  步骤1：创建实现Observer接口的具体类

import java.util.Observable;
import java.util.Observer;
public class ObserverB implements Observer{
    
    private String state;
    
    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }

    @Override
    public void update(Observable o, Object arg) {
        this.state = ((TargetObject)o).getState();
    }
}

步骤2：创建实现Observable接口的具体目标对象

import java.util.Observable;
public class TargetObject extends Observable{
    
    private String state;

    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;//目标对象发生改变
        setChanged();//表明目标对象已经做了更改
        notifyObservers(state);//通知所有的观察者
    }
}

步骤3：调用者测试

public class ObserverDemo02 {    
    public static void main(String[] args) {
        TargetObject t = new TargetObject();
        ObserverB ob1 = new ObserverB();
        ObserverB ob2 = new ObserverB();
        ObserverB ob3 = new ObserverB();
         t.addObserver(ob1);
         t.addObserver(ob2);
         t.addObserver(ob3);
         t.setState("red");
         System.out.println(ob1.getState());
         System.out.println(ob2.getState());
         System.out.println(ob3.getState());
         System.out.println("---------------------------------------");
         t.setState("blue");
         System.out.println(ob1.getState());
         System.out.println(ob2.getState());
         System.out.println(ob3.getState());
    }
}

步骤4：运行程序，观察结果