JAVA设计模式之观察者模式 IT

一、定义

观察者模式即发布-订阅模式(Publish/Subscribe):定义了一种一对多的依赖关系，让多个观察者对象同事监听某一个主题对象。这个主题对象在状态发生变化时，会通知所有观察者对象，使它们能够自动更新自己。

       观察者模式结构图，如下图1-1所示:

 

图 1-1

二、实例展示

      Subjcet 类，可翻译为主题或抽象通知者，一般由一个抽象类或一个接口实现。它把所有对观察者对象的引用保存在一个聚集里，每个主题都可以有任何数量的观察者。抽象主题提供一个接口，可以增加和删除观察者对象。

abstract class Subject{
    private List<Observer> observers = new ArrayList<Observer>();
    
    //增加观察者
    public void Attach(){
        observers.Add(observer);
    }
    
    //移除观察者
    public void Detach(){
        
    }
}

      Observer类，抽象观察者，为所有的具体观察者定义了一个接口，在得到主题的通知时更新自己。这个接口叫做更新接口。抽象观察者一般用一个抽象类或者一个接口实现。更新接口通常包含一个Update()方法,这个方法叫做更新方法。

abstract class Observer{
    public abstract void Update();
}

      ConcreteSubject类，叫做具体主题或具体通知者，将有关状态存入具体观察者对象；在具体主题的内部状态改变时，给所有登记过的观察者发出通知。具体主题角色通常用一个具体子类实现。 

class ConcreteSubject extends Subject{
    private String subjectState;
    
    public String getSubjectState() {
        return subjectState;
    }

    public void setSubjectState(String subjectState) {
        this.subjectState = subjectState;
    }
}

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

class ConcreteObserver extends Observer{
    private String name;
    private String observerState;
    private ConcreteSubject subject;
    
    public ConcreteObserver(ConcreteSubject subject,String name){
        this.subject = subject;
        this.name = name;
    }
    
    @override
    public void Update(){
        observerState = subject.SubjectState;
        System.out.println("观察者"+name+"的新状态是"+observerState);
    }
    
    public String getSubjectState() {
        return subjectState;
    }

    public void setSubjectState(String subjectState) {
        this.subjectState = subjectState;
    }
}

      客户端代码:

static void Main(String[] args){
    ConcreteSubject s = new ConcreteSubject();
    
    s.Attach(new ConcreteObserver(s,"X"));
    s.Attach(new ConcreteObserver(s,"Y"));
    s.Attach(new ConcreteObserver(s,"Z"));
    
    s.SubjectState = "ABC";
    s.Notify();
}

      结果显示:

观察者X的状态是ABC
观察者Y的状态是ABC
观察者Z的状态是ABC

三、使用场景

      1、一个抽象模型有两个方面，其中一个方面依赖于另一个方面，将这两个方面封装在独立的对象中使它们各自独立地改变和复用。

      2、当一个对象的改变需要同时改变其它对象的时候。

四、使用总结

       1、观察者模式的主要优点如下:

             1) 观察者模式可以实现表示层和逻辑层的分离，定义了稳定的消息更新传递机制，抽象了更新接口，使得可以有各种各样不用的表示层充当具体观察者角色。

             2) 观察者模式在观察目标和观察者之间建立一个抽象的耦合。观察目标只需要维持一个抽象观察者集合，无需了解其具体观察者。由于观察目标和观察者没有紧密地耦合在一起，因此它们可以属于不同的抽象化层次。

             3) 观察者模式支持广播通信，观察目标会向所有已注册的观察者对象发送通知，简化了一对多系统设计的难度。        

             4) 观察者模式满足"开闭原则"的要求，增加新的具体观察者对象无须修改原有系统代码。在具体观察者和观察目标之间不存在关联关系的情况下，增加新的观察目标也很方便。

       2、观察者模式的主要缺点如下:

             1) 如果一个观察目标对象有很多直接和间接观察者，将所有的观察者都通知到会花费很多时间。

             2) 如果在观察者和观察目标之间存在循环依赖，观察目标会触发它们之间进行循环调用，可能导致系统崩溃。

             3) 观察者模式没有相应的机制让观察者知道所观察的目标对象是怎么发生变化的，而仅仅只是知道观察目标发生了变化。 

