关闭

通过Java源码分析初探观察者模式(一)

标签: androidjava源码观察者模式
6232人阅读 评论(3) 收藏 举报
分类:

对于观察者,很多开发者并不陌生,在日常开发过程中,这也是一个非常常见的设计模式,尤其是Android小伙伴,很多人都知道broadcast就是一个典型的观察者模式,还有最近很火的rxjava,响应式编程中,观察者模式扮演着一个很重要的角色,但观察者模式具体是怎么样运转的,部分小伙伴就有点模糊了。

先从日常生活中一个例子开始说起,在看电视的过程中,我们经常看到一些抗日神剧中有这么一个剧情,鬼子进村,在进村的过程中,总会有一些一些人通风报信,然后通知村里的人能躲的躲,能藏的藏,能跑的跑,或者中路再搞个埋伏,抓到了以后是手撕还是其它方式处理,在此就先不做讨论。。。其实这个过程中就是一个典型的观察者模式,下面,我们先看一下手撕鬼子的UML。

这里写图片描述

DevilsSubject.java

/**
 * 
 * created by zm on 2016-5-28
 * 继承Observable,此类等同于上述UML的Devil(小鬼子),其它对号入座
 * 观察鬼子是否来袭击 
 *
 */
public class DevilsSubject extends Observable
{
    private String assault;

    public String isAssault() {
        return assault;
    }

    public void setAssault(String assault) {
        this.assault = assault;
        //可通过this.hasChanged()获取是否发生改变,这里我们统一设置成改变,以便测试
        this.setChanged();
        this.notifyObservers(assault);
    }
}

VillagerObserver.java

/**
 * 
 * created by zm on 2016-5-28
 * 
 * VillagerObserver(放哨的村民),观察小鬼子行动
 *
 */
public class VillagerObserver implements Observer
{

    public void update(Observable o, Object obj) {
        // TODO Auto-generated method stub
        String assault = (String) obj;
        System.out.println(assault);
    }
}

Client.java

public class Client
{
    public static void main(String[] args) {
        VillagerObserver yes = new VillagerObserver();
        VillagerObserver no = new VillagerObserver();
        DevilsSubject devilsSubject = new DevilsSubject();
        //如果观察者与集合中已有的观察者不同,则向对象的观察者集中添加此观察者。
        devilsSubject.addObserver(yes);
        devilsSubject.addObserver(no);
        devilsSubject.setAssault("前方有一坨鬼子来了");
        devilsSubject.setAssault("鬼子见阎王了,在来村的路上就被村民手撕了");
        //返回 Observable 对象的观察者数目
        System.out.println(devilsSubject.countObservers());
        System.out.println("................");
        devilsSubject.deleteObserver(yes);
        devilsSubject.setAssault("鬼子来了");
        System.out.println(devilsSubject.countObservers());
    }
}

运行的结果:

前方有一坨鬼子来了
前方有一坨鬼子来了
鬼子见阎王了,在来村的路上就被村民手撕了
鬼子见阎王了,在来村的路上就被村民手撕了
Observable对象的观察者数目:2................
鬼子来了
Observable对象的观察者数目:1

下面是observable源码

package java.util;

/**
 * This class represents an observable object, or "data"
 * in the model-view paradigm. It can be subclassed to represent an
 * object that the application wants to have observed.
 * <p>
 * An observable object can have one or more observers. An observer
 * may be any object that implements interface <tt>Observer</tt>. After an
 * observable instance changes, an application calling the
 * <code>Observable</code>'s <code>notifyObservers</code> method
 * causes all of its observers to be notified of the change by a call
 * to their <code>update</code> method.
 * <p>
 * The order in which notifications will be delivered is unspecified.
 * The default implementation provided in the Observable class will
 * notify Observers in the order in which they registered interest, but
 * subclasses may change this order, use no guaranteed order, deliver
 * notifications on separate threads, or may guarantee that their
 * subclass follows this order, as they choose.
 * <p>
 * Note that this notification mechanism has nothing to do with threads
 * and is completely separate from the <tt>wait</tt> and <tt>notify</tt>
 * mechanism of class <tt>Object</tt>.
 * <p>
 * When an observable object is newly created, its set of observers is
 * empty. Two observers are considered the same if and only if the
 * <tt>equals</tt> method returns true for them.
 *
 * @author  Chris Warth
 * @see     java.util.Observable#notifyObservers()
 * @see     java.util.Observable#notifyObservers(java.lang.Object)
 * @see     java.util.Observer
 * @see     java.util.Observer#update(java.util.Observable, java.lang.Object)
 * @since   JDK1.0
 */
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的api
这里写图片描述

