Java监听：一个Java睡前故事(Java Listener: A Java Bedtime Story)，

Java监听：一个Java睡前故事(Java Listener: A Java Bedtime Story)

 

作者: 杨帆           博 邮

 

本文是仿照 .NET Delegates: A C# Bedtime Story 的功能实现的Java版源代码，时间原因，没有给出文字故事 。请参见原文链接。

 

接口定义

package cn.steven.demo;

import java.util.EventListener;
import java.util.EventObject;
/**
 * 监听接口 用于处理各种事件
 * 此处设计与JDK不同
 */
public interface StevenEventListener extends EventListener {
	public void doListen(EventObject e);
}


package cn.steven.demo;
/**
 * 评价接口
 */
public interface IAppraisable {
	//评价的方法
	public void appraise(String name, int degree);
}

事件

独立工作事件

package cn.steven.demo; import java.util.EventObject; public class WorkEvent extends EventObject { private String eventMsg = "干活了"; public String getEventMsg() { return eventMsg; } public void setEventMsg(String eventMsg) { this.eventMsg = eventMsg; } /** * 自动升成的serialVersionUID用于序列化 */ private static final long serialVersionUID = 6232430258434094316L; /** * @param source 事件源 */ public WorkEvent(Object source) { super(source); } }

生活事件 (注意此事件有两个子类)

package cn.steven.demo; import java.util.EventObject; public abstract class LifeEvent extends EventObject { public abstract String getEventMsg(); public LifeEvent(Object source) { super(source); } private static final long serialVersionUID = -5117554641874171524L; }

 

package cn.steven.demo; public class BornEvent extends LifeEvent { private String eventMsg = "出生"; public String getEventMsg() { return eventMsg; } public void setEventMsg(String eventMsg) { this.eventMsg = eventMsg; } public BornEvent(Object source) { super(source); } private static final long serialVersionUID = 8880371520168303175L; }

 

package cn.steven.demo; public class DieEvent extends LifeEvent { public DieEvent(Object source) { super(source); } private String eventMsg = "死亡"; public String getEventMsg() { return eventMsg; } public void setEventMsg(String eventMsg) { this.eventMsg = eventMsg; } private static final long serialVersionUID = 5643693360168396103L; }

 

监听器

package cn.steven.demo;

import java.util.EventObject;

public class Boss implements StevenEventListener{

	/**
	 * 只对WorkEvent事件响应
	 */
	@Override
	public void doListen(EventObject e) {
		if(e instanceof WorkEvent){
			System.out.println("老板:"+e.getSource()+"开工啦!");
			
			
			try {
				//老板由于事务繁忙，打分时间要长，所以需要异步调用节省时间
				Thread.currentThread().sleep(500);
			} catch (InterruptedException e1) {
			}
			
			Object source = e.getSource();
			//如果可以打分
			if(source instanceof IAppraisable){
				IAppraisable ia = (IAppraisable)source;
				//老板打分
				ia.appraise("老板", 5);
			}
		}
	}

}


package cn.steven.demo;

import java.util.EventObject;

public class God implements StevenEventListener {

	@Override
	public void doListen(EventObject e) {
		if (e instanceof LifeEvent) {
			LifeEvent de = (LifeEvent) e;
			System.out.println("上帝：(生命时间)" + de.getSource() + de.getEventMsg());
		}

		if (e instanceof WorkEvent) {
			WorkEvent de = (WorkEvent) e;

			System.out.println("上帝：(工作时间)" + de.getSource() + de.getEventMsg());
			
			try {
				//god由于事务繁忙，打分时间要长，所以需要异步调用节省时间
				Thread.currentThread().sleep(1000);
			} catch (InterruptedException e1) {
			}
			
			Object source = e.getSource();
			//如果可以打分
			if(source instanceof IAppraisable){
				IAppraisable ia = (IAppraisable)source;
				//上帝打分
				ia.appraise("上帝", 6);
			}
		}
	}
}


package cn.steven.demo;

import java.util.EventObject;

public class Satan implements StevenEventListener {

	@Override
	public void doListen(EventObject e) {
		if (e instanceof DieEvent) {
			DieEvent de = (DieEvent) e;
			System.out.println("撒旦：" + de.getSource() + de.getEventMsg());
		}
	}

}

事件源

