java高级---->Java观察者的原理

　　观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态上发生变化时，会通知所有观察者对象，让他们能够自动更新自己。今天我们通过模拟按钮的处理事件来深入Java观察者模式的学习。

目录导航

1. Java观察者的简要说明
2. Java的按钮点击案例
3. 使用Java中的Observer来模拟按钮监听事件机制
4. Java中的Observer原理的说明
5. 使用自定义的Observer来过滤按钮监听事件
6. 友情链接

Java观察者的简要说明

观察者模式所涉及的角色有：

　　●　抽象主题(Subject)角色：抽象主题角色把所有对观察者对象的引用保存在一个聚集（比如ArrayList对象）里，每个主题都可以有任何数量的观察者。抽象主题提供一个接口，可以增加和删除观察者对象，抽象主题角色又叫做抽象被观察者(Observable)角色。

　　●　具体主题(ConcreteSubject)角色：将有关状态存入具体观察者对象；在具体主题的内部状态改变时，给所有登记过的观察者发出通知。具体主题角色又叫做具体被观察者(Concrete Observable)角色。

　　●　抽象观察者(Observer)角色：为所有的具体观察者定义一个接口，在得到主题的通知时更新自己，这个接口叫做更新接口。

　　●　具体观察者(ConcreteObserver)角色：存储与主题的状态自恰的状态。具体观察者角色实现抽象观察者角色所要求的更新接口，以便使本身的状态与主题的状态 像协调。如果需要，具体观察者角色可以保持一个指向具体主题对象的引用。

Java的按钮点击案例

我们建立一个项目去开始今天的测试。项目结构如下：

aaarticlea/png;base64,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" alt="" />

demo很简单，点击button按钮，修改button上显示的文字

package com.huhx.frame;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JButton;
import javax.swing.JFrame;

/**
 * writer: huhx
 */
public class Jframe extends JFrame {
    private JButton button;

    public Jframe() {
        button = new JButton("text");
        add(button);
        setVisible(true);
        button.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                button.setText("world");
            }
        });
    }

    public static void main(String[] args) {
        new Jframe();
    }
}

使用Java中的Observer来模拟按钮监听事件机制

　　java中的内置观察者模式有两个类：一个是observable被观察者类，一个是observer观察者接口。大体上与自定义模式相同，我们编写程序时只需继承obervable类，具体实现observer接口就可以了。值得注意的是：调用notifyObservers()方法之前，必须先调用setChanged()方法。这是因为observable类中把 changed变量初始化为false,notifyObservers()方法会先检查该变量是否为true,如果不为ture，就不会调用 update()方法，这就要我们调用notifyObservers()之前，先用setChanged()方法将changed变量设置为true。

现在我们以上述例子为引子，使用Java中内置的Observer自己来模拟一个按钮监听事件的案例：

一、 创建一个继承obervable类的被观察者，在案例中也就是Button，类记为：MyButton

package com.huhx.observer;

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

/**
 * @author huhx
 */
public class MyButton extends Observable {
    public void addListeners(Observer observer) {
        addObserver(observer);
    }

    public void process(Object args) {
        setChanged();
        notifyObservers(args);
    }

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

二、 创建几个观察这个按钮的观察者，其实就是按钮的监听事件：

模拟点击事件：

package com.huhx.observer;

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

public class ClickObserver implements Observer {

    @Override
    public void update(Observable o, Object arg) {
        if (arg != null) {
            System.out.println("click: " + arg.toString());
        } else {
            System.out.println("click no arg");
        }
    }
}

模拟按下事件：

package com.huhx.observer;

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

public class PressObserver implements Observer {

    @Override
    public void update(Observable o, Object arg) {
        if (arg != null) {
            System.out.println("press: " + arg.toString());
        } else {
            System.out.println("press no arg");
        }
    }
}

三、 然后我们写一个测试的类，用于模拟按钮的事件：这里的process方法模拟真实按钮的触发事件，通知所有的观察者。比如我们按下按钮。

package com.huhx.observer;

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

public class PersonTest {

