设计模式原来如此-观察者模式（Observer Pattern）

观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态上发生变化时，会通知所有观察者对象，让他们能够主动更新自己。

 

观察者模式的组成

1．  抽象主题角色(Subject)：把所有对观察者对象的引用保存在一个集合中，每个抽象主题角色都可以有任意数量的观察者。抽象主题提供了一个接口，可以增加和删除观察者角色。一般用一个抽象类或接口来实现。

2．  抽象观察者角色(Observer)：为所有具体的观察者定义一个接口，在得到主题的通知时更新自己。

3．  具体主题角色：在具体主题内部状态改变时，给所有登记过的观察者发出通知。具体主题角色通常用一个子类实现。

4．  具体观察者角色：该角色实现抽象观察者角色所要求的更新接口，以便使本身的状态与主题的状态相协调。如果需要，具体观察者角色可以保存一个指向具体主题角色的引用，通常用一个子类实现。

 

观察者模式的应用

观察者模式的优点

1.      观察者和被观察者之间是抽象耦合：如此设计，则不管是增加观察者还是被观察者都非常容易扩展，而且在Java中都已经实现了抽象层次的定义，在系统扩展方面更是得心应手。

2.      建立一套触发机制：根据单一职责原则，每个类的职责是单一的，那么怎么把各个单一的职责串联成真实世界的复杂的逻辑关系呢？比如，猎人去打猎，打死了一只羚羊，母羊有三个幼崽，因失去了母羊而饿死，尸体又被四只狼争抢，因分配不均，狼开始斗殴，然后输了的狼死掉，生成下来的狼，则因此扩大了地盘。这就是一个触发机制，形成了一个触发链。观察者模式可以完美地实现这里的链条形式。

 

观察者模式的缺点

1.      观察者模式需要考虑一下开发效率和运行效率问题，一个被观察者，多个观察者，开发和调试就会比较复杂，而且在Java中消息的通知默认是顺序执行，一个观察者卡壳，就会影响整体的执行效率。在这种情况下，一般考虑采用异步的方式。

2.      多级触发时的效率更是让人担忧，大家在设计时注意考虑。

 

观察者模式的使用场景

1.      关联行为场景。需要注意的是，关联行为是可拆分的，而不是“组合”关系。

2.      事件多级触发场景。

3.      跨系统的消息交换场景，如消息队列的处理机制。

 

观察者模式的注意事项

使用观察者模式也有以下两个重点问题要解决。

1.      广播链的问题：如果你做过数据库的触发器，你就应该知道有一个触发器链的问题，比如表A上写了一个触发器，内容是一个字段更新后更新表B的一条数据，而表B上也有个触发器，要更新表C，表C也有触发器…，这个数据库基本上就毁掉了。我们的观察者模式也是一样的问题，一个观察者可以有双重身份，既是观察者，也是被观察者，这没什么问题呀，但是链一旦建立，这个逻辑就比较复杂，可维护性非常差，根据经验建议，在一个观察者模式中最多出现一个对象既是观察者也是被观察者，也就是说消息最多转发一次（传递两次），这还是比较好控制的。

2.      异步处理问题：这个EJB是一个非常好的例子，被观察者发生动作了，观察者要做出回应，如果观察者比较多，而且处理时间比较长怎么办？那就用异步呗，异步处理就要考虑线程安全和队列的问题，这个大家有时间看看Message Queue，就会有更深的了解。

 

实例

下面我们举个实例来说明一下观察者模式的使用。孩子睡觉了，妈妈要出去办事，走之前交代爸爸，孩子醒后给他喂吃的。现在孩子是被观察者，爸爸是观察者。如果爸爸一直盯着孩子醒没醒，是一个很笨的办法，因为这样爸爸就干不了其他的事。所以用到了触发，孩子一醒就告诉爸爸，爸爸就马上喂孩子吃的。

抽象主题角色(Subject)

package com.zhouyu.myobserver;

public interface Observable
{
    public void addObserver(Observer o);

    public void removeObserver(Observer o);

    public void notifyObservers(String str);
}

抽象观察者角色(Observer)

package com.zhouyu.myobserver;

public interface Observer
{
    public void update(String str);
}

具体主题角色

package com.zhouyu.myobserver;

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

public class Child implements Observable
{
    private List<Observer> list = new ArrayList<Observer>();

    @Override
    public void addObserver(Observer o)
    {
        list.add(o);
    }

    @Override
    public void removeObserver(Observer o)
    {
        list.remove(o);
    }

    @Override
    public void notifyObservers(String str)
    {
        for(Observer o : list)
        {
            o.update(str);
        }
    }

    public void wakeUp()
    {
        this.notifyObservers("我醒了");
    }
}

