talk is cheap ， show me the code.
Swing中的事件
事件驱动
所有的GUI程序都是事件驱动的。Swing当然也是。
GUI程序不同于Command Line程序，一个很大的区别是程序执行的驱动条件：命令行程序是接受用户输入的文本参数，对命令解析，然后通过类似switch的选择来执行不同的功能模块。而GUI程 序就不一样了。GUI程序由界面元素组成，如Button，CheckBox，TextArea，等等。用户操作不同的组件，就会引发不同的事件，然后， 程序编写时注册到UI组件上的事件处理程序得到调用，以此来和用户交互。
事件Event
事件有点类似于异常：事件是事件类的对象，它携带了事件相关的信息，异常是异常类的对象，他携带了异常信息。无论是异常，还是事件
发生时，我们的程序都要事先写好相应的代码应对并处理。只不过，对于程序员来说，事件是正派的，而异常则是反派，谁也不希望自己的程序出现异常。
java中，所有的事件类都是EventObject类的子类，所有的事件都有一个成员字段：source用来保存事件源，即引发事件的对象。
public class EventObject implements java.io.Serializable {
private static final long serialVersionUID = 5516075349620653480L;
/* source保存 引发事件的对象的引用*/
protected transient Object source;
public EventObject(Object source) {
if (source == null)
throw new IllegalArgumentException("null source");
this.source = source;
}
public Object getSource() {
return source;
}
public String toString() {
return getClass().getName() + "[source=" + source + "]";
}
}
Swing的事件机制由AWT提供，下面是Swing中常用的高级事件 ActionEvnet类的部分代码。还有其他事件。
public class ActionEvent extends AWTEvent {
public ActionEvent(Object source, int id, String command, long when,
int modifiers) {
super(source, id);
this.actionCommand = command;
this.when = when;
this.modifiers = modifiers;
}
//.......
}
事件队列Event Queue
Swing应用程序中的所有事件都会由 java.awt.EventQueue对象来管理。
1、EventQueue中的事件会按序一 一 分发，一个时间点只能处理1个事件。
2、如果时间A先入队，B后入队，则A一定会在B的前面被处理。
3、队列中的事件会在一个单独的线程中被处理，这个线程就是EDT线程。
由于Swing是单线程的，线程不安全的，所以Swing中的UI操作就必须以事件的形式放置到EventQueue中按序分发处理。这就保证了Swing组件状态的可预知性和正确性。
Swing的正确使用姿势是：所有与GUI相关的操作都必 以事件的形式发布到Event Queue中，并在EDT中处置。
事件源EventSource
异常，有引发异常的原因，事件，也有引发事件的对象，这就是事件源。谁引发了事件，谁就是事件源。
比如，Button被点击时引发事件，Button就是事件源，JFrame 状态变化时，JFrame也是事件源。Swing中所有的组件，都有感知自己被操作的能力。
Swing中，事件源一般是一些用户组件，他们能感知用户的操作，并引发相应的事件，最后通知对自己注册的监听器。
事件源都会提供事件的注册接口，所有对某个组件的某个事件感兴趣的其他代码，都可以提前注册到这个组件上，事件发生时，此组件就会调用相应的注册的
事件处理程序。
下面是JButton的父类 AbstractButton的一个方法。
protected void fireActionPerformed(ActionEvent event)
{
// Guaranteed to return a non-null array
Object[] listeners = listenerList.getListenerList();
ActionEvent e = null;
// Process the listeners last to first, notifying
// those that are interested in this event
for (int i = listeners.length-2; i>=0; i-=2)
{
if (listeners[i]==ActionListener.class)
{
// Lazily create the event:
if (e == null) {
String actionCommand = event.getActionCommand();
if(actionCommand == null)
{
actionCommand = getActionCommand();
}
e = new ActionEvent(AbstractButton.this,
ActionEvent.ACTION_PERFORMED,
actionCommand,
event.getWhen(),
event.getModifiers());
}
((ActionListener)listeners[i+1]).actionPerformed(e);
}
}
}
监听者Listener
监听者（有的也叫侦听器）：实现了某个监听接口的类对象。某个类实现了一个监听器接口，它就是一个监听者。
当事件发生时，并不是事件源处理事件，而是注册在事件源的上的监听器去处理。事件源只是通知监听器，通知实质是调用所有监听器对象按接口约定实现的的接口方法。
我们知道，对象实现了某个接口，就代表这个对象能做什么。同理，一个对象想成为监听器，它就必须实现相应的监听器接口，表明他有处理某个事件的能力。
监听器实现了监听接口，就必然要实现接口中定义的方法，用来应对事件。
所有的监听器接口都必须扩展自EventListener,它是一个空接口。一个事件往往对应一个监听者接口。
JComponnet类是所有Swing组件的父类。JComponnet 类中有一个 EventListenerList成员，它是一个表，用来存储所有注册的监听者。那也就是说，所有的Swing组件内部都包含一个存储监听者的列表，这也是为什么能向Swing组件中注册监听器的本质。
public abstract class JComponent extends Container implements Serializable,TransferHandler.HasGetTransferHandler{
/** A list of event listeners for this component. */
protected EventListenerList listenerList = new EventListenerList();
//.......
}
/** EventListenerList类
这是一个用于保存监听器的一个表类型。这个表可以存储任何类型的EventListener，因为内部是用的一个Object数组存储的。
*/
public class EventListenerList implements Serializable
{
protected transient Object[] listenerList = NULL_ARRAY;
//获取所有监听者的数组
public Object[] getListenerList()
{
return listenerList;
}
/**
* 返回监听者的数量*/
public int getListenerCount()
{
return listenerList.length/2;
}
/**
向监听者列表中添加 “一对” 新的监听者。其实是添加一个监听者，
只不过对于一个监听者需要保存2项：监听者的类 t，和监听者本身 l
*/
public synchronized <T extends EventListener> void add(Class<T> t, T l)
{
if (l==null) {return;}
if (!t.isInstance(l))
{ throw new IllegalArgumentException("Listener " + l +" is not of type " + t); }
if (listenerList == NULL_ARRAY)
{
//如果是第一次添加监听者，则 new 一个Object 数组。
listenerList = new Object[] { t, l };
}
else
{
int i = listenerList.length;
Object[] tmp = new Object[i+2];
System.arraycopy(listenerList, 0, tmp, 0, i);
tmp[i] = t;
tmp[i+1] = l;
listenerList = tmp;
}
}
}
这个时候你再回去看事件源分块中的那段代码，是不是思路清晰许多了呢？
所以，事件源通知监听者，实质是遍历内部的监听者表，将自己作为EventSorece，构造一个事件对象，并调用所有监听者的事件处理程序时，将构造的事件对象传递过去。
如果你还是有点迷糊，下面通过一例子说明下。
下面是一个简单的Swing程序。
监听者：ButtonClickListener 类对象，它实现了监听器接口。一般我们会使用匿名内部类完成监听者的实例化，这里写出成员内部类是为了更清晰。当使用addActionListener方法注册后，ButtonClickListener对象就被存储在Button对象内部的一个EventListenerList列表中了。
事件 ：点击Button时生成。
事件源：被点击的Button对象。
import java.awt.Dimension;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.SwingUtilities;
public class SwingDrive {
public static void main(String[] args) {
SwingUtilities.invokeLater(new Runnable() {
@Override
public void run() {
JFrame frame = new TestFrame("测试");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setVisible(true);
}
});
}
}
class TestFrame extends JFrame
{
private static final int FRAME_WIDTH = 530;
private static final int FRAME_HEIGHT = 360;
/*************View******************/
private JPanel mainPanel = null;
private JButton msgButton = null;
private JLabel msgLabel = null;
public TestFrame(String title)
{
super(title);
initUI();
}
private void initUI()
{
//内容面板
mainPanel = new JPanel();
mainPanel.setPreferredSize(new Dimension(FRAME_WIDTH,FRAME_HEIGHT));
this.setContentPane(mainPanel);
//按钮
msgButton = new JButton("我是按钮");
//监听者表示对按钮的点击事件感兴趣，于是注册到按钮上。
msgButton.addActionListener(new ButtonClickListener());
//msg显示文本
msgLabel = new JLabel();
//将组建添加到窗体的内容面板中
this.add(msgButton);
this.add(msgLabel);
this.pack();
}
/*监听者，实现了监听接口*/
private class ButtonClickListener implements ActionListener
{
@Override
public void actionPerformed(ActionEvent e) {
msgLabel.setText("你点击了按钮");
}
}
}
还有一点疑问
who invoke the fireActionPerformed(ActionEvent event) method？
谁调用了JButton的fireActionPerformed方法呢？
如果你能想到这个问题，说明你已经开始深入了。这是Swing本身的机制，确切说是AWT提供的机制。一个Swing程序中会有一个toolkit线程不断运行着，它监视用户对组件的操作，当组件被点击，获取焦点，被最大化，状态改变等，都会被toolkit线程发现，并将fireXXX发送带EDT中执行，fireXXX的执行，又会导致所有监听器的执行。
先不急，这涉及到Swing线程的知识，请往下看。
Swing中的线程
1、主线程，main方法，程序执行的入口。任何程序都必须有的。
2、初始化线程。创建和初始化图形界面。
3、tookit线程：负责捕捉系统事件，如鼠标，键盘等。负责感知组件的操作，并将事件发通知EDT。
4、EDT线程：处理Swing中的各种事件。UI绘制，UI的修改操作,UI的绘制渲染.，监听者的事件处理函数，等。所有的UI操作都必须在EDT线程中执行，不允许在其他线程中。
5、N个后台工作线程：处理耗时任务，如网络资源下载，可能阻塞的IO操作。
初始化线程
public static void main(String [] args)
{
SwingUtilities.invokeLater(new Runnable{
public void run()
{
//初始化线程逻辑代码在这里执行
}
});
}
Swing多线程的执行
图画完后，我才发现图画的有一问题：其中EDT线程和toolkit线程是循环线程，并没有确切的执行终点，也就是不知道这2个线程什么时候执行任务到100%。只要Swing程序没有结束，他们就一直工作，因为用户可能在任何时候执行UI操作。
后台工作线程当执行完任务后就结束了。
一、不要在EDT线程中执行耗时的任务。
一旦EDT线程被阻塞，UI组件就不能及时渲染，更新，使得整个程序失去对用户的响应。用户体验十分糟糕。
Swing本身是设计为单线程操作的,并非线程安全的.这就意味着:所有的UI操作都会必须在EDT线程中进行。内置的组件都是遵守这个约定的，比如一个JButton被按下时，它需要显示为按下的状态，那么，这个渲染为按下的状态，就会以事件的形式发布到EDT线程中去执行。同样，按钮弹起时，需要渲染为普通状态，也会引发事件，并在EDT中处理。
不要让EDT干 "体力活"。很明显，Swing中组件UI的更新，都会形成事件置于事件队列，并等待EDT派发，也就是UI更新依赖EDT线程完成。如果你的事件处理程序太耗时了，那么，UI就很久得不到及时更新，造成界面假死现象。
下面这个程序中，用户点击下载按钮后，真个界面都失去了响应，按钮久久不能弹起，窗口也失去了响应，体验很糟糕。
class BadFrame extends JFrame
{
public BadFrame()
{
super();
initUI();
}
private JButton downloadButton ;
private JPanel mainPane ;
private void initUI()
{
mainPane = new JPanel();
mainPane.setPreferredSize(new Dimension(430,250));
this.setContentPane(mainPane);
downloadButton = new JButton("下载");
this.getContentPane().add(downloadButton);
downloadButton.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
downloadMovie();
}
});
this.pack();
}
//模拟下载任务
private void downloadMovie()
{
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
二、不要在非EDT线程中访问UI，操作UI组件。
Swing组件都不是线程安全的，只有把他们的操作限制在一个线程中，才能保证所有的UI的操作都符合预期。这个线程就是EDT线程。那么，怎样将UI操作发送到EDT中执行呢？
通过以下之一。
EDT线程维护一个事件队列EventQueue , 所有的UI渲染，UI事件都打包为事件放到EventQueue中排队处理。这样就让Swing在并发编程安全运行，因为单一线是顺序执行的，不会有线程安全性的问题。
SwingUtilities.invokeLater(new Runnable() {
@Override
public void run() {
}
});9
SwingUtilities.invokeAndWait(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
}
});9
他们有什么区别？
SwingUtilities.invokeLater调用后立即返回。然后执行第9行后的代码。其他线程和 invokeLater中的参数线程异步执行。互不阻塞。
SwingUtilities.invokeAndWait调用后，必须等到 线程对象 run方法在EDT中执行完了，才返回，然后继续执行第9行后的代码。
下面是一个简单的例子：用户输入2个整数 start ，end，程序计算从start 累加到end 的结果。我依然使用了线程睡眠来模拟耗时任务。因为如果我使用更加贴近现实的例子的话，又会引出更多的知识点。
虽然简单，但说明了如何让Swing更好的工作。
import java.awt.Dimension;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JTextField;
import javax.swing.SwingUtilities;
public class Demo {
public static void main(String[] args)
{
SwingUtilities.invokeLater(new Runnable() {
@Override
public void run() {
MFrame frame = new MFrame();
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setVisible(true);
}
});
}
}
class MFrame extends JFrame
{
public MFrame()
{
initUI();
onButtonClick();
}
/***************Model*************/
private int start = 0;
private int end = 0;
private int result = 0;
/************View***************/
private JButton calcButton = null;
private JTextField startField = null;
private JTextField endField = null;
private JTextField resultField = null;
private JPanel mainpane = null;
private void initUI()
{
calcButton =new JButton("计算");
startField = new JTextField();
startField.setColumns(5);
endField = new JTextField();
endField.setColumns(5);
resultField = new JTextField();
resultField.setColumns(5);
resultField.setEditable(false);
mainpane = new JPanel(new GridLayout(1, 4,5,0));
mainpane.setPreferredSize(new Dimension(300,50));
mainpane.add(startField);
mainpane.add(endField);
mainpane.add(resultField);
mainpane.add(calcButton);
this.setContentPane(mainpane);
this.setLocationRelativeTo(null);
this.pack();
}
//为button注册监听者
private void onButtonClick()
{
calcButton.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent event) {
Thread calcThread = new Thread(new Runnable() {
@Override
public void run()
{
try{
start = Integer.parseInt(startField.getText());
end = Integer.parseInt(endField.getText());
for (int i = start; i <=end; i++)
{
result += i; //假设计算过程十分耗时，就像挖矿一样。
Thread.sleep(500);
}
//耗时任务完成后了，通过SwingUtilities.invokeLater将设置任务到UI的事件发送到EDT线程中。
SwingUtilities.invokeLater(new Runnable()
{
@Override
public void run() {
resultField.setText(result+"");
}
});
}
catch(NumberFormatException e)
{
JOptionPane.showMessageDialog(MFrame.this, "请输入一个合法的整数", "错误", JOptionPane.ERROR_MESSAGE);
}
catch (InterruptedException e) {
System.out.println("计算时错误");
}
}
}); //wrok Thread new End
calcThread.start(); //启用任务线程
}
});
}
}
更优雅的解决办法：SwingWorker线程类
当Swing程序复杂后，自定义线程会让代码越来越庞大，不好理解。于是jdk1.6中引入了SwingWorker线程类，简化了程序员的工作。今天就写到这里，我会在以后的文章中介绍。:)