设计模式之观察者模式学习理解

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

介绍

意图：定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。

主要解决：一个对象状态改变给其他对象通知的问题，而且要考虑到易用和低耦合，保证高度的协作。

何时使用：一个对象（目标对象）的状态发生改变，所有的依赖对象（观察者对象）都将得到通知，进行广播通知。

如何解决：使用面向对象技术，可以将这种依赖关系弱化。

关键代码：在抽象类里有一个 ArrayList 存放观察者们。

应用实例： 1、京东上某个商品暂时没货，提示用户关注后到货通知，这个暂时无货的商品是被观察者，点击关注这个商品的用户就是观察者。 2、老师针对成绩在60分以下的同学定期发送最新的考题分析邮件，每轮考试下来都会有不及格的同学，由不及格变为及格的同学自动从邮件列表里移除，新的不及格的同学会被加进邮件列表里。

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

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

使用场景： 1、有多个子类共有的方法，且逻辑相同。 2、重要的、复杂的方法，可以考虑作为模板方法。

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

下面这个实例是系统中常会遇到的：

场景描述：
* 系统有一个模块：工单管理，它有三个子模块，工单创建，工单激活，工单处理
* 系统有两个角色：管理员、安装工
* 管理员可以操作所有的子模块，安装工只能操作工单处理
* 现在需要添加删除子模块的时候自动通知到对应的角色，使其添加删除对应的模块权限

自己实现的观察者模式

被观察者类

/**
 * 工单管理  被观察者类
 * @author ko
 *
 */
public class OrderManage {

    private List<AbstractRole> roles = new ArrayList<>();// 观察者集合    角色
    private List<String> submodules = new ArrayList<>();// 子模块集合
    
    public void attach(AbstractRole role){
        roles.add(role);
    }
    
    // 删除某个子模块
    public void removeSubmodule(String submodule){
        submodules.remove(submodule);
        // 删除好后通知观察者
        notifyRelevantRoles("removeSubmodule "+submodule);
    }
    
    // 添加某个子模块
    public void addSubmodule(String submodule){
        if (!submodules.contains(submodule)) {
            submodules.add(submodule);
            // 添加好后通知观察者
            notifyRelevantRoles("addSubmodule "+submodule);
        }
    }

    private void notifyRelevantRoles(String msg) {
        for (AbstractRole role : roles) {
            role.update(msg);
        }
    }
    
}

抽象观察者类

/**
 * 抽象观察者类 抽象角色类
 * @author ko
 *
 */
public abstract class AbstractRole {
    
    protected OrderManage orderManage;
    protected String roleName;
    
    public abstract void update(String msg);

}

具体观察者类，管理员

/**
 * 具体观察者类，管理员角色不管操作的是什么子模块，都更新相关信息
 * @author ko
 *
 */
public class Administrators extends AbstractRole {
    
    public Administrators(OrderManage orderManage,String roleName) {
        this.roleName = roleName;
        this.orderManage = orderManage;
        orderManage.attach(this);// 注册观察者到被观察者
    }

    @Override
    public void update(String msg) {
        System.out.println(roleName+"receive OrderManage msg:"+msg);
    }

}

具体观察者类，安装工

/**
 * 具体观察者类，安装工角色只能操作工单处理子模块，更新相关信息
 * @author ko
 *
 */
public class Installer extends AbstractRole {

    public Installer(OrderManage orderManage,String roleName) {
        this.roleName = roleName;
        this.orderManage = orderManage;
        orderManage.attach(this);// 注册观察者到被观察者
    }

    @Override
    public void update(String msg) {
        if (msg.contains("工单处理")) {
            System.out.println(roleName+"receive OrderManage msg:"+msg);
        }
    }

}

测试类

/**
 * 测试类
 * 观察者模式 Observer Pattern
 * 场景描述：
 *     系统有一个模块：工单管理，它有三个子模块，工单创建，工单激活，工单处理
 *  系统有两个角色：管理员、安装工
 *  管理员可以操作所有的子模块，安装工只能操作工单处理
 *  现在需要添加删除子模块的时候自动通知到对应的角色，使其添加删除对应的模块权限
 * @author ko
 *
 */
public class Test {

    public static void main(String[] args) {
        OrderManage orderManage = new OrderManage();
        new Administrators(orderManage,"管理员");
        new Installer(orderManage,"安装工");
        
        
        // 添加一个子模块 工单创建
        System.out.println("创建子模块工单创建");
        orderManage.addSubmodule("工单创建");
        
        System.out.println("");
        System.out.println("创建子模块工单处理");
        orderManage.addSubmodule("工单处理");
        
        System.out.println("");
        System.out.println("创建子模块工单激活");
        orderManage.addSubmodule("工单激活");
        
        System.out.println("");
        System.out.println("删除子模块工单处理");
        orderManage.removeSubmodule("工单处理");
    }
    
}

