事件模型到底是什么？

事件模型是个什么玩意？

这两天在研究java的设计模式，到底什么是设计模式呢？通过多方面查找，得到下面的结论：设计模式就是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。 毫无疑问，设计模式于己于他人于系统都是多赢的，设计模式使代码编制真正工程化，设计模式是软件工程的基石，如同大厦的一块块砖石一样。按照我的理解，我认为设计模式并不难于理解，难得是怎么合理的运用设计模式。下面先说一说事件模型，在接下来的学习过程中，会不断的总结其他的模式，请敬请期待~~~
要想弄清什么是事件模型，我们就得先找一个事例。我们就举给按钮添加动作事件模型的例子。我们都知道事件的参与者要有三部分组成，分别为事件源，监听器，和事件。事件的处理过程就是，当在事件源上触发了相应的事件，就会调用相应的事件处理器去处理这个事件，来执行相应的操作。我们来看下面的例子：点击按钮，输出”点击了按钮”。那样这个按钮就是事件源，点击按钮就是相应的事件，输出”点击了按钮”就是相应的处理操作。

JButton b1 = new JButton();
		b1.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent e) {
				System.out.println("点击了按钮");

			}
		});

上面的代码就是实现上面事件的代码，b1作为事件源，点击按钮这个动作作为事件，而实例化ActionListener,重写actionPerformed方法就是事件的相应处理器。那为什么事件源通过add<事件名>Listener方法来添加监听器呢，我们看源码可知实际上有一个保存事件监听器的listenerList，每次add时，就把这个事件监听器添加到listenerList队列中去，然后每一个事件监听器都是实现了一个事件监听器接口，重写actionPerformed(ActionEvent e)方法，来实现自己的动作。

public void addActionListener(ActionListener l) {
    	    listenerList.add(ActionListener.class, l);
    }

然后在当点击按钮的时候，就回遍历这个队列，找到对应的事件监听器来进行相应的事件处理。源码如下：

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);
            }          
        }
    }

好，既然我们知道了系统是如何处理事件的了，那我们自己写一个事件模型就容易的多了。我总结事件模型的建立可以依照下面几个步骤：
1. 建立事件接口
2. 建立事件监听器接口
3. 建立模拟事件源
4. 实现具体的实现上述接口的类。
我们以客户端接收消息为例：将接收到的消息显示到一个JTextField中
代码如下：
1. 首先我们要了解这个过程中事件是什么？可知，就是一个接收消息
所以我们建立一个消息接口类：

package 接口包;
/**
 * 事件接口：消息类
 * @author YuYang
 *
 */

public interface Message {
	//得到消息的方法
	public String getMessage();
}

2. 然后要有一个事件监听接口来处理接收到的相应消息，采取动作

package 接口包;
/**
 * 事件监听器接口
 * @author YuYang
 *
 */

public interface Monitor {
	//不同的监听器采取不同的动作
	public void MonitorPro(Message m);
}。

3. 我们模拟事件源，接收消息。通过查看源代码，我们知道要创建一个储存事件监听器的队列。由于接收消息是不断的，应采取多线程。

package 事件源包;
/**
 * 模拟事件源
 */
import java.util.ArrayList;

import 实现接口包.SMessage;
import 接口包.Message;
import 接口包.Monitor;

public class NetConn extends Thread{
	//用于储存监听器对象的队列
	private ArrayList<Monitor> list = new ArrayList<Monitor>();
	//提供给队列添加对象的方法
	public void addMonitor(Monitor m){
		list.add(m);
	}

	public void run(){
		int i = 0;
		while (true){

			i ++;
			//模拟接收到的消息
			Message message = new SMessage("收到的消息"+i+"\t\n");
			//遍历监听器队列
			for(int j =0;j<list.size();j++){
				//得到相应的监听器对象
				Monitor m = list.get(j);
				//实现各自不同的动作
				m.MonitorPro(message);
			}
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
}

4. 实现具体的实现上述接口的类。此步骤就是要实现相应的接口。
a) 实现消息接口，获取消息

package 实现接口包;
/**
 * 实现消息接口，模拟接收消息
 */
import 接口包.Message;

public class SMessage implements Message{
	private String message;

	public SMessage(String message){
		this.message = message;
	}
	@Override
	public String getMessage() {
		// TODO Auto-generated method stub
		return this.message;
	}

}

b) 实现监听器接口

package 实现接口包;
/**
 * 实现监听器接口
 */

import java.awt.TextField;

import 接口包.Message;
import 接口包.Monitor;

public class STextField extends TextField implements Monitor{

	//实现触发本监听器采取的相应动作的方法
	public void MonitorPro(Message m) {
		this.setText(m.getMessage());

	}

}

c)将上诉部分组装起来

package 组装包;
import java.awt.*;
import javax.swing.*;

import 事件源包.NetConn;
import 实现接口包.STextField;

public class Test {
	public static void main(String[] args) {
		JFrame jf = new JFrame();
		jf.setLayout(new FlowLayout());
		jf.setSize(100,100);

		NetConn nc = new NetConn();
		STextField stf = new STextField();
		nc.addMonitor(stf);

		nc.start();

		jf.add(stf);
		jf.setVisible(true);
		jf.setDefaultCloseOperation(3);

	}
}

这样，一个事件模型就写好了！