具体观察者角色

package com.zhouyu.myobserver;

public class Dad implements Observer
{
    @Override
    public void update(String str)
    {
        System.out.println(str);
        this.eat();
    }

    public void eat()
    {
        System.out.println("孩子醒了，马上喂吃的");
    }
}

场景类

package com.zhouyu.myobserver;

public class Client
{
    public static void main(String[] args)
    {
        Dad d = new Dad();
        Child c = new Child();

        c.addObserver(d);
        c.wakeUp();
    }
}

观察者模式在Java语言中的地位极其重要，JDK也提供了对观察者模式的内置支持，这就是java.util.Observable实现类和java.util.Observer接口，我们上面写的那个例子中的Observable接口可以改换成java.util.Observable实现类了。

 

Observable类用于创建可以观测到你的程序中其他部分的子类。当这种子类的对象发生变化时，观测类被通知。观测类必须实现定义了update()方法的Observer接口。当一个观测程序被通知到一个观测对象改变时，update()方法被调用。

 

一个被观测的对象必须服从下面两个简单规则。

1.      如果它被改变了，它必须调用setChanged()方法。

2.      当它准备通知观测程序它的改变时，它必须调用notifyObservers()方法。这导致了在观测对象中对update()方法的调用。注意：当对象在调用notifyObservers()方法之前，没有调用setChanged()方法，就不会有什么动作发生。在update()被调用之前，被观测对象必须调用setChanged()和notifyObservers()两种方法。

 

notifyObservers()有两种形式：一种带有参数而另一种没有。当用参数调用notifyObservers()方法时，该对象被传给观测程序的update()方法作为其第二个参数。否则，将给update()方法传递一个null。可以使用第二个参数传递适合于你的应用程序的任何类型的对象。

 

为了观测一个可观测的对象，必须实现Observer接口。这个接口仅仅定义了如下所示的一个方法。Void update(Observable obserOb,Object arg)，这个observOb是被观测的对象，而arg是由notifyObservers()方法传递的值。当被观测对象发生了改变，调用update()方法。

 

下面实例，我们用JDK提供的java.util.Observable实现类和java.util.Observer接口来代替我们自己写的类。

child.java

package com.zhouyu.jdkObserver;

import java.util.Observable;

public class Child extends Observable
{
    public void wakeUp()
    {
        super.setChanged();
        super.notifyObservers("我醒了");
    }
}

Dad.java

package com.zhouyu.jdkObserver;

import java.util.Observable;
import java.util.Observer;

public class Dad implements Observer
{
    @Override
    public void update(Observable o, Object arg)
    {
        System.out.println(arg.toString());
        this.eat();
    }

    public void eat()
    {
        System.out.println("孩子醒了，马上喂吃的");
    }
}

Client.java

package com.zhouyu.jdkObserver;

public class Client
{
    public static void main(String[] args)
    {
        Dad d = new Dad();
        Child c = new Child();

        c.addObserver(d);
        c.wakeUp();
    }
}

项目中真实的观察者模式

1.      观察者和被观察者之间的消息沟通：被观察者状态改变会触发观察者的一个行为，同时会传递一个消息给观察者，这是正确的，在实际中一般的做法是：观察者中的update方法接受两个参数，一个是被观察者，一个是DTO（Data Transfer Object，据传输对象），DTO一般是一个纯洁的JavaBean，由被观察者生成，由观察者消费。当然，如果考虑到远程传输，一般消息以XML格式传递。

2.      观察者响应方式：我们这样来想一个问题，观察者是一个比较复杂的逻辑，它要接受被观察者传递过来的信息，同时还要对他们进行逻辑处理，在一个观察者多个被观察者的情况下，性能就需要提到日程上来考虑了，为什么呢？如果观察者来不及响应，被观察者的执行时间是不是也会被拉长？那现在的问题就是：观察者如何快速响应？有两个办法，一是采用多线程技术，不管是被观察者启动线程还是观察者启动线程，都可以明显的提高系统性能，这也就是大家通常所说的异步架构；二是缓存技术，不管你谁来，我已经准备了足够的资源给你了，我保证快速响应，这当然也是一种比较好的方案，代价就是开发难度很大，而且压力测试要做的足够充分，这种方案也就是大家说的同步架构。

3.      被观察者尽量自己做主：这是什么意思呢？被观察者的状态改变是否一定要通知观察者呢？不一定吧，在设计的时候要灵活考虑，否则会加重观察者的处理逻辑，一般是这样做的，对被观察者的业务逻辑doSomething方法实现重载，如增加一个doSomething(Boolean isNotifyObs)方法，决定是否通知观察者，而不是在消息到达观察者时才判断是否要消费。