    public static void main(String[] args) {
        MyButton button = new MyButton();
        button.addObserver(new ClickObserver());

        button.addListeners(new Observer() {
            @Override
            public void update(Observable o, Object arg) {
                System.out.println("observer");
            }
        });
        button.process("huhx");
    }
}

五、 它的输出结果如下：

observer
click: huhx

Java中的Observer原理的说明

上述我们通过案例，来模拟了按钮的监听事件原理，现在我们通过源码来详细的分析它的运行过程：

一、 Observer是一个观察者可以实现的接口，它的文档说明如下：

A class can implement the Observer interface when it wants to be informed of changes in observable objects.

Observer中有一个update()方法：

void update(Observable o, Object arg); // Observable 是观察者  arg 是notifyObservers方法传入的参数

二、 Observable是一个被观察者继承的类，它的文档说明大致如下：

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. 

Observable有几个重要的方法，我们简单的介绍一下：

void addObserver(Observer o)            // 加入观察者到Vetor中
protected  void clearChanged()          // 设置change为false
int countObservers()                    // 返回Vetor中观察者的数量
void deleteObserver(Observer o)         // 从Vetor中删除指定的观察者
void deleteObservers()                  // 删除所有的观察者
void notifyObservers()                  // 通知Vetor中的观察者
void notifyObservers(Object arg)        // 通知Vetor中的观察者，带参数
boolean hasChanged()                    // 判断是否发生改变
protected  void setChanged()            // 设置changed为true

三、 接下来，我们结合上述的例子来分析Observer的原理：

当执行MyButton button = new MyButton()，由于MyButton是继承Observable，所以下述代码会执行。

private boolean changed = false;
private Vector obs;

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

当执行button.addObserver(new ClickObserver())，把参数中的Observer存放在上述初始化的Vetor中(为了适应多线程，用的是Vetor)

public synchronized void addObserver(Observer o) {
    if (o == null)
        throw new NullPointerException();
    if (!obs.contains(o)) {
        obs.addElement(o);
    }
}

当执行button.process("huhx")，如果被观察者发生了改变，就通知Vetor中的观察者去执行update方法。

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来过滤按钮监听事件

上述案例中，我们还无法做到对观察者的过滤通知，现在我们自己实现一个Observer，来对事件监听的事件过滤，更好的模拟按钮的事件机制。

一、 定义一个常量类，用于各种事件的标记：

package com.huhx.myobserver;

/**
 * huhx 陈慧
 */
public class Event {
    // 触发所有的Listener
    public static final int ALL = -1;
    // 触发内部定义的Listener
    public static final int DEFAULT = 0;
    public static final int CLICK = 1;
    public static final int PRESS = 2;
    public static final int DOWN = 3;
    public static final int FOCUE = 4;
}

二、 定义一个Listener接口，和Java内置的Observer作用类似，注意方法中的参数是MyObservable

package com.huhx.listener;

import com.huhx.myobserver.MyObservable;

public interface Listener {

    void actionPerformed(MyObservable o, Object arg);
}

三、 定义几个实现Listener的观察者，也就是事件：

模拟点击事件：

package com.huhx.listener;

import com.huhx.myobserver.MyObservable;

/**
 * 陈慧
 * @author Linux
 *
 */
public class ClickListener implements Listener {
    @Override
    public void actionPerformed(MyObservable o, Object arg) {
        if (arg != null) {
            System.out.println("click: " + arg);
        } else {
            System.out.println("click");
        }
    }
}

模拟按下事件：

package com.huhx.listener;

import com.huhx.myobserver.MyObservable;

public class PressListener implements Listener {

    @Override
    public void actionPerformed(MyObservable o, Object arg) {
        System.out.println("press");
    }
}

模拟定义在内部类中的事件：

package com.huhx.listener;

import com.huhx.myobserver.MyObservable;

public class DefaultListener implements Listener {

    @Override
    public void actionPerformed(MyObservable o, Object arg) {

    }
}

四、 定义一个类似于Observable类的自定义被观察者：

package com.huhx.myobserver;

import java.util.Vector;

import com.huhx.listener.ClickListener;
import com.huhx.listener.Listener;
import com.huhx.listener.PressListener;

/**
 *
 * @author huhx
 *
 */
public class MyObservable {
    private boolean changed = false;
    private Vector<Listener> obs;
    Object[] arrLocal;

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

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

    public void notifyObserverByEvent(int event, Object args) {
        synchronized (this) {
            if (!changed)
                return;
            arrLocal = obs.toArray();
            clearChanged();
        }
        notifyFixObserver(event, args);
    }

