java事件处理机制

java中的事件机制的参与者有3种角色：  

1.event object：就是事件产生时具体的“事件”，用于listener的相应的方法之中，作为参数，一般存在与listerner的方法之中   

2.event source：具体的接受事件的实体，比如说，你点击一个button，那么button就是event source，这样你必须使button对某些事件进行相应，你就需要注册特定的listener，比如说MouseEvent之中的MouseClicked方法，这是他就必须有了add方法   

3.event listener：具体的对监听的事件类，当有其对应的event object产生的时候，它就调用相应的方法，进行处理。在windows程序设计里边这种相应使用callback机制来实现的    

先看看jdk提供的event包：

public interface EventListener：所有事件侦听器接口必须扩展的标记接口。

public class EventObject extends Object implements Serializable所有事件状态对象都将从其派生的根类。 所有 Event 在构造时都引用了对象 "source"，在逻辑上认为该对象是最初发生有关 Event 的对象。           

在Java2处理事件时，没有采用dispatchEvent()-postEvent()-handleEvent()方式，采用了监听器类，每个事件类都有相关联的监听器接口。事件从事件源到监听者的传递是通过对目标监听者对象的Java方法调用进行的。      对每个明确的事件的发生，都相应地定义一个明确的Java方法。这些方法都集中定义在事件监听者（EventListener）接口中，这个接口要继承 java.util.EventListener。
实现了事件监听者接口中一些或全部方法的类就是事件监听者。      伴随着事件的发生，相应的状态通常都封装在事件状态对象中，该对象必须继承自java.util.EventObject。事件状态对象作为单参传递给应响应该事件的监听者方法中。发出某种特定事件的事件源的标识是：遵从规定的设计格式为事件监听者定义注册方法，并接受对指定事件监听者接口实例的引用。    开始之前首先问个问题：您熟悉java.util.EventObject 和java.util.EventListener两个类以及他们已有的子类吗？
  如果你已经能够熟练使用jdk为我们提供的事件监听器，并且很熟悉MouseEvent, KeyEvent, WindowEvent等等这些jdk为我们准备好的事件，那么想必你对java的事件机制已经有所理解。但是也许你还是觉得虽然用起来没什么问题，但是原理还是有些糊涂，那么下面我们再进一步自己实现这些事件和监听器，我们把这个取名为自定义事件。   其实自定义事件在java中很有用处，我们有的时候想让自己的程序产生一个事件，但有不希望（或者不可能）用鼠标，键盘之类的输入设备进行操作，比如你写一个应用程序，在这个程序中一旦收到邮件就对邮件进行相关处理，对于“收到邮件”这个事件，jdk中就没有定义。对于这样的事件，以及对于这样的事件的监听器，我们只能自己动手完成了。

其实呢，java事件处理机制就是观察者模式，我这里详细的整理一下，在并发编程中，动不动就给某一个主题注册一个监听，然后当主题状态发生变化的时候，监听就会被触发。好了，废话不多说了，我贴出几篇代码好了。

第一步：

/**
 *
 */
package test;

/**
 * @author LinkinPark
 * @date 2015年8月31日 下午3:07:34
 * @Description:
 * 前面我已经整理了观察者模式，这里对照这个设计模式来整理下java事件
 * 这里先写个最简单的模拟
 */
public class Util
{

	public static void main(String[] args)
	{
		// 首先初始化一个被观察者，然后在初始化一个观察者
		// 然后将观察者绑定到被观察者上面，然后使用被观察者看看观察者里面的事件有没有被触发
		Observable observable = new Observable();
		Observer observer = new Observer();
		observable.setObserver(observer);
		observable.test();//事件被成功的触发了
	}

}

//这个模拟被观察者
class Observable
{
	//绑定到被观察者上面的观察者
	private Observer observer;

	//被观察者对外面提供的操作
	public void test()
	{
		observer.test();
	}

	public Observer getObserver()
	{
		return observer;
	}

	public void setObserver(Observer observer)
	{
		this.observer = observer;
	}
}

// 这个模拟观察者
class Observer
{
	// 这个模拟事件
	public void test()
	{
		System.out.println("这里就是事件。。。");
	}
}

第二步：

/**
 *
 */
package test;

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

/**
 * @author LinkinPark
 * @date 2015年8月31日 下午3:07:34
 * @Description:
 * 现在在原来的基础上稍微复杂一点，现在不在被观察者身上只绑一个观察者了。
 * 现在绑定多个观察者。
 */
public class Util
{

	public static void main(String[] args)
	{
		// 首先初始化一个被观察者，然后在初始化2个观察者
		// 然后将观察者绑定到被观察者上面，然后使用被观察者看看观察者里面的事件有没有被触发
		Observable observable = new Observable();
		Observer observer1 = new Observer();
		Observer observer2 = new Observer();
		observable.registObserver(observer1);
		observable.registObserver(observer2);
		//调用外部事件，看看观察者里面的事件执行了没有
		observable.notifyObserver("被观察者触发了操作了呢");
	}

}