package cn.steven.demo; import java.util.EventObject; import java.util.HashMap; import java.util.LinkedList; import java.util.List; import java.util.Map; //Worker的工作是可以评价的IAppraisable public class Worker implements IAppraisable { private String name; private Map<Class<? extends EventObject>, List<StevenEventListener>> listenerMap; public Worker(String name) { this.name = name; listenerMap = new HashMap<Class<? extends EventObject>, List<StevenEventListener>>(); } @Override public String toString() { return name; } // 增加监听器 public synchronized void addListener(StevenEventListener listener, Class<? extends EventObject>... eventClass) { if (null != listenerMap) { if (eventClass.length <= 0) { throw new RuntimeException("至少指定一个事件进行监听！"); } else { for (int i = 0; i < eventClass.length; i++) { Class<? extends EventObject> e = eventClass[i]; List<StevenEventListener> list = null; if (listenerMap.containsKey(e)) { list = listenerMap.get(e); } if (null == list) { list = new LinkedList<StevenEventListener>(); } if (list.contains(listener)) { // 如果已存在，不操作，处理下一个事件 continue; } list.add(listener); listenerMap.put(e, list); } } } } // 移除事件监听器 public synchronized void removeEventListener(StevenEventListener listener, Class<? extends EventObject>... eventClass) { if (null != listenerMap) { // 如果没给定第二个参数 if (eventClass.length <= 0) { // 在所有事件中移除监听器 for (Map.Entry<Class<? extends EventObject>, List<StevenEventListener>> entry : listenerMap .entrySet()) { List<StevenEventListener> list = entry.getValue(); if (null != list) { list.remove(listener); } } } else { // 在给定的事件中移除监听器 for (int i = 0; i < eventClass.length; i++) { Class<? extends EventObject> e = eventClass[i]; if (listenerMap.containsKey(e)) { List<StevenEventListener> list = listenerMap.get(e); if (null != list) { list.remove(listener); } } } } } } public synchronized void removeListener(StevenEventListener listener) { if (null != listenerMap) { } } // 移除所有监听器 public synchronized void removeAllListener() { if (null != listenerMap) { listenerMap.clear(); } } // 处理监听 public void doEvent(final EventObject e) { if (null != listenerMap) { // 在此，如果key是event的祖先也可以监听 for (Map.Entry<Class<? extends EventObject>, List<StevenEventListener>> entry : listenerMap .entrySet()) { if (entry.getKey().isInstance(e)) { if (null != entry.getValue()) { for (final StevenEventListener stevenEventListener : entry .getValue()) { if (null != stevenEventListener) { // 处理监听 同步方法 // stevenEventListener.doListen(e); // 处理监听 异步多线程方法 Thread t = new Thread(new Runnable() { public void run() { stevenEventListener.doListen(e); } }); // 如果设置为守护进程，程序退出后此进程关闭 // t.setDaemon(true); // 如果不设置为守护，则程序退出后线程还会运行 t.start(); // 如果想再次等待非守护想成结束在结束进程(阻塞调用线程，直到某个线程终止时为止。变为同步)，则join // try { // t.join();//必须放在线程启动的后面 // } catch (InterruptedException e1) { // } } } } } } } } // 工作方法 public void work() { System.out.println("@我干活了!"); doEvent(new WorkEvent(this)); } public void born() { System.out.println("@我出生了!"); doEvent(new BornEvent(this)); } public void die() { System.out.println("@我死了!"); doEvent(new DieEvent(this)); } //对工作打分 需要回调(callback) @Override public void appraise(String name, int degree){ System.out.println(name+"评价工作为"+degree+"分!"); } }

 

运行

package cn.steven.demo; public class Run { public static void main(String[] args) { System.out.println("/t进程开始"); // 事件源 Worker worker = new Worker("东方不败"); Boss boss = new Boss(); God god = new God(); Satan satan = new Satan(); // 老板只对工作关心 worker.addListener(boss, WorkEvent.class); // god对两种时间都关心 worker.addListener(god, WorkEvent.class, LifeEvent.class); // satan对死亡关心 worker.addListener(satan, DieEvent.class); worker.work(); worker.born(); worker.die(); System.out.println("/t进程结束 在此后出现的为非守护线程"); } }

 

运行结果

进程开始 @我干活了! @我出生了! 老板:东方不败开工啦! @我死了! 上帝：(工作时间)东方不败干活了 上帝：(生命时间)东方不败出生 进程结束 在此后出现的为非守护线程 撒旦：东方不败死亡 上帝：(生命时间)东方不败死亡 老板评价工作为5分! 上帝评价工作为6分!

 

后记

java版的故事很明显要比c#的代码多，这实际上是由于Java中的很多机制是编程实现而不是类库和语言特性支持的缘故，下图是两种实现的比较。

 

	java	c#	说明
效率	采用多态，相对高	采用委托，相对低。	应该说，它们都是在运行时获取对哪个对象的哪个方法进行调用，但是采用多态相对于委托效率高一点。
是否支持静态方法调用	否	是	java采用多态，当然不能把方法声明为static;c#中delegate中的_object可以为null来实现对静态方法的调用
是否类型安全	是	是	它们都会在编译时对响应函数进行参数检查，类型安全。
开发者易用性	两级实体对象：事件源-与事件响应者	三级实体对象：事件源-委托-事件响应者	由于有delegate的封装，不用编写事件注册/注销之类的代码，c#事件处理易用性相对高；注意，虽然java中采用接口来规范响应函数，但这里却说java中是两级实体对象，是因为在运行时并不存在接口的实例(实际上，接口也不可实例化，呵呵)