运行结果

创建子模块工单创建
管理员receive OrderManage msg:addSubmodule 工单创建

创建子模块工单处理
管理员receive OrderManage msg:addSubmodule 工单处理
安装工receive OrderManage msg:addSubmodule 工单处理

创建子模块工单激活
管理员receive OrderManage msg:addSubmodule 工单激活

删除子模块工单处理
管理员receive OrderManage msg:removeSubmodule 工单处理
安装工receive OrderManage msg:removeSubmodule 工单处理

　　

java自带的观察者模式

Observer对象是观察者，Observable对象是被观察者。

a.实现观察者模式

实现观察者模式非常简单，

[1]创建被观察者类，它继承自java.util.Observable类；

[2]创建观察者类，它实现java.util.Observer接口；

b.对于被观察者类

添加它的观察者：

void addObserver(Observer o)

addObserver()方法把观察者对象添加到观察者对象列表中

当被观察者中的事件发生变化时，执行

setChanged();

notifyObservers();

setChange()方法用来设置一个内部标志位注明数据发生了变化；notifyObservers()方法会去调用观察者对象列表中所有的Observer的update()方法，通知它们数据发生了变化。

只有在setChange()被调用后，notifyObservers()才会去调用update()。

c.对于观察者类，实现Observer接口的唯一方法update

void update(Observable o, Object arg)

形参Object arg，对应一个由notifyObservers(Object arg);传递来的参数，当执行的是notifyObservers();时，arg为null。

使用java自带的封装的类实现观察者模式
* 场景模拟：报警管理
* 汽车租赁公司把车子租出去后，还是要监控车子的使用情况，防止不法之徒动歪心思，给公司造成损失。
* 当出现以下情形时，汽车会发出报警，相关人员接到报警信息后，会及时跟进处理。
* A：进出围栏报警
* B：gps终端拆除报警
* C：二押报警
* 追车员可以接收到B C报警，数据分析员可以接收到A B C类报警，银行抵押代理可以收到C类报警

被观察者类

/**
 * 被观察者类
 * 报警管理
 * @author ko
 *
 */
public class AlarmManage extends Observable {
    
    private String msg = "";
    
    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        System.out.println(msg);
        if (!this.msg.equals(msg)) {
            this.msg = msg;
            setChanged();// 改变通知者的状态
        }
        notifyObservers();// 调用父类Observable方法，通知所有观察者
    }
　　
    // 具体业务操作 当前环境下就是 模拟报警触发
    public void simulationAlarm(String carNum,String alarmType){
        setMsg(carNum+"触发了："+alarmType);
    }
    // 下面的这些方法没有特殊需求可以不重写，这边列出来只是为了了解一下jdk源码
    // 如果观察者与集合中已有的观察者不同，则向对象的观察者集中添加此观察者。
    @Override
    public synchronized void addObserver(Observer o) {
        // TODO Auto-generated method stub
        super.addObserver(o);
    }

    // 指示对象不再改变，或者它已对其所有的观察者通知了最近的改变，所以 hasChanged 方法将返回 false。
    @Override
    protected synchronized void clearChanged() {
        // TODO Auto-generated method stub
        super.clearChanged();
    }

    // 返回 Observable 对象的观察者数目
    @Override
    public synchronized int countObservers() {
        // TODO Auto-generated method stub
        return super.countObservers();
    }

    // 从对象的观察者集合中删除某个观察者
    @Override
    public synchronized void deleteObserver(Observer o) {
        // TODO Auto-generated method stub
        super.deleteObserver(o);
    }
    
    // 清除观察者列表，使此对象不再有任何观察者。
    @Override
    public synchronized void deleteObservers() {
        // TODO Auto-generated method stub
        super.deleteObservers();
    }

    // 测试对象是否改变。
    @Override
    public synchronized boolean hasChanged() {
        // TODO Auto-generated method stub
        return super.hasChanged();
    }

    // 如果 hasChanged方法指示对象已改变，则通知其所有观察者，并调用 clearChanged 方法来指示此对象不再改变。
    @Override
    public void notifyObservers() {
        // TODO Auto-generated method stub
        super.notifyObservers();
    }

    // 如果 hasChanged 方法指示对象已改变，则通知其所有观察者，并调用 clearChanged 方法来指示此对象不再改变。
    @Override
    public void notifyObservers(Object arg) {
        // TODO Auto-generated method stub
        super.notifyObservers(arg);
    }
    
    // 标记此 Observable 对象为已改变的对象；现在 hasChanged 方法将返回 true。
    @Override
    protected synchronized void setChanged() {
        // TODO Auto-generated method stub
        super.setChanged();
    }
    
    
}