五、观察者模式的典型应用

        1、JDK提供的观察者接口

              观察者模式在Java语言中的地位非常重要。在JDK的java.util包中，提供了Observer类及Observer接口，它们构成了JDK对观察者模式的支持。

              其中的Observer接口为观察者，只有一个update方法。当观察者目标发生变化时被调用，其代码如下:

public interface Observer{
    void update(Observer o,Object arg);
}

               Observerable类则为目标类，相比示例中的Publisher类多了并发和NPE方面的考虑。

public class Observable {
    private boolean changed = false;
    private Vector<Observer> obs;

    /** Construct an Observable with zero Observers. */

    public Observable() {
        obs = new Vector<>();
    }

    /**
     * Adds an observer to the set of observers for this object, provided
     * that it is not the same as some observer already in the set.
     * The order in which notifications will be delivered to multiple
     * observers is not specified. See the class comment.
     *
     * @param   o   an observer to be added.
     * @throws NullPointerException   if the parameter o is null.
     */
    public synchronized void addObserver(Observer o) {
        if (o == null)
            throw new NullPointerException();
        if (!obs.contains(o)) {
            obs.addElement(o);
        }
    }

    /**
     * Deletes an observer from the set of observers of this object.
     * Passing <CODE>null</CODE> to this method will have no effect.
     * @param   o   the observer to be deleted.
     */
    public synchronized void deleteObserver(Observer o) {
        obs.removeElement(o);
    }

    /**
     * If this object has changed, as indicated by the
     * <code>hasChanged</code> method, then notify all of its observers
     * and then call the <code>clearChanged</code> method to
     * indicate that this object has no longer changed.
     * <p>
     * Each observer has its <code>update</code> method called with two
     * arguments: this observable object and <code>null</code>. In other
     * words, this method is equivalent to:
     * <blockquote><tt>
     * notifyObservers(null)</tt></blockquote>
     *
     * @see     java.util.Observable#clearChanged()
     * @see     java.util.Observable#hasChanged()
     * @see     java.util.Observer#update(java.util.Observable, java.lang.Object)
     */
    public void notifyObservers() {
        notifyObservers(null);
    }

    /**
     * If this object has changed, as indicated by the
     * <code>hasChanged</code> method, then notify all of its observers
     * and then call the <code>clearChanged</code> method to indicate
     * that this object has no longer changed.
     * <p>
     * Each observer has its <code>update</code> method called with two
     * arguments: this observable object and the <code>arg</code> argument.
     *
     * @param   arg   any object.
     * @see     java.util.Observable#clearChanged()
     * @see     java.util.Observable#hasChanged()
     * @see     java.util.Observer#update(java.util.Observable, java.lang.Object)
     */
    public void notifyObservers(Object arg) {
        /*
         * a temporary array buffer, used as a snapshot of the state of
         * current Observers.
         */
        Object[] arrLocal;

        synchronized (this) {
            /* We don't want the Observer doing callbacks into
             * arbitrary code while holding its own Monitor.
             * The code where we extract each Observable from
             * the Vector and store the state of the Observer
             * needs synchronization, but notifying observers
             * does not (should not).  The worst result of any
             * potential race-condition here is that:
             * 1) a newly-added Observer will miss a
             *   notification in progress
             * 2) a recently unregistered Observer will be
             *   wrongly notified when it doesn't care
             */
            if (!changed)
                return;
            arrLocal = obs.toArray();
            clearChanged();
        }

        for (int i = arrLocal.length-1; i>=0; i--)
            ((Observer)arrLocal[i]).update(this, arg);
    }

    /**
     * Clears the observer list so that this object no longer has any observers.
     */
    public synchronized void deleteObservers() {
        obs.removeAllElements();
    }

