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

观察者模式定义：

      它是对象的行为模式，它有叫做发布/订阅模式(redis中有这样的概念)，模型/视图模式，源/监听器模式或从属模式。它定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象，当这个主题发生改变时，会通知所有他的观察者对象，使之跟随改变更新。

      为什么会有这种设计模式呢？在一个软件生态中，对象之间依赖当一个改变时会有相应的其它对象发生改变。能完成这个问题的方案有很多，但是为了使系统能够易于复用，应选择耦合度较低的方案，减少对象之间的耦合有利于系统的复用，但是同时也应该使这些低耦合对象之间维持行动协调一致，保证高度协作。所以观察者设计模式就出现了。

   它的类图如下图所示：

从类图中可观察到一下几个概念：

       Subject（抽象主题）角色：首先它是一个interface，它维护的一个集合保存所有的观察者，并且提供增加和删除观察者对象和通知所有观察者对象的方法。一般他有被称为Observable(自jdk.1.0 本身库中包含这个类后面会说到)角色，一般用接口或抽象类来表示。

       Observer（抽象观察者）角色：为所有具体观察者定义一个接口，在得到一个主题时通知更新自己，也叫作更新接口。他通常使用接口或抽象类实现。可看到它通常只包含一个方法（update()）.

       ConcreteSubject（具体主题）角色：将有关状态存入具体观察者对象，在具体主题发生改变是，给所有登记过的具体观察者发送通知。

      ConcreteObserver（具体观察者）角色：存储与主题状态相关的自状态。

简单实现，代码如下：

   Subject接口：

 

package com.obserable;
public interface Subject {
      void addObserver(Observer observer);
      void delObserver(Observer observer);
      void notifyall();
}

SubjectImpl实现类：

package com.obserable;

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

public class SubjectImpl implements Subject {
      private List<Observer> list = new ArrayList<Observer>();
    @Override
    public void addObserver(Observer observer) {
        // TODO Auto-generated method stub
     list.add(observer);
    }

    @Override
    public void delObserver(Observer observer) {
        // TODO Auto-generated method stub
  list.remove(observer);
    }

    @Override
    public void notifyall() {
        Iterator<Observer> iter = list.iterator();
        while(iter.hasNext()){
            iter.next().update();
        }
    }

}

Observer接口：

package com.obserable;

public interface Observer {
    void update();
}

ObserverImpl实现类：

package com.obserable;

public class ObserverImpl implements Observer{
     private String name;
     
    public ObserverImpl(String name) {
        super();
        this.name = name;
    }

    @Override
    public void update() {
        System.out.println(name+"I am notify");
    }

}

测试类：

package com.obserable;

public class Test {
    public static void main(String[] args) {
        Subject sub = new SubjectImpl();
        sub.addObserver(new ObserverImpl("王五"));
        sub.addObserver(new ObserverImpl("王五1"));
        sub.addObserver(new ObserverImpl("王五2"));
        sub.notifyall();
    }


}

结果：

王五I am notify
王五1I am notify
王五2I am notify

还可以使用抽象类来实现Subject，Observer不变；

package com.obserable;

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

public abstract class AbstractSubjct {

    private List<Observer> list = new ArrayList<Observer>();
    public void addObserver(Observer observer) {
   list.add(observer);
    }

    public void delObserver(Observer observer) {
        // TODO Auto-generated method stub
list.remove(observer);
    }
    public void notifyall() {
        Iterator<Observer> iter = list.iterator();
        while(iter.hasNext()){
            iter.next().update();
        }
    }


}

抽象类的实现类：

package com.obserable;

public class JtSubject extends AbstractSubjct{
  private String state;
  
  public void change(String state){
      this.state=state;
      notifyall();
  }
}

Observer不变。

测试类：

package com.obserable;

public class AbsTest {
     public static void main(String[] args) {
         JtSubject as = new JtSubject();
        as.addObserver(new ObserverImpl("王五"));
        as.addObserver(new ObserverImpl("王五1"));
        as.addObserver(new ObserverImpl("王五2"));
        as.change("hello");
    }
}

结果：

王五I am notify
王五1I am notify
王五2I am notify

因为此模式在实际应用中广泛，所以自jdk1.0就纳入的本身库。

Observer接口，等同于上述的Observer，只有一个update方法。

 * Copyright (c) 1994, 1998, Oracle and/or its affiliates. All rights reserved.
package java.util;

/**
 * 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);
}

再看jdk中Observable类,他是一个可实例化类。

 * Copyright (c) 1994, 2012, Oracle and/or its affiliates. All rights reserved.

package java.util;
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 synchronized void deleteObserver(Observer o) {
        obs.removeElement(o);
    }

  
    public void notifyObservers() {
        notifyObservers(null);
    }

 
    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);
    }

   
    public synchronized void deleteObservers() {
        obs.removeAllElements();
    }

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

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

    public synchronized boolean hasChanged() {
        return changed;
    }

    public synchronized int countObservers() {
        return obs.size();
    }
}

可以看到它是线程安全的，方法是有synchronizednchronized修饰的，而且维护的Observer集合使用的Vector。

使用方法和上述一样。