观察者类

/**
 * 观察者类
 * 追车员
 * 只能接收到 gps终端拆除报警、二押报警
 * @author ko
 *
 */
public class ChaseCarPerson implements Observer {

    private String pname;
    
    public ChaseCarPerson(String pname, AlarmManage alarmManage) {
        this.pname = pname;
        alarmManage.addObserver(this);
    }

    @Override
    public void update(Observable observable, Object arg1) {
        String msg = ((AlarmManage) observable).getMsg();
        if(msg.contains("gps终端拆除报警") || msg.contains("二押报警")){
            System.out.println("追车员"+pname+"接收到报警信息："+msg);
        }
    }

}

/**
 * 观察者类
 * 数据分析员
 * 能接收到所有报警
 * @author ko
 *
 */
public class AnalysisPerson implements Observer {

    private String pname;
    
    public AnalysisPerson(String pname, AlarmManage alarmManage) {
        this.pname = pname;
        alarmManage.addObserver(this);
    }
    
    @Override
    public void update(Observable observable, Object arg1) {
        String msg = ((AlarmManage) observable).getMsg();
        System.out.println("数据分析员"+pname+"接收到报警信息："+msg);
    }

}

/**
 * 观察者类
 * 银行代理员
 * 只能接收到二押报警
 * @author ko
 *
 */
public class BankAgentPerson implements Observer {

    private String pname;
    
    public BankAgentPerson(String pname, AlarmManage alarmManage) {
        this.pname = pname;
        alarmManage.addObserver(this);
    }
    
    @Override
    public void update(Observable observable, Object arg1) {
        String msg = ((AlarmManage) observable).getMsg();
        if (msg.contains("二押报警")) {
            System.out.println("银行代理员"+pname+"接收到报警信息："+msg);
        }
    }

}

测试类

/**
 * 测试类
 * 使用java自带的封装的类实现观察者模式
 * 场景模拟：报警管理
 *         汽车租赁公司把车子租出去后，还是要监控车子的使用情况，防止不法之徒动歪心思，给公司造成损失。
 *         当出现以下情形时，汽车会发出报警，相关人员接到报警信息后，会及时跟进处理。
 *         A：进出围栏报警
 *         B：gps终端拆除报警
 *         C：二押报警
 *         追车员可以接收到B C报警，数据分析员可以接收到A B C类报警，银行抵押代理可以收到C类报警
 * @author ko
 *
 */
public class Test {
    static String[] alarmTypes = new String[]{"进出围栏报警","gps终端拆除报警","二押报警"};
    static String[] cars = new String[]{"沪A125KL","蒙A985NL","闵D668YY"};
    
    public static void main(String[] args) {
        // 新建被观察者
        AlarmManage alarmManage = new AlarmManage();
        
        // 新建观察者的同时就将其加入到了被观察者
        ChaseCarPerson chaseCarPerson = new ChaseCarPerson("mr wang", alarmManage);
        AnalysisPerson analysisPerson = new AnalysisPerson("mr li", alarmManage);
        BankAgentPerson bankAgentPerson = new BankAgentPerson("mr sun", alarmManage);
        
        System.out.println("被观察者报警管理里共有"+alarmManage.countObservers()+"个观察者。");
        
        // 触发报警
        for (int i = 0; i < alarmTypes.length; i++) {
            alarmManage.simulationAlarm(getCarNumRandom(), getAlarmTypeRandom());
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("");
        }
        
        // 从被观察者删除观察者追车员
        alarmManage.deleteObserver(chaseCarPerson);
        System.out.println("从被观察者删除追车员");
        
        System.out.println("被观察者报警管理里还有"+alarmManage.countObservers()+"个观察者。");
    }
    
    public static String getCarNumRandom(){
        return cars[new Random().nextInt(3)];
    }
    public static String getAlarmTypeRandom(){
        return alarmTypes[new Random().nextInt(3)];
    }
}

运行结果

被观察者报警管理里共有3个观察者。

闵D668YY触发了：gps终端拆除报警
数据分析员mr li接收到报警信息：闵D668YY触发了：gps终端拆除报警
追车员mr wang接收到报警信息：闵D668YY触发了：gps终端拆除报警

蒙A985NL触发了：进出围栏报警
数据分析员mr li接收到报警信息：蒙A985NL触发了：进出围栏报警

沪A125KL触发了：进出围栏报警
数据分析员mr li接收到报警信息：沪A125KL触发了：进出围栏报警

从被观察者删除追车员

被观察者报警管理里还有2个观察者。

总结

可以看出jdk自带的观察者模式还是比自己实现的代码更健全，考虑到了多线程情况下的使用，加入了同步机制。另外redis里的pub/sub也有这样的功能，可以实现观察者模式。