从零开始理解JAVA事件处理机制

“事件”这个词已经被滥用了。正因为“事件”的被滥用，很多人在用到事件的时候不求甚解，依样画葫芦，导致学习工作了很多年，还是不清楚什么是事件处理器、什么是事件持有者。所以，如果你对于Event这个词还是心存恐惧，那么本文正是你需要的。让我们从易到难，从具体到抽象，一步一步来解释java事件处理机制。

一：观察者模式

要了解事件和监听，我们首先来必须要了解观察者模式。

什么是观察者模式，我们先来看一个熟悉的场景：

1：教师布置作业，通知学生；

2：学生观察到老师布置了作业，开始做作业；

首先我明确下，我历来是十分反对以阿猫阿狗、老师学生这样的场景来阐述代码问题的，所以该主题的最后肯定会回到实际代码中来。言归正传，在这个场景中，学生就是观察者，教师就是被观察者，但是大家一定要注意：

教师作为被观察者，实际上是掌握着主动的，且看上文中我加粗的“通知”二字，因为这貌似看上去简简单单的通知，事实上却要做很多事情（写很多代码）。

好了，我们先来实现上面的场景：

代码：

观察者，学生

package com.zuikc.events;

import java.util.Observable;

public class Student implements java.util.Observer {

private String name;
public Student(String name){
this.name = name;
}
@Override
public void update(Observable o, Object arg) {
Teacher teacher = (Teacher) o;
System.out.printf("学生%s观察到（实际是被通知）%s布置了作业《%s》 \n", this.name, teacher.getName(), arg);
}

}

被观察者，教师

package com.zuikc.events;

import java.util.*;

public class Teacher extends java.util.Observable {

private String name;
private List<String> homeworks;

public String getName() {
return this.name;
}

public Teacher(String name) {
this.name = name;
homeworks = new ArrayList<String>();
}

public void setHomework(String homework) {
System.out.printf("%s布置了作业%s \n", this.name, homework);
homeworks.add(homework);
setChanged();
notifyObservers(homework);

}
}

客户端：

package com.zuikc.events;

public class Client {

public static void main(String[] args) {
Student student1= new Student("张三");
Student student2 = new Student("李四");
Teacher teacher1 = new Teacher("zuikc");
teacher1.addObserver(student1);
teacher1.addObserver(student2);
teacher1.setHomework("事件机制第一天作业");
}

}

很多初学者有个错觉，考虑“观察”这个动作是主动的，所以就认为在代码实现上，Reader是主动调用自己的update，但是很遗憾，当然不是，在代码实现上，update是“被观察者”Teacher主动调用的。有人说，我只在Teacher中看到了

setChanged();
notifyObservers(homework);

没有看到它调用update呀，那么请查看它的父类Observable，在notifyObservers方法中有，

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

看看结果吧：

注意，以上代码中，我直接使用了java.util包中的类Observable和接口Observer，我们当然也可以自己写这两个东东。

二：基础版观察者模式

初学者对于一上来就使用java.util中的api不习惯，可能觉得看不到摸不着，那我们就自己来写一个基础版的观察者模式，大家感受下，在写的过程中，一定要对照上节中的UML图和代码，然后心中默念：它们没有区别，它们没有区别！

上图：

上代码：

观察者，接口

package com.zuikc;

public interface Observer {

void update(Observable o);
}

具体观察者，我写了两个：

class ConcreteObserver1 implements Observer {

public void update(Observable o) {
System.out.println("观察者1观察到" + o.getClass().getSimpleName() + "发生变化");
System.out.println("观察者1做出响应");
}
}

class ConcreteObserver2 implements Observer {

public void update(Observable o) {
System.out.println("观察者2观察到" + o.getClass().getSimpleName() + "发生变化");
System.out.println("观察者2做出响应");
}
}

观察者

package com.zuikc;

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

public class Observable {

List<Observer> observers = new ArrayList<Observer>();

public void addObserver(Observer o) {
observers.add(o);
}

public void doSomething() {
System.out.println("我是被观察者，我发生变化了");
// 主动去通知所有的观察者
notifyObservers();
}

public void notifyObservers() {
for (Observer observer : observers) {
observer.update(this);
}
}
}

客户端：

package com.zuikc;

public class Client {

public static void main(String[] args) {
Observable observable = new Observable();
observable.addObserver(new ConcreteObserver1());
observable.addObserver(new ConcreteObserver2());
observable.doSomething();
}

}

大家可以自己运行下代码，看看发生了什么。

在上面代码中，我们自己了一个接口，一个被观察者类，虽然简单了一点，但是却达到了演示的效果。当然，我们也可以原封不动的把JDK中的源码拷贝出来作为我们这两个文件的代码。

如果对于上面的代码已经相当之熟悉，你还可以研究下update方法，在第一小节中我们是带了arg参数的，但是这个基础版本中没带。无所谓，你想带就带，不想带就不想带，代码即*，只要你实现了功能。

三：观察者模式的用意

基础版的观察者模式毕竟太简单，在我们第一节中的代码中，我们可以总结出：

1：教师类和学生类无关，他只依赖观察者接口，如果有一天，他的作业不仅仅布置给学生，作为优秀讲师，还要发送给全校的老师作为参考，那么只要老师这个类也实现观察者接口，我们同样可以将老师添加到这个教师的观察者列表中；

2：观察者模式分离了观察者和被观察者自身的责任，让类各自维护自己的功能，提高了系统的可重用性；

3：观察看上去是一个主动的行为，但是其实观察者不是主动调用自己的业务代码的，相反，是被观察者调用的。所以，观察者模式还有另一个名字，叫发布-订阅模式，我认为，后者更贴切；

观察者模式还有另外一种形态，就是事件驱动模型，这两种方式在实现机制上是非常接近的，在理解了观察者模式的基础上，理解事件驱动，就非常简单了。

以上就是从零开始理解JAVA事件处理机制的详细内容，更多请关注其它相关文章！