    /**
     * Marks this <tt>Observable</tt> object as having been changed; the
     * <tt>hasChanged</tt> method will now return <tt>true</tt>.
     */
    protected synchronized void setChanged() {
        changed = true;
    }

    /**
     * Indicates that this object has no longer changed, or that it has
     * already notified all of its observers of its most recent change,
     * so that the <tt>hasChanged</tt> method will now return <tt>false</tt>.
     * This method is called automatically by the
     * <code>notifyObservers</code> methods.
     *
     * @see     java.util.Observable#notifyObservers()
     * @see     java.util.Observable#notifyObservers(java.lang.Object)
     */
    protected synchronized void clearChanged() {
        changed = false;
    }

    /**
     * Tests if this object has changed.
     *
     * @return  <code>true</code> if and only if the <code>setChanged</code>
     *          method has been called more recently than the
     *          <code>clearChanged</code> method on this object;
     *          <code>false</code> otherwise.
     * @see     java.util.Observable#clearChanged()
     * @see     java.util.Observable#setChanged()
     */
    public synchronized boolean hasChanged() {
        return changed;
    }

    /**
     * Returns the number of observers of this <tt>Observable</tt> object.
     *
     * @return  the number of observers of this object.
     */
    public synchronized int countObservers() {
        return obs.size();
    }
}

              可以使用Observable类以及Observer接口来实现一个微信公众号示例。

              增加一个通知类WechatNotice,用于推送通知的传递。

public class WechatNotice {
    private String publisher;
    private String articleName;

    public WechatNotice(String publisher,String articleName){
        this.publisher = publisher;
        this.articleName = articleName;
    }

    public String getPublisher() {
        return publisher;
    }

    public void setPublisher(String publisher) {
        this.publisher = publisher;
    }

    public String getArticleName() {
        return articleName;
    }

    public void setArticleName(String articleName) {
        this.articleName = articleName;
    }
}

              然后改写 WeChatClient 和 WeChatAccounts，分别实现JDK的 Observer 接口和继承 Observable 类。

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

public class WeChatClient implements Observer {
    private String username;
    public WeChatClient(String username) {
        this.username = username;
    }

    public void update(Observable o, Object arg) {
        //WeChatAccounts weChatAccounts = (WeChatAccounts) o;
        WechatNotice notice = (WechatNotice) arg;
        System.out.println(String.format("用户<%s> 接收到 <%s>微信公众号 的推送，文章标题为 <%s>", username, notice.getPublisher(), notice.getArticleName()));

    }
}

import java.util.Observable;

public class WeChatAccounts extends Observable {
    private String name;

    public WeChatAccounts(String name) {
        this.name = name;
    }

