AWT事件处理机制

任何支持GUI的操作系统都要不断的监视敲击键盘或点击鼠标这样的事件。操作系统将这些事件报告给正在运行的应用程序。那么如果这个程序是用Java写的，那么Java是如何做出反应的呢？

我们都知道Swing的出现使得Java图形用户界面开始真正有意义起来。但这并不代表AWT过时了，没用了。恰恰相反，Swing仅仅提供了强大的，可移植的，高效的用户界面组件（比如JButton），但要实现相应用户动作的业务逻辑，还需要使用基本的A WT事件处理机制 。

AWT的事件处理机制，实际上是一种委托模型 。比如按钮，当我们发出点击按钮的动作之后，真正响应事件的业务逻辑并非按钮本身，而是由按钮委托的相应监听器来完成的。在深入探讨这个过程之前，我们先看看三个比较重要的概念：

(1) 事件(event)
    我们都知道，点击鼠标的动作会产生一个事件。像Java这样面向对象的语言，会将事件的相关信息封装在一个事件对象中，这就是ActionEvent类。
    实际上，ActionEvent类不光是点击按钮，如果其它组件发生了与组件定义的动作相关的语义事件时，也会产生ActionEvent对象，比如时钟Timer类发生定时性动作时。
    另外还有很多其他的事件类，如组件被移动、大小被更改或可见性被更改的事件——ComponentEvent等。
    这些事件类都继承了java.awt.AWTEvent,而这个类又直接继承java.util.EventObject。

(2) 事件源(event source)
    顾名思义，就是发生事件的组件，比如说按钮Button就是一个事件源，他可以发生ActionEvent这样的事件。这些事件源类型的父类就是Component。

(3) 事件监听器(event listener)
    这是一些相应事件，并完成相应逻辑功能的对象。
    比如点击按钮，产生了一个ActionEvent对象，但需要完成相应的业务逻辑。必须使用到ActionListener监听器。但要注意ActionListener并不是类，而是接口，不同的业务逻辑要封装在完成ActionListener接口的不同类中。
    这些监听器接口都继承了接口java.util EventListener 。

 

当我们鼠标点击Button按钮时，发生了什么呢？我们来解析一下Button按钮中的一些重要方法源码。

Java代码

1.     //1、当按下按钮并释放时,执行按钮上的这个操作，并产生一个ActionEvent事件   
2.      public boolean doAccessibleAction(int i) {   
3.            if (i == 0) {   
4.                // 模拟按钮点击   
5.                 Toolkit.getEventQueue().postEvent(   
6.                        new ActionEvent(Button.this,   
7.                                         ActionEvent.ACTION_PERFORMED,   
8.                                         Button.this.getActionCommand()));   
9.                return true;   
10.             } else {   
11.                return false;   
12.             }   
13.         }   
14.   
15.      //2、当按下按钮并释放时，AWT 通过调用按钮的 processEvent，将产生的ActionEvent事件发送给按钮处理。   
16. protected void processEvent(AWTEvent e) {   
17.         //注意，如果事件是ActionEvent类型或其子类，则会调用processActionEvent()方法。   
18.     if (e instanceof ActionEvent) {   
19.          processActionEvent((ActionEvent)e);   
20.         return;   
21.      }   
22.     super.processEvent(e);   
23.         }   
24.   
25. //3、调用监听器的actionPerformed方法   
26. protected void processActionEvent(ActionEvent e) {   
27.      ActionListener listener = actionListener;   
28.     if (listener != null) {   
29.          listener.actionPerformed(e);  //真正执行响应后的业务逻辑的是监听器。   
30.      }   
31.         }  

     //1、当按下按钮并释放时,执行按钮上的这个操作，并产生一个ActionEvent事件
      public boolean doAccessibleAction(int i) {
            if (i == 0) {
                // 模拟按钮点击
                Toolkit.getEventQueue().postEvent(
                        new ActionEvent(Button.this,
                                        ActionEvent.ACTION_PERFORMED,
                                        Button.this.getActionCommand()));
                return true;
            } else {
                return false;
            }
        }

      //2、当按下按钮并释放时，AWT 通过调用按钮的 processEvent，将产生的ActionEvent事件发送给按钮处理。
 protected void processEvent(AWTEvent e) {
         //注意，如果事件是ActionEvent类型或其子类，则会调用processActionEvent()方法。
  if (e instanceof ActionEvent) {
      processActionEvent((ActionEvent)e);
      return;
  }
  super.processEvent(e);
        }
  
 //3、调用监听器的actionPerformed方法
 protected void processActionEvent(ActionEvent e) {
  ActionListener listener = actionListener;
  if (listener != null) {
      listener.actionPerformed(e);  //真正执行响应后的业务逻辑的是监听器。
  }
        }

通过这三个源码，我们可以看到AWT的事件相应机制是这样完成的：
(1) 由事件源(Button)产生一个与动作(按下按钮并释放)相适应的ActionEvent事件。
(2) 事件源会将这个ActionEvent事件发送给监听器，并执行监听器的actionPerformed(e)方法来完成事件响应。

 

可事件源是如何知道由哪一个监听器来完成呢。这是我们必须为事件源指定某一个监听器，依然看看Button中的源代码：

Java代码

1. public class Button extends Component implements Accessible {   
2.     // 按钮中的监听器对象   
3.     transient ActionListener actionListener;   
4.     // 注册指定的监听器   
5.     public synchronized void addActionListener(ActionListener l) {   
6.     if (l == null) {   
7.         return;   
8.      }   
9.      actionListener = AWTEventMulticaster.add(actionListener, l);   
10.          newEventsOnly = true;   
11.      }   
12. }  

public class Button extends Component implements Accessible {
    // 按钮中的监听器对象
    transient ActionListener actionListener;
    // 注册指定的监听器
    public synchronized void addActionListener(ActionListener l) {
 if (l == null) {
     return;
 }
 actionListener = AWTEventMulticaster.add(actionListener, l);
        newEventsOnly = true;
    }
}

现在很明白了，只要向按钮注册指定的监听器就OK了。

综上所述，AWT事件处理机制概要如下：
(1) 将响应事件所需要的业务逻辑封装在实现监听器接口的类中。
    Class ClickAction implements ActionListener{
          public void actionPerformed(ActionEvent e){
              // ....more work to do.
      }
    }
(2) 创建事件源并注册完成所需业务逻辑的监听器。
    ActionListener click=new ClickAction();
    Button btn=new Button();
    btn.addActionListener(click);
(3) 当事件发生时，事件源就会像上面所说的将事件对象传递给所有注册的监听器。

(4) 接着调用监听器的actionPerformed方法来完成事件响应。