java flash tcp字节流通信(五)-java 伪事件处理器

package com.event;

/**
 * 事件
 */
public class Event {
 /**事件类型*/
 private int type;
 /**参数*/
 private Object[] args;
 public Event(int type, Object ...args){
  this.type = type;
  this.args = args;
 }
 public int getType() {
  return type;
 }
 public Object[] getArgs(){
  return args;
 }
}

---------------------------------------------------------------

package com.event;

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

/**
 *
 * 事件类型注册器,所有监听事件类型都必须通过此类注册
 *
 */
public class EventTypeRegister {
 private static List<Integer> eventTypes = new ArrayList<Integer>();
 public static void regist(int eventType) throws EventTypeException{
  if(isRegist(eventType)){
   throw new EventTypeException(EventTypeException.ERROR_DEFINE, eventType);
  }else{
   eventTypes.add(eventType);
  }
 }
 public static boolean isRegist(int eventType){
  return eventTypes.contains(eventType);
 }
}

--------------------------------------------------------------

package com.event;

/**
 *
 * 类型类型异常
 *
 */
public class EventTypeException extends Exception {

 private static final long serialVersionUID = -3452473972642667800L;

 public static final int ERROR_DEFINE = 0;
 public static final int ERROR_UNDEFINE = 1;
 
 private static final String[] messages = {
  "event type [{0}] is define",
  "event type [{0}] is undefine"
  };
 
 public EventTypeException(int error, int eventType){
  super(messages[error].replace("{0}", String.valueOf(eventType)));
 }
}

--------------------------------------------------------------

package com.event;

import java.util.HashMap;
import java.util.Map;

/**
 *
 * 事件处理结果
 *
 */
public class EventResult {
 /**{key=监听对象,value=方法执行结果*/
 private Map<Object, Object> results;
 public EventResult(){
  results = new HashMap<Object, Object>();
 }
 public void addResult(Object target, Object result){
  results.put(target, result);
 }
 public Object getResult(Object key){
  return results.get(key);
 }
 public Map<Object, Object> getResults(){
  return results;
 }
}

 

--------------------------------------------------------------

package com.event;

import java.lang.reflect.Method;

/**
 *
 * 事件监听类
 *
 */
public class EventListener {
 /**监听对象*/
 private Object target;
 /**监听方法*/
 private Method method;
 public EventListener(Object target, String method, Class<?>... parameterTypes) throws Exception{
  this.target = target;
  this.method = target.getClass().getMethod(method, parameterTypes);
 }
 public Object invoke(Object ...args) throws Exception{
  return method.invoke(target, args);
 }
 public Method getMethod() {
  return method;
 }
 public Object getTarget() {
  return target;
 }
 
}

--------------------------------------------------------------

package com.event;

import java.util.HashMap;
import java.util.Map;

/**
 *
 * 事件派发器
 *
 */
public class EventDispatcher {
 private static EventDispatcher executor;
 /**{key=EventType,value={key=被监听对象,value=EventListeners}}*/
 private static Map<Integer, Map<Object, EventListener>> listeners;
 static{
  init();
 }
 private EventDispatcher(){
  
 }
 
 public static void init(){
  if(executor == null){
   executor = new EventDispatcher();
   listeners = new HashMap<Integer, Map<Object, EventListener>>();
  }
 }
 
 /**
  * 没有通过EventrTypeRegister注册的eventType,将报EventTypeException异常
  * @param eventType 事件类型
  * @param target 被监听对象
  * @param listener 监听器
  * @throws Exception
  */
 public static void addListener(int eventType, Object target, EventListener listener) throws Exception{
  /**添加监听器,事件类型必须是注册过的*/
  if(!EventTypeRegister.isRegist(eventType)){
   throw new EventTypeException(EventTypeException.ERROR_UNDEFINE, eventType);
  }else{
   Map<Object, EventListener> map = listeners.get(eventType);
   if(map == null){
    map = new HashMap<Object, EventListener>();
    listeners.put(eventType, map);
   }
   map.put(target, listener);
  }
 }
 
 /**
  * 移除事件监听器
  * @param evenType 事件类型
  * @param target 被监听对象
  */
 public static void removeListener(int eventType, Object target){
  Map<Object, EventListener> map = listeners.get(eventType);
  if(map != null){
   map.remove(target);
  }
 }
 
 /**
  * 触发事件
  * @param event
  * @return
  */
 public static EventResult dispatchEvent(Event event){
  try{
   Map<Object, EventListener> map = listeners.get(event.getType());
   if(map != null){
    EventResult result = new EventResult();
    for(Map.Entry<Object, EventListener> entry : map.entrySet()){
     result.addResult(entry.getValue().getTarget(), entry.getValue().invoke(event.getArgs()));
    }
    return result;
   }
  }catch(Exception e){
   e.printStackTrace();
  }
  return null;
 }
}

--------------------------------------------------------------

测试类:

package com.event.test;

import com.event.Event;
import com.event.EventDispatcher;
import com.event.EventListener;
import com.event.EventResult;
import com.event.EventTypeRegister;

public class EventTest {
 public final static int LOGIN = 1;
 public final static int LOGOUT = 2;
 
 public EventTest() throws Exception{
  EventTypeRegister.regist(LOGIN);
  EventTypeRegister.regist(LOGOUT);
  EventDispatcher.addListener(LOGIN, this, new EventListener(this, "login", String.class));
  EventDispatcher.addListener(LOGOUT, this, new EventListener(this, "logout", String.class));
 }
 public boolean login(String name){
  System.out.println(name + " login...");
  return true;
 }
 public void logout(String name){
  System.out.println(name + " logout...");
 }
 public static void main(String args[]) throws Exception{
  EventTest test = new EventTest();
  EventResult result1 = EventDispatcher.dispatchEvent(new Event(EventTest.LOGIN, "admin"));
  EventResult result2 = EventDispatcher.dispatchEvent(new Event(EventTest.LOGOUT, "admin"));
  System.out.println(result1.getResult(test));
  System.out.println(result2.getResult(test));
  EventDispatcher.removeListener(EventTest.LOGIN, test);
  EventDispatcher.dispatchEvent(new Event(EventTest.LOGIN, "admin"));
  EventDispatcher.dispatchEvent(new Event(EventTest.LOGOUT, "admin"));
 }
}

测试结果:

admin login...
admin logout...
true
null
admin logout...