行为型之观察者模式

观察者模式

Observer

行为模式之一

当一个对象状态发生变化时，能够自动通知其他关联对象，自动刷新对象状态

Observer模式提供给关联对象一种同步通信的手段，使某个对象与依赖他的其他对象之间保持状态同步

在Java中想要一个类成为被观察者，需要去继承Observable，

即被观察者是继承Observable的任何对象

观察者是实现Observer接口的任何对象

Java提供了较为方便的Observer和Observable供我们去实现观察者模式，

其实它本质还是基于容器的实现，即当一个对象是被观察者时，当其注册观察者对象时，会将观察者放进容器中，每个观察者都有着各自的update方法，当被观察手动改变状态时（setChanged()），然后再去调用唤醒观察者方法（notifyObservers()）时，其本质上还是遍历容器里注册的观察者，依个调用其update方法而已

源码分析

public class Observable {
    private boolean changed = false;
    private Vector<Observer> obs; //维护观察者的一个容器

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

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

        public synchronized void addObserver(Observer o) {
        if (o == null)
            throw new NullPointerException();
        if (!obs.contains(o)) {
            obs.addElement(o); //在容器中去注册观察者对象
        }
    }

        public void notifyObservers() {
        notifyObservers(null); //调用有参的notifyObervers
    }

      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--) //依次遍历容器中观察者，调用其update方法
            ((Observer)arrLocal[i]).update(this, arg);
    }

      protected synchronized void setChanged() {
        changed = true;
    }

      protected synchronized void clearChanged() {
        changed = false;
    }

     public synchronized boolean hasChanged() {
        return changed;
    }
//源码其实讲的就听明白的不是吗？QAQ

代码实现 发布者 / 订阅者模式

public class Blogger extends Observable {
    void addBlog(Article article){
        System.out.println("博主更新了博客");
        this.setChanged();
        this.notifyObservers(article);
    }
}

public class Article {
    public String getArticleTitle() {
        return articleTitle;
    }

    public void setArticleTitle(String articleTitle) {
        this.articleTitle = articleTitle;
    }

    public String getArticleContent() {
        return articleContent;
    }

    public void setArticleContent(String articleContent) {
        this.articleContent = articleContent;
    }

    public Article(String articleTitle, String articleContent) {
        this.articleTitle = articleTitle;
        this.articleContent = articleContent;
    }

    String articleTitle;
    String articleContent;
}

public class Reader implements Observer {
    @Override
    public void update(Observable o, Object arg) {
        System.out.println("您关注的博主博客更新啦");
        Article article = (Article) arg;
        System.out.println("博客标题：" + article.getArticleTitle());
        System.out.println("博客内容：" + article.getArticleContent());
    }
}

public class MainClass {
    public static void main(String[] args) {
        Blogger blogger = new Blogger();
        blogger.addObserver(new Reader());
        blogger.addBlog(new Article("这是我的第一篇博客", "你若不弃，我便不离"));
    }
}

我们知道，当一个系统划分为一系列相互合作的类时，是有一定的缺点的，我们需要维护这些类之间的某种状态联系，这也就意味着这些类实际上是高耦、扩展性差且难以改变的，这时我们就需要脱耦，让这些类之间依赖关系能直接或间接的减少些，这时观察者模式便发挥作用了.

应用场景

• 侦听事件驱动程序设计中的外部事件
• 侦听/监视某个对象的状态改变
• 发布者 / 订阅者 （publisher/subscriber)模型