    private void notifyFixObserver(int event, Object args) {
        Listener listener = null;
        for (int i = arrLocal.length - 1; i >= 0; i--) {
            listener = (Listener) arrLocal[i];
            switch (event) {
            case Event.PRESS:
                if (listener instanceof PressListener)
                    ((PressListener) listener).actionPerformed(this, args);
                break;
            case Event.CLICK:
                if (listener instanceof ClickListener)
                    ((ClickListener) listener).actionPerformed(this, args);
                break;
            case Event.DEFAULT:
                if (listener instanceof Listener)
                    listener.actionPerformed(this, args);
                break;
            case Event.ALL:
                listener.actionPerformed(this, args);
                break;
            default:
                break;
            }
        }
    }

    public void notifyObserverByEvent(int event) {
        notifyObserverByEvent(event, null);
    }

    public void notifyObserverByEvent(Object args) {
        notifyObserverByEvent(Event.ALL, args);
    }

    public synchronized void addListener(Listener listener) {
        if (listener == null)
            throw new NullPointerException();
        if (!obs.contains(listener)) {
            obs.addElement(listener);
        }
    }

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

五、 为了简化Button的使用，我们仿造Java中的做法，先创建一个AbstractButton，用于处理共公的代码：

package com.huhx.myobserver;

import com.huhx.listener.Listener;

public class AbstractButton extends MyObservable {
    public void addListeners(Listener listener) {
        addListener(listener);
    }

    public void process(int source, Object args) {
        setChanged();
        switch (source) {
        case Event.CLICK:
            notifyObserverByEvent(Event.CLICK, args);
            break;
        case Event.PRESS:
            notifyObserverByEvent(Event.PRESS, args);
            break;
        case Event.DEFAULT:
            notifyObserverByEvent(Event.DEFAULT, args);
            break;
        case Event.ALL:
            notifyObserverByEvent(Event.ALL, args);
        default:
            break;
        }
    }

    public void process(int source) {
        process(source, null);
    }
}

六、 创建一个被观察者，也就是我们的按钮Button

package com.huhx.myobserver;

/**
 *
 * @author Linux
 *
 */

public class MyButtton extends AbstractButton {

}

七、 在测试中使用：

package com.huhx.myobserver;

import com.huhx.listener.ClickListener;
import com.huhx.listener.Listener;

public class PersonTest {
    public static void main(String[] args) {
        MyButtton buttton = new MyButtton();
        buttton.addListener(new Listener() {
            @Override
            public void actionPerformed(MyObservable observable, Object object) {
                System.out.println("listener");
                System.out.println(observable + ", object: " + object.toString());
            }
        });

        buttton.addListener(new ClickListener());
        buttton.process(Event.CLICK);
//        buttton.process(Event.DEFAULT, "world");
    }
}

它的输出结果如下：

click: 陈慧

观察者模式的应用

一、观察者模式的优点

• 观察者和被观察者之间是抽象耦合

　　如此设计，则不管是增加观察者还是被观察者都非常容易扩展，而且在Java中都已经实现的抽象层级的定义，在系统扩展方面更是得心应手。

• 建立一套触发机制

　　根据单一职责原则，每个类的职责是单一的，那么怎么把各个单一的职责串联成真实世界的复杂的逻辑关系呢？比如，我们去打猎，打死了一只母鹿，母鹿有三个幼崽，因失去了母鹿而饿死，尸体又被两只秃鹰争抢，因分配不均，秃鹰开始斗殴，然后羸弱的秃鹰死掉，生存下来的秃鹰，则因此扩大了地盘……这就是一个触发机制，形成了一个触发链。观察者模式可以完美地实现这里的链条形式。

二、观察者模式的缺点

　　观察者模式需要考虑一下开发效率和运行效率问题，一个被观察者，多个观察者，开发和调试就会比较复杂，而且在Java中消息的通知默认是顺序执行，一个观察者卡壳，会影响整体的执行效率。在这种情况下，一般考虑采用异步的方式。

　　多级触发时的效率更是让人担忧，大家在设计时注意考虑。

三、观察者模式的使用场景

• 关联行为场景。需要注意的是，关联行为是可拆分的，而不是“组合”关系。
• 事件多级触发场景。
• 跨系统的消息交换场景，如消息队列的处理机制。

友情链接