    public void publishArticles(String articleName, String content) {
        System.out.println(String.format("\n<%s>微信公众号 发布了一篇推送，文章名称为 <%s>，内容为 <%s> ", this.name, articleName, content));
        setChanged();
        notifyObservers(new WechatNotice(this.getName(), articleName));
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

              测试:

public class TestMain {
    public static void main(String[] args){
        WeChatAccounts accounts = new WeChatAccounts("飞鹰");

        WeChatClient user1 = new WeChatClient("张三");
        WeChatClient user2 = new WeChatClient("李四");
        WeChatClient user3 = new WeChatClient("王五");

        accounts.addObserver(user1);
        accounts.addObserver(user2);
        accounts.addObserver(user3);

        accounts.publishArticles("设计模式 | Java设计模式之观察者模式及其应用场景", "观察者模式的内容...");

        accounts.deleteObserver(user1);
        accounts.publishArticles("设计模式 | Java设计模式之建筑者模式及其应用场景", "建筑者模式的内容....");
    }
}

              测试结果如下，可以发现结果如示例一致。

<飞鹰>微信公众号 发布了一篇推送，文章名称为 <设计模式 | Java设计模式之观察者模式及其应用场景>，内容为 <观察者模式的内容...> 
用户<王五> 接收到 <飞鹰>微信公众号 的推送，文章标题为 <设计模式 | Java设计模式之观察者模式及其应用场景>
用户<李四> 接收到 <飞鹰>微信公众号 的推送，文章标题为 <设计模式 | Java设计模式之观察者模式及其应用场景>
用户<张三> 接收到 <飞鹰>微信公众号 的推送，文章标题为 <设计模式 | Java设计模式之观察者模式及其应用场景>

<飞鹰>微信公众号 发布了一篇推送，文章名称为 <设计模式 | Java设计模式之建筑者模式及其应用场景>，内容为 <建筑者模式的内容....> 
用户<王五> 接收到 <飞鹰>微信公众号 的推送，文章标题为 <设计模式 | Java设计模式之建筑者模式及其应用场景>
用户<李四> 接收到 <飞鹰>微信公众号 的推送，文章标题为 <设计模式 | Java设计模式之建筑者模式及其应用场景>

        2、Spring ApplicationContext 事件机制中的观察者模式。

             spring的事件机制是从java的事件机制拓展而来，ApplicationContext 中事件处理是由 ApplicationEvent 类和 ApplicationListener 接口来提供的。如果一个Bean实现了 ApplicationListener 接口，并且已经发布到容器中去，每次 ApplicationContext 发布一个 ApplicationEvent 事件，这个Bean就会接到通知

             1) ApplicationContext：事件源，其中的 publishEvent()方法用于触发容器事件

             2) ApplicationEvent：事件本身，自定义事件需要继承该类，可以用来传递数据

             3) ApplicationListener：事件监听器接口，事件的业务逻辑封装在监听器里面

             使用 spring 事件机制重新实现示例

import org.springframework.context.ApplicationEvent;

public class WechatNotice extends ApplicationEvent {

    private String publisher;
    private String articleName;

    public WechatNotice(Object source, String publisher, String articleName) {
        super(source);
        this.publisher = publisher;
        this.articleName = articleName;
    }

    public String getPublisher() {
        return publisher;
    }

    public void setPublisher(String publisher) {
        this.publisher = publisher;
    }

    public String getArticleName() {
        return articleName;
    }

    public void setArticleName(String articleName) {
        this.articleName = articleName;
    }
}

import org.springframework.context.ApplicationEvent;
import org.springframework.context.ApplicationListener;

public class WeChatClient  implements ApplicationListener {

    private String username;

    public WeChatClient(String username) {
        this.username = username;
    }


    public void onApplicationEvent(ApplicationEvent event) {
        if (event instanceof WechatNotice) {
            WechatNotice notice = (WechatNotice) event;
            System.out.println(String.format("用户<%s> 接收到 <%s>微信公众号 的推送，文章标题为 <%s>", username, notice.getPublisher(), notice.getArticleName()));
        }
    }

    public void setUsername(String username) {
        this.username = username;
    }

}

import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;

public class WeChatAccounts  implements ApplicationContextAware {

    private ApplicationContext ctx;
    private String name;

    public WeChatAccounts(String name) {
        this.name = name;
    }

    public ApplicationContext getCtx() {
        return ctx;
    }

    public void setCtx(ApplicationContext ctx) {
        this.ctx = ctx;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.ctx = applicationContext;
    }

    public void publishArticles(String articleName, String content) {
        System.out.println(String.format("\n<%s>微信公众号 发布了一篇推送，文章名称为 <%s>，内容为 <%s> ", this.name, articleName, content));
        ctx.publishEvent(new WechatNotice(this.name, this.name, articleName));
    }
}

             在 resources 目录下创建 spring.xml 文件，填入下面的内容

