设计模式-观察者模式

1、概述

观察者模式，也称发布订阅模式，是一种行为型设计模式，它定义了一种一对多的依赖关系，当一个对象的状态发生了改变时，其所有依赖对象都会收到通知并自动更新。我们就可以简单地称这一个被依赖的对象为被观察者，多个依赖对象为观察者。

主题（Subject）：也可以称之为可观察者和被观察者。它是一个具有状态的对象，维护一个观察者列表，提供添加、删除、通知观察者的方法；
观察者（Observer）：接收主题通知的对象。实现一个更新方法，当接受通知时，进行更新操作。
具体主题（Concreate Subject）：主题的具体实现类。
具体观察者（Concreate Observer）：观察者的具体实现类。

2、优缺点

优点：

观察者和被观察者之间是抽象耦合

建立一套触发机制

缺点：

观察者模式需要考虑一下开发效率和运行效率问题， 一个被观察者，多个观察者，开发和调试就会比较复杂，如果通知默认是顺序执行， 一个观察者卡壳，会影响整体的执行效率。

3、实现方式

import java.util.*;
/**
 * 客户端代码，用于展示运行
 */
public class Test {
    public static void main(String[] args) {
        Subject mouse = new Mouse();
        mouse.setState(1);  // 用0这个状态代表老鼠没有任何动作
        Observer cat = new Cat();
        mouse.attach(cat);  // 注册cat这个观察者
        if (mouse.getState() != 0) {
            mouse.notifys(); // 老鼠有了新的动作，猫开始捉老鼠
        }
    }
}


/**
 * 主题类
 */
public interface Subject {
    
    List<Observer> observers = new ArrayList<Observer>();

    // 用于增加观察者
    void attach(Observer obs);
    // 用于删除观察者
    void detach(Observer obs);
    // 用于通知观察者
    void notifys();

    int getState();
    void setState(int state);
}


/**
 * 观察者类
 */
public interface Observer {
    public void update();
}


/**
 * 具体的主题类，以老鼠为例
 */
public class Mouse implements Subject {
    
    private List<Observer> observers = new ArrayList<Observer>();
    private int state;

	@Override
    public void attach(Observer obs) {
        observers.add(obs);
    }

	@Override
    public void detach(Observer obs) {
        observers.remove(obs);
    }

	@Override
    public void notifys() {
        for (Observer observer : observers) {
            observer.update();
        }
    }

	@Override
    public void setState(int state) {
        this.state = state;
    }

	@Override
    public int getState() {
        return state;
    }
}



/**
 * 具体的观察者类，以猫为例
 */
public class Cat implements Observer {
    public void update() {
        System.out.println("猫开始捉老鼠");
    }
}

4、应用场景

关联行为场景，当一个对象的改变需要同时改变其他对象的时候，而且它不知道具体有多少对象有待改变时。 需要注意的是， 关联行为是可拆分的， 而不是“组合”关系。
事件多级触发场景。
跨系统的消息交换场景， 如消息队列的处理机制。