23个设计模式学习笔记：05.观察者模式

动机(Motivation)

在软件构建过程中，我们需要为某些对象建立一种“通知依赖关系”，——一个对象(目标对象)的状态发生改变，所有的依赖对象(观察者对象)都将得到通知，如果这样的依赖关系过于紧密，将使软件不能很好地抵御变化

使用面向对象技术，可以将这种依赖关系弱化，并形成一种稳定的依赖关系，从而实现软件体系的松耦合

模式定义

定义对象间的一种一对多(变化)的依赖关系，以便当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并自动更新

观察者模式又叫做发布-订阅（Publish/Subscribe）模式、源-监听（Source/Listener）模式

结构(Structure)

要点总结

• 使用面向对象的抽象，Observer模式使得我们可以独立地改变目标与观察者，从而使二者之间的依赖关系达致松耦合
• 目标发送通知时，无需指定观察者，通知(可以携带通知信息作为参数)会自动传播
• 观察者自己决定是否需要订阅通知，目标对象对此一无所知
• Observer模式是基于事件的UI框架中非常常用的设计模式，也是MVC模式的一个重要组成部分

代码示例

Tomcat中的生命周期管理机制的实现采用了观察者模式，相关代码示例如下：

• Lifecycle(event source)：相当于抽象主题角色，所有的容器类与组件实现类都实现了这个接口。如StandardContext
• LifecycleListener(event listener)：相当于抽象观察者角色,具体的实现类有ContextConfig, HostConfig, EngineConfig类，它们在容器启动时与停止时触发
• LifecycleEvent(event object)：生命周期事件，对主题与发生的事件进行封装
• LifecycleSupport：生命周期管理的实用类，提供对观察者的添加，删除及通知观察者的方法
• LifecycleException：生命周期异常类

public interface Lifecycle {
    
    /**
     * Add a LifecycleEvent listener to this component.
     *
     * @param listener The listener to add
     */
    public void addLifecycleListener(LifecycleListener listener);


    /**
     * Get the life cycle listeners associated with this life cycle. If this
     * component has no listeners registered, a zero-length array is returned.
     */
    public LifecycleListener[] findLifecycleListeners();


    /**
     * Remove a LifecycleEvent listener from this component.
     *
     * @param listener The listener to remove
     */
    public void removeLifecycleListener(LifecycleListener listener);
    
}

public interface LifecycleListener {


    /**
     * Acknowledge the occurrence of the specified event.
     *
     * @param event LifecycleEvent that has occurred
     */
    public void lifecycleEvent(LifecycleEvent event);


}

public final class LifecycleSupport {


    // ----------------------------------------------------------- Constructors


    /**
     * Construct a new LifecycleSupport object associated with the specified
     * Lifecycle component.
     *
     * @param lifecycle The Lifecycle component that will be the source
     *  of events that we fire
     */
    public LifecycleSupport(Lifecycle lifecycle) {

        super();
        this.lifecycle = lifecycle;

    }


    // ----------------------------------------------------- Instance Variables


    /**
     * The source component for lifecycle events that we will fire.
     */
    private Lifecycle lifecycle = null;


    /**
     * The set of registered LifecycleListeners for event notifications.
     */
    private LifecycleListener listeners[] = new LifecycleListener[0];

    private final Object listenersLock = new Object(); // Lock object for changes to listeners


    // --------------------------------------------------------- Public Methods


    /**
     * Add a lifecycle event listener to this component.
     *
     * @param listener The listener to add
     */
    public void addLifecycleListener(LifecycleListener listener) {

      synchronized (listenersLock) {
          LifecycleListener results[] =
            new LifecycleListener[listeners.length + 1];
          for (int i = 0; i < listeners.length; i++)
              results[i] = listeners[i];
          results[listeners.length] = listener;
          listeners = results;
      }

    }


    /**
     * Get the lifecycle listeners associated with this lifecycle. If this
     * Lifecycle has no listeners registered, a zero-length array is returned.
     */
    public LifecycleListener[] findLifecycleListeners() {

        return listeners;

    }


    /**
     * Notify all lifecycle event listeners that a particular event has
     * occurred for this Container.  The default implementation performs
     * this notification synchronously using the calling thread.
     *
     * @param type Event type
     * @param data Event data
     */
    public void fireLifecycleEvent(String type, Object data) {

        LifecycleEvent event = new LifecycleEvent(lifecycle, type, data);
        LifecycleListener interested[] = listeners;
        for (int i = 0; i < interested.length; i++)
            interested[i].lifecycleEvent(event);

    }


    /**
     * Remove a lifecycle event listener from this component.
     *
     * @param listener The listener to remove
     */
    public void removeLifecycleListener(LifecycleListener listener) {

        synchronized (listenersLock) {
            int n = -1;
            for (int i = 0; i < listeners.length; i++) {
                if (listeners[i] == listener) {
                    n = i;
                    break;
                }
            }
            if (n < 0)
                return;
            LifecycleListener results[] =
              new LifecycleListener[listeners.length - 1];
            int j = 0;
            for (int i = 0; i < listeners.length; i++) {
                if (i != n)
                    results[j++] = listeners[i];
            }
            listeners = results;
        }

    }


}

参考资料

Tomcat生命周期管理与观察者模式
二.观察者模式使用(Tomcat)