<beans xmlns="http://www.springframework.org/schema/beans"
                xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
                xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="WeChatAccounts" class="com.jdk8.webchatListener.WeChatAccounts" scope="prototype">
         <constructor-arg name="name" value=""></constructor-arg>
    </bean>
    <bean id="WeChatClient1" class="com.jdk8.webchatListener.WeChatClient">
         <constructor-arg name="username" value="张三"></constructor-arg>
    </bean>
    <bean id="WeChatClient2" class="com.jdk8.webchatListener.WeChatClient">
         <constructor-arg name="username" value="李四"></constructor-arg>
    </bean>
    <bean id="WeChatClient3" class="com.jdk8.webchatListener.WeChatClient">
         <constructor-arg name="username" value="王五"></constructor-arg>
    </bean>
</beans>

              测试:

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestMain {
     public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");

        WeChatAccounts accounts = (WeChatAccounts) context.getBean("WeChatAccounts");
        accounts.setName("飞鹰");
        accounts.setApplicationContext(context);

        accounts.publishArticles("设计模式 | Java设计模式之建筑者模式及其应用场景", "观察者模式的内容...");
      }
}

             输出如下:

用户<张三> 接收到 <飞鹰>微信公众号 的推送，文章标题为 <设计模式 | Java设计模式之建筑者模式及其应用场景>
用户<李四> 接收到 <飞鹰>微信公众号 的推送，文章标题为 <设计模式 | Java设计模式之建筑者模式及其应用场景>
用户<王五> 接收到 <飞鹰>微信公众号 的推送，文章标题为 <设计模式 | Java设计模式之建筑者模式及其应用场景>

             在此示例中 ApplicationContext 对象的实际类型为 ClassPathXmlApplicationContext，其中的与 publishEvent 方法相关的主要代码如下：

private ApplicationEventMulticaster applicationEventMulticaster;

public void publishEvent(ApplicationEvent event) {
    this.getApplicationEventMulticaster().multicastEvent(event);
    if (this.parent != null) {
        this.parent.publishEvent(event);
    }
}

ApplicationEventMulticaster getApplicationEventMulticaster() throws IllegalStateException {
    return this.applicationEventMulticaster;
}

protected void initApplicationEventMulticaster() {
        ConfigurableListableBeanFactory beanFactory = this.getBeanFactory();
        if (beanFactory.containsLocalBean("applicationEventMulticaster")) {
            this.applicationEventMulticaster = (ApplicationEventMulticaster)beanFactory.getBean("applicationEventMulticaster", ApplicationEventMulticaster.class);
        } else {
            this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
            beanFactory.registerSingleton("applicationEventMulticaster", this.applicationEventMulticaster);
        }

    }

             其中的 SimpleApplicationEventMulticaster 如下，multicastEvent 方法主要是通过遍历 ApplicationListener（注册由 AbstractApplicationEventMulticaster 实现），使用线程池框架 Executor 来并发执行 ApplicationListener 的 onApplicationEvent 方法，与示例本质上是一致的

public class SimpleApplicationEventMulticaster extends AbstractApplicationEventMulticaster {
    private Executor taskExecutor;

    public void multicastEvent(final ApplicationEvent event) {
        Iterator var2 = this.getApplicationListeners(event).iterator();

        while(var2.hasNext()) {
            final ApplicationListener listener = (ApplicationListener)var2.next();
            Executor executor = this.getTaskExecutor();
            if (executor != null) {
                executor.execute(new Runnable() {
                    public void run() {
                        listener.onApplicationEvent(event);
                    }
                });
            } else {
                listener.onApplicationEvent(event);
            }
        }

    }
}

五、观察者模式不足

             尽管已经用了依赖倒转的原则，但是"抽象通知者"还是依赖"抽象观察者"，也就是说，万一没有了抽象观察者这样的接口，该通知的功能就完不成了。另外就是每个具体观察者，不一定都是"更新"的方法要调用的，需要实现的功能根本风马牛不相及的。要实现该功能，请关注下一节的"java委托功能的实现"。

 参考:

   1、http://laijianfeng.org/2018/10/%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F-%E8%A7%82%E5%AF%9F%E8%80%85%E6%A8%A1%E5%BC%8F%E5%8F%8A%E5%85%B8%E5%9E%8B%E5%BA%94%E7%94%A8/

   2、大话设计模式。