根据源码中最上部分的注释,翻译成中文后,大体的意思是此类是一个被观察者。它可以派生子类来表示一个应用程序想要观察的对象。一个可观察到的对象(observable)可以有一个或多个观察者(observer)。一个观察者可以是任何实现接口的观察者的对象。修改后可观察到的实例,应用程序调用notifyObservers方法使所有的观察者调用更新方法。通知的顺序将是未指定的。请注意,这与线程通知机制无关,完全独立于类对象的等待和通知机制。当一个可观察的对象是新创建的,它的观察是空的。当且仅当这个方法返回true,两个观察者是同步的。

源码中,起关键性作用的就是vector和changed,在observable实例化的时候,就初始化了一个空的vector,可以通过vector添加和移除vector操作后,当observable发生改变时,通过changed去判断是否通知,在我们的上述示例代码中使用setChanged(),主要是因为第一次加入的时候,不会去调用observer的update方法,也就是changed为false,当changed为false时,直接从notifyObservers方法中return,只有changed为true的时候才通知刷新,刷新之前,重新把changed赋值为false,提取上述源码中的关键代码如下:

public void notifyObservers(Object arg) {
        Object[] arrLocal;
        synchronized (this) {
            if (!changed)
                return;
            arrLocal = obs.toArray();
            clearChanged();
        }

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

observer类

/**
 * A class can implement the <code>Observer</code> interface when it
 * wants to be informed of changes in observable objects.
 *
 * @author  Chris Warth
 * @see     java.util.Observable
 * @since   JDK1.0
 */
public interface Observer {
    /**
     * This method is called whenever the observed object is changed. An
     * application calls an <tt>Observable</tt> object's
     * <code>notifyObservers</code> method to have all the object's
     * observers notified of the change.
     *
     * @param   o     the observable object.
     * @param   arg   an argument passed to the <code>notifyObservers</code>
     *                 method.
     */
    void update(Observable o, Object arg);
}

observer就是一个接口,里面一个update方法,这个类没太多需要解释的,有点Java基础的都可以明白。

现在一目了然了,Observer模式是一种行为模式,它的作用是当一个对象的状态发生改变的时候,能够自动通知其他关联对象,自动刷新对象状态。Observer模式提供给关联对象一种同步通信的手段,使其某个对象与依赖它的其他对象之间保持状态同步。

抽象主题角色(Subject)内部其实就是一个Vector,在addObserver的时候,就把需要的观察者添加到Vector中。在deleteObserver的时候,就把传进来的观察者从容器中移除掉。主题角色又叫抽象被观察者角色(observable),一般用一个抽象类或者接口来实现。

observable与observer是一种一对多的依赖关系,可以让多个观察者对象同时监听某一个主题对象。观察者模式有时被称作发布/订阅模式(Publish/Subscribe),对于这名称很贴切的,就好比我们订阅了报纸,每次报社新报纸出版发售的时候,就会根据订阅的客户一一发报纸,通知客户阅读。

ConcreteSubject:具体主题角色,将相关状态存入具体观察者对象。具体主题角色又叫具体被观察者角色(ConcreteObservable)。

ConcreteObserver:具体观察者角色,实现抽象观察者角色(observer)所需要的更新接口,以便使自己状态和主题状态相协调。

这里写图片描述

总结:通过依赖抽象而不是依赖具体类,去实现一个类中某个状态的改变,而通知相关的一些类去做出相应的改变,进而保持同步状态。实现这样的方式或许有很多种,但是为了使系统能够易于复用,应该选择第耦合度的方案。减少对象之间的耦合度有利于系统的复用,在保证低耦合度的前提下并且能够维持行动的协调一致,保证高度协作,观察者模式是一种很好的设计方案。

1
0
查看评论

观察者模式(python版)

观察者模式:又叫发布-订阅模式。     它定义了一种一对多的依赖关系,让多个观察者对象同时鉴定某一个主题对象。这个主题对象在状态发生变化时,会通知所有的观察者对象,使它们能够自动更新自己。 观察者模式所做的工作实际上就是解耦,根据“依赖倒转原则”,让耦合的双方都依...
  • ponder008
  • ponder008
  • 2011-10-17 11:03
  • 3571

Java源码分析——String的设计

Tip:笔者马上毕业了,准备开始Java的进阶学习计划。于是打算先从String类的源码分析入手,作为后面学习的案例。这篇文章寄托着今后进阶系列产出的愿望,希望能坚持下去,不忘初心,让自己保持那份对技术的热爱。 因为学习分析源码,所以借鉴了HollisChuang成神之路的大部分内容,并在此基础上对...
  • u012963909
  • u012963909
  • 2016-04-20 21:49
  • 1347

事件分发之扫描自定义注解实现观察者模式注册

一点机缘巧合,花了一个小时写了一版用反射方案去注册和释放的观察者设计模式,用于事件统一处理,权当记忆一下吧 1、控制中心类 package org.iamwsbear.scannerobserver; import java.lang.annotation.Annotation; impor...
  • iamws
  • iamws
  • 2016-10-28 22:42
  • 897

C++11 并发指南系列(C++11 多线程初探)

C++11 并发指南一(C++11 多线程初探) 引言 C++11 自2011年发布以来已经快两年了,之前一直没怎么关注,直到最近几个月才看了一些 C++11 的新特性,今后几篇博客我都会写一些关于 C++11 的特性,算是记录一下自己学到的东西吧,和大家共勉。 相信 Linux 程序员都用...
  • chenjh213
  • chenjh213
  • 2014-12-27 18:45
  • 609

java源码分析

arrayBlockQueue生成(插入元素)在往队列中插入数据由下面几个函数,他们的区别就是对队列满的情况处理不同 - put 一直等待着 - offer(无时间) 如果空了直接返回false - offer(有时间) 等待指定的时间,在指定时间内如果空了,那么插入,负责返回false -...
  • benbendy1984
  • benbendy1984
  • 2017-02-24 21:30
  • 419

浅谈为什么设计模式要有观察者模式--观察者模式的意义

设计模式可以说是一种代码规范,也可以说是一种前人总结的奇技淫巧,对于后来编程者,学习设计模式可以对编程思路有一些启发,其中也包括经验启发. php相对java形式比较随意,所以对于模式设计更需要多花时间研究.下面通俗地说说观察者模式使用场景和意义: 先不提定义,我们先思考一个实例,当博客更新文章时,...
  • h330531987
  • h330531987
  • 2017-09-03 14:23
  • 386

一个用观察者模式解决实际问题的例子

前几天组里接到一个以前开发的已上线项目的维护任务,要求把其中的一些数据定时通过webservice接口上传到当地某市某平台上面,基本上算是个体力活儿了。 时间仓促只好加班加点,搜集比对 -->拼写SQL-->调试接口-->测试上传。。。 正要把十几个接口搞定的时候,突然接到新要...
  • u012763117
  • u012763117
  • 2014-03-09 02:31
  • 1486

iOS开发之观察者模式初探

在软件开发中,无论是那种高级语言中总会伴随着一些最为常用的设计模式,即便就如iOS开发中与我们打交道最多的无非就是单例模式、观察者模式和工厂模式了,当然了其他的设置模式也同样存在在编程的很多地方。下面就就让我们简单的了解下观察者模式吧! 观察者模式本质上时一种发布-订阅模型,用以消除具有不同行为的...
  • yishengzhiai005
  • yishengzhiai005
  • 2016-06-22 17:23
  • 184

设计模式初探之观察者模式

 在大多数情况下,业务逻辑层执行完表示层的命令后需要向表示层反馈信息。在我之前的《使用接口封装变化》提到的网络用户管理模块中便是使用观察者模式的一个恰当之处,类功能如下图所示。http://blog.csdn.net/kecp/archive/2009/09/29/4613618.aspx...
  • kecp
  • kecp
  • 2009-10-09 22:18
  • 522

观察者模式(看完马士兵视频的总结)

例子就是一个小孩在睡觉,当小孩醒过来之后,爸爸要喂奶,爷爷要
  • oWuGuanFengYue123
  • oWuGuanFengYue123
  • 2014-05-06 11:45
  • 1617
    个人资料
    • 访问:264019次
    • 积分:2999
    • 等级:
    • 排名:第13879名
    • 原创:46篇
    • 转载:0篇
    • 译文:0篇
    • 评论:329条
    QQ交流群

    Android路上

    611566797
    博客专栏
    我的公众号