// 这个模拟被观察者
class Observable
{
	// 绑定到被观察者上面的观察者
	private List<Observer> observers = new ArrayList<Observer>();

	// 添加一个观察者到被观察者身上
	public void registObserver(Observer observer)
	{
		observers.add(observer);
	}

	// 从绑定的观察者集合中去掉当前这个
	public void removeObserver(Observer observer)
	{
		observers.remove(observer);
	}

	// 定义外部执行
	public void notifyObserver(String str)
	{
		for (Observer observer : observers)
		{
			observer.test(str);
		}
	}

}

// 这个模拟观察者
class Observer
{
	// 这个模拟事件
	public void test(String str)
	{
		System.out.println("这里就是事件-->" + str);
	}
}

第三步：

/**
 *
 */
package test;

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

/**
 * @author LinkinPark
 * @date 2015年8月31日 下午3:07:34
 * @Description:
 * 现在在原来的基础上稍微复杂一点，现在不在被观察者身上只绑一个观察者了。
 * 现在绑定多个观察者。现在在稍微复杂一点，观察者和被观察者都面向接口编程，里面提供多个实现
 */
public class Util
{

	public static void main(String[] args)
	{
		// 首先初始化一个被观察者，然后在初始化2个观察者
		// 然后将观察者绑定到被观察者上面，然后使用被观察者看看观察者里面的事件有没有被触发
		Iobservable observable = new Observable();
		Iobserver observer = new Observer();
		Iobserver observer1 = new Observer1();
		observable.registObserver(observer);
		observable.registObserver(observer1);
		// 调用被观察者的外部事件，看看观察者里面的事件执行了没有
		observable.notifyObserver("被观察者触发了操作了呢");
	}

}

// 被观察者对外提供的接口，其实这里定义成抽象类，也就是模板好一点。
interface Iobservable
{
	// 绑定到被观察者上面的观察者
	public List<Iobserver> observers = new ArrayList<Iobserver>();

	// 添加一个观察者到被观察者身上
	void registObserver(Iobserver observer);

	// 从绑定的观察者集合中去掉当前这个
	void removeObserver(Iobserver observer);

	// 定义外部执行
	public void notifyObserver(String str);
}

// 观察者对外提供的接口。
interface Iobserver
{
	// 这个模拟事件
	public void test(String str);
}

// 这个模拟被观察者
class Observable implements Iobservable
{

	public void registObserver(Iobserver observer)
	{
		observers.add(observer);
		System.out.println("这里添加一个被观察者-->" + observer.getClass());
	}

	public void removeObserver(Iobserver observer)
	{
		observers.remove(observer);
		System.out.println("这里溢出一个被观察者-->" + observer.getClass());
	}

	public void notifyObserver(String str)
	{
		for (Iobserver observer : observers)
		{
			observer.test(str);
		}
	}

}

// 这个模拟观察者0
class Observer implements Iobserver
{
	public void test(String str)
	{
		System.out.println("这里就是Observer事件-->" + str);
	}
}

// 这个模拟观察者1
class Observer1 implements Iobserver
{
	public void test(String str)
	{
		System.out.println("这里就是Observer1事件-->" + str);
	}
}

第四步：

/**
 *
 */
package test;

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

/**
 * @author LinkinPark
 * @date 2015年8月31日 下午3:07:34
 * @Description:
 * 现在在原来的基础上稍微复杂一点，现在不在被观察者身上只绑一个观察者了。
 * 现在绑定多个观察者。现在在稍微复杂一点，观察者和被观察者都面向接口编程，里面提供多个实现。
 * 最后现在提供一个最完美的观察者模式，其实和我前面那篇博客写的差不多
 */
public class Util
{

	public static void main(String[] args)
	{
		// 首先初始化一个被观察者，然后在初始化2个观察者
		// 然后将观察者绑定到被观察者上面，然后使用被观察者看看观察者里面的事件有没有被触发
		Iobservable observable = new Observable();
		Iobserver observer = new Observer();
		Iobserver observer1 = new Observer1();
		observable.registObserver(observer);
		observable.registObserver(observer1);
		// 调用被观察者的外部事件，看看观察者里面的事件执行了没有
		System.out.println("===========华丽丽的分割线=============");
		observable.notifyObserver("LinkinPark...");
	}

}

// 被观察者对外提供的接口，其实这里定义成抽象类，也就是模板好一点。
abstract class Iobservable
{
	// 绑定到被观察者上面的观察者
	public List<Iobserver> observers = new ArrayList<Iobserver>();

	// 添加一个观察者到被观察者身上
	abstract void registObserver(Iobserver observer);

	// 从绑定的观察者集合中去掉当前这个
	abstract void removeObserver(Iobserver observer);

	// 通知给观察者，让其开始做相关处理
	public void notifyObserver(String str)
	{
		for (Iobserver observer : observers)
		{
			observer.test(str);
		}
	}

}

