java中的观察者模式

java在util包中给我们提供了默认了观察者模式的类和接口。观察者可以实现Observer接口,被观察者则是使用Observable这个类来实现。首先我们来看看Observer接口和Observable类的基本使用。

首先，我们需要定义我们的观察者实现Observer这个接口。

package com.app.motion;
import java.util.Observable;
import java.util.Observer;

public class CustomObserver implements Observer {

private String name;

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

@Override
public void update(Observable arg0, Object arg1) {
    if (arg1 instanceof String) {
        System.out.println(name + "say:" + arg1);
    }
}

}

接着我们定义一个Obserable的继承类。

package com.app.motion;

import java.util.Observable;

public class CustomObservable extends Observable{

@Override
protected synchronized void setChanged() {
    super.setChanged();
}

}

客户端调用

package com.app.motion; 
public class Client {   
public static void main(String[] args) {
    CustomObservable content = new CustomObservable();
    content.addObserver(new CustomObserver("zhangsan"));
    content.addObserver(new CustomObserver("lisi"));
    content.addObserver(new CustomObserver("wangwu"));
    content.setChanged();
    content.notifyObservers("update");
}
}

最后调用结果为：

wangwusay:update
lisisay:update
zhangsansay:update

使用非常简单，那么我们接下来看看源码是怎么实现。首先来说说Observer接口,这个接口的定义非常简单,只有一个update方法。

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

这个方法是在Observable调用notifyObservers（）方法中调用的，Observable参数代表了我们添加的被观察者，object参数代表了被观测者传递给观察者的信息.

接下来在看看Observable类

public class Observable {
    private boolean changed = false;
    private Vector 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();
    }
}

Observerable这个类也比较简单，在构造方法中，新建一个Vector集合用来管理所有的Observer接口，每一次调用addObserver()方法都是把observer对象加入到vector的集合中。但某个时间需要通知所有的观察者的时候调用notifyObservers（）方法，这样就可以调用每个观察者的update方法了。这里有个要注意的地方，在调用update之前，需要调用一下setChanged（）方法，这个方法是一个protected方法，所以也需要继承Observable类。