// 观察者对外提供的接口。
interface Iobserver
{
	// 这个模拟事件
	public void test(String str);

}

// 这个模拟被观察者
class Observable extends Iobservable
{

	private String name;

	public String getName()
	{
		return name;
	}

	// 在给这个被观察者重新设值name的时候，也就说现在观察者状态发生改变了，那么就要通知给观察者，让他也来做相关的处理
	public void setName(String name)
	{
		this.name = name;
		notifyObserver(name);
	}

	public void registObserver(Iobserver observer)
	{
		observers.add(observer);
		System.out.println("这里添加一个被观察者-->" + observer.getClass());
	}

	public void removeObserver(Iobserver observer)
	{
		observers.remove(observer);
		System.out.println("这里移除一个被观察者-->" + observer.getClass());
	}

}

// 这个模拟观察者0
class Observer implements Iobserver
{

	public Observer()
	{
		System.out.println("Observer:观察者原来的name-->" + getName());
	}

	private String name = "Observer";

	public String getName()
	{
		return name;
	}

	public void setName(String name)
	{
		this.name = name;
	}

	public void test(String str)
	{
		System.out.println("Observer:原来的name-->" + getName());
		setName(str);
		System.out.println("被观察者状态改变后本地的同步name-->" + getName());
	}
}

// 这个模拟观察者1
class Observer1 implements Iobserver
{
	public Observer1()
	{
		System.out.println("Observer1:观察者原来的name-->" + getName());
	}

	private String name = "Observer1";

	public String getName()
	{
		return name;
	}

	public void setName(String name)
	{
		this.name = name;
	}

	public void test(String str)
	{
		System.out.println("Observer1:原来的name-->" + getName());
		setName(str);
		System.out.println("被观察者状态改变后本地的同步name-->" + getName());
	}
}

最后一步：java事件监听了呢。

package test;

import java.util.ArrayList;
import java.util.EventListener;
import java.util.EventObject;
import java.util.Iterator;
import java.util.List;

/**
 * @author LinkinPark
 * @date 2015年9月1日 下午1:46:52
 * @Description: java事件监听机制
 */
public class Linkin
{
	// 初始化主题-->被观察者
	DemoSource source = new DemoSource();
	// 初始化监听-->观察者
	DemoListener Listener1 = new Listener1();
	DemoListener Listener2 = new Listener2();

	public Linkin()
	{
		source.addDemoListener(Listener1).addDemoListener(Listener2).addDemoListener(new DemoListener()
		{
			@Override
			public void demoEvent(DemoEvent demoEvent)
			{
				System.out.println("匿名内部类收到主题推送-->" + demoEvent.getSource().getClass());
			}
		});
		System.out.println("主题原来的状态-->" + name);
	}

	private String name = "nameOld";

	/**
	 * @return the name
	 */
	public String getName()
	{
		return name;
	}

	/**
	 * @param name the name to set
	 */
	public void setName(String name)
	{
		this.name = name;
		System.out.println("主题现在的状态-->" + name);
		source.notifyDemoEvent();
	}

	public static void main(String[] args)
	{
		new Linkin().setName("nameNew");
	}
}

// 就是事件产生时具体的“事件”，用于listener的相应的方法之中，作为参数，一般存在与listerner的方法之中
class DemoEvent extends EventObject
{
	private static final long serialVersionUID = 1L;
	Object obj;

	public DemoEvent(Object source)
	{
		super(source);
		obj = source;
	}

	public Object getSource()
	{
		return obj;
	}

}

// 具体的对监听的事件类，当有其对应的event object产生的时候，它就调用相应的方法，进行处理。
interface DemoListener extends EventListener
{
	void demoEvent(DemoEvent demoEvent);
}

// 这个相当于观察者
class Listener1 implements DemoListener
{

	@Override
	public void demoEvent(DemoEvent demoEvent)
	{
		System.out.println("Listener1监听收到了主题的推送消息" + demoEvent.getSource());
	}
}

// 这个相当于观察者
class Listener2 implements DemoListener
{

	@Override
	public void demoEvent(DemoEvent demoEvent)
	{
		System.out.println("Listener2监听收到了主题的推送消息" + demoEvent.getSource());
	}
}

// 具体的接受事件的实体，也就是观察者模式中的被观察者。比如说，你点击一个button，那么button就是event source，
// 这样你必须使button对某些事件进行相应，你就需要注册特定的listener，比如说MouseEvent之中的MouseClicked方法，这是他就必须有了add方法
class DemoSource
{
	private List<Object> repository = new ArrayList<Object>();
	DemoListener dl;

	public DemoSource()
	{
	}

	// 添加监听
	public DemoSource addDemoListener(DemoListener dl)
	{
		repository.add(dl);
		return this;
	}

	// 状态改变被触发
	public void notifyDemoEvent()
	{
		Iterator<Object> it = repository.iterator();
		while (it.hasNext())
		{
			dl = (DemoListener) it.next();
			dl.demoEvent(new DemoEvent(this));
		}
	}
}