事件监听处理小框架

最新推荐文章于 2023-04-16 14:41:07 发布
最新推荐文章于 2023-04-16 14:41:07 发布
阅读量1.8k 收藏 2
点赞数
分类专栏： spring 文章标签： 框架 spring service events java list

转：http://www.javaeye.com/topic/519498

基于SPRING的事件处理其实很简单，初学者不必一开始就担心搞不懂，本文先是介绍完全基于SPRING的事件监听实现(熟识Spring事件监听的朋友应该跳过第一节)，然后依葫芦画瓢自已做一个性能更好事件监听小框架，最后在回贴中加入了注解版。
    为何要使用事件监听，而不是直接调用？打个比方，在系统删除一个用户时，需要把用户的其他信息和行为记录一起删除，此时最容易想到的是：删除用户时，调用其他Service类接口删除与之相关的信息和用户行为记录，但是用户是一个基础模块，随着系统模块不断增加，会有越来越多的模块与之关联，按以上方案，每增加一个与用户相关的模块，那么删除用户时就要把这个模块的信息也一起删除，这样用户这个模块就与这些业务模块偶合在一起了，只要系统不断的增加或减少模块，用户模块就永远都改不完。（以上逻辑仅为说明问题）
    如果采用事件监听，那么在删除一个用户时，发布一事件就完事了，所有相关的模块监听此事件，在事件处理中删除本模块对应的数据，那么用户模块也不会与这些模块有任何偶合了。
    好，回到主题，
    1、完全基于SPRING的事件监听与处理：
    首先，SERVICE总接口类继承org.springframework.context.ApplicationListener接口，并且在SERVICE的抽象类中实现此接口的方法，SERVICE总接口代码：

Java代码 复制代码
  1. import org.springframework.context.ApplicationListener;   
  2.   
  3. /**  
  4.  * 业务层顶层接口  
  5.  */  
  6. public interface IBaseService extends ApplicationListener{   
  7.   
  8. }  
import org.springframework.context.ApplicationListener;

/**
 * 业务层顶层接口
 */
public interface IBaseService extends ApplicationListener{

}



SERVICE抽象类代码，所有具体业务类皆继承此抽象业务类

Java代码 复制代码
  1. import org.springframework.context.ApplicationEvent;   
  2.   
  3. /**  
  4.  * 实现顶层接口的抽象类  
  5.  */  
  6. public abstract class AbstractBaseService implements IBaseService {   
  7.   
  8.   
  9.     /**  
  10.      * 此方法不允许重写，要监听事件，重写onBaseEvent方法  
  11.      */  
  12.     public final void onApplicationEvent(ApplicationEvent event) {   
  13.         if (event instanceof BaseEvent) {   
  14.             onBaseEvent((BaseEvent) event);   
  15.         }   
  16.     }   
  17.   
  18.     /**  
  19.      * 要监听事件就重写此方法  
  20.      */  
  21.     protected void onBaseEvent(BaseEvent event) {   
  22.     }   
  23.   
  24.          /**  
  25.      * 发布事件  
  26.      */  
  27.     protected final void publishEvent(BaseEvent event) {   
  28.         //取得SPRING容器并发布事件   
  29.         org.springframework.web.context.ContextLoader.getCurrentWebApplicationContext().publishEvent(event);   
  30.     }   
  31. }  
import org.springframework.context.ApplicationEvent;

/**
 * 实现顶层接口的抽象类
 */
public abstract class AbstractBaseService implements IBaseService {


	/**
	 * 此方法不允许重写，要监听事件，重写onBaseEvent方法
	 */
	public final void onApplicationEvent(ApplicationEvent event) {
		if (event instanceof BaseEvent) {
			onBaseEvent((BaseEvent) event);
		}
	}

	/**
	 * 要监听事件就重写此方法
	 */
	protected void onBaseEvent(BaseEvent event) {
	}

         /**
	 * 发布事件
	 */
	protected final void publishEvent(BaseEvent event) {
		//取得SPRING容器并发布事件
		org.springframework.web.context.ContextLoader.getCurrentWebApplicationContext().publishEvent(event);
	}
}


BaseEvent类是我自定义的一个类，各业务模块要发布事件，首先定义自已的EVENT类，继承BaseEvent。BaseEvent类代码

Java代码 复制代码
  1. import org.springframework.context.ApplicationEvent;   
  2.   
  3. public class BaseEvent extends ApplicationEvent {   
  4.   
  5.     public BaseEvent(Object source) {   
  6.         super(source);   
  7.     }   
  8.   
  9. }  
import org.springframework.context.ApplicationEvent;

public class BaseEvent extends ApplicationEvent {

	public BaseEvent(Object source) {
		super(source);
	}

}



用户业务类UserSerivceImpl删除一个用户时，需要发布事件，所以要先定义一个UserDeleteEvent事件类

Java代码 复制代码
  1. import com.esc.permission.model.User;   
  2.   
  3. public class UserDeleteEvent extends BaseEvent {   
  4.        
  5.     public UserDeleteEvent(User user){   
  6.         super(user);   
  7.     }   
  8.        
  9.     public User getUser(){   
  10.         return (User) super.getSource();   
  11.     }   
  12.   
  13. }  
import com.esc.permission.model.User;

public class UserDeleteEvent extends BaseEvent {
	
	public UserDeleteEvent(User user){
		super(user);
	}
	
	public User getUser(){
		return (User) super.getSource();
	}

}


下面是UserSerivceImpl类删除用户的方法模拟

Java代码 复制代码
  1. public void deleteUser(String id){   
  2.     //先发布删除事件   
  3.     publishEvent(new UserDeleteEvent(new User(id)));   
  4.     //再把用户删除   
  5.     userDao.deleteUser(id);   
  6. }  
public void deleteUser(String id){
    //先发布删除事件
    publishEvent(new UserDeleteEvent(new User(id)));
    //再把用户删除
    userDao.deleteUser(id);
}


假如有一个OtherServiceImpl业务类需要接收用户删除事件并做一些处理，

Java代码 复制代码
  1. public class OtherServiceImpl extends AbstractBaseService {   
  2.     private IBaseDAO otherDao;   
  3.   
  4.     /**  
  5.      * 重写父类的方法，处理用户删除事件  
  6.      */  
  7.     protected void onBaseEvent(BaseEvent baseEvent){   
  8.         if(baseEvent instanceof UserDeleteEvent){//如果是用户删除事件   
  9.             otherDao.deleteOtherData(((User)baseEvent.getSource()).getId());   
  10.         }   
  11.     }   
  12. }  
public class OtherServiceImpl extends AbstractBaseService {
	private IBaseDAO otherDao;

	/**
	 * 重写父类的方法，处理用户删除事件
	 */
	protected void onBaseEvent(BaseEvent baseEvent){
		if(baseEvent instanceof UserDeleteEvent){//如果是用户删除事件
			otherDao.deleteOtherData(((User)baseEvent.getSource()).getId());
		}
	}
}


    到此，所有逻辑就完了，用户业务类中根本不需要知道谁将会处理此事件，所以完全与其它模块解偶了。
    这里用了一个偷懒的方法，那就是在业务类的顶层接口IBaseService中实现了ApplicationListener接口，这样其实所有具体业务类都参与了所有事件的处理，即使是那些根本不需要监听事件的业务类。对于所有根本不需要监听事件的业务类，事件发生时就调用其父类空方法onBaseEvent，这里有一点性能浪费，如果改进？不要在顶层接口IBaseService中实现ApplicationListener接口，而是在具体的需要监听事件的业务类中实现此接口，但是这样还是有一点缺陷，那就是此具体业务类还是会监听到它不关心的事件，不论是用户删除事件还是用户修改事件，没办法，有得必有失，想要方便，肯定会有所牺牲。

    如果只想监听到自已所关心的事件呢，那么就要自已实现一套事件处理的小框架了：

    2、自定义的事件监听与处理框架。
    首先重新定义事件监听器接口，不再使用SPRING提供的ApplicationListener接口：

Java代码 复制代码
  1. import java.util.List;   
  2.   
  3. /**  
  4.  * 事件处理接口，实现此接口并且getEventClasses方法的返回结果条数大于0，方可处理对应的事件  
  5.  */  
  6. public interface IBaseEventListener {   
  7.     /**  
  8.      * 事件处理的方法  
  9.      */  
  10.     public void onBaseEvent(BaseEvent event);   
  11.        
  12.     /**  
  13.      * 所要处理的事件类型  
  14.      */  
  15.     public List<Class<? extends BaseEvent>> getEventClasses();   
  16. }  
import java.util.List;

/**
 * 事件处理接口，实现此接口并且getEventClasses方法的返回结果条数大于0，方可处理对应的事件
 */
public interface IBaseEventListener {
	/**
	 * 事件处理的方法
	 */
	public void onBaseEvent(BaseEvent event);
	
	/**
	 * 所要处理的事件类型
	 */
	public List<Class<? extends BaseEvent>> getEventClasses();
}


    这个接口比SPRING的事件接口多了一个方法。因为SPRING原来做法是只要实现了它提供的接口，任何事件发生时都会得到调用，这种做法是很方便使用的，这里沿用了这种思路。多出的那个方法作用是描述本类处理哪些事件。这时我需要一个类，这个类要在系统启动时把所有实现此接口的业务类找出来，归好类，以便事件发生时进行精确调用，并且提供事件发布事件的静态方法，这样我们才能知道事件在何时发生了。好，下面就来编写这个类

Java代码 复制代码
  1.   
  2. /**  
  3.  * 事件处理相关操作工具类  
  4.  */  
  5. public class EventController {   
  6.     /** KEY：事件类的类名，值：所有监听此事件的处理类实例  */  
  7.     private static Map<String,List<IBaseEventListener>> listeners = new LinkedHashMap<String, List<IBaseEventListener>>();   
  8.        
  9.     private EventController(){   
  10.         //no instance   
  11.     }   
  12.        
  13.     /**  
  14.      * 扫瞄所有bean,进行事件监听（业务类按事件类型归类），此方法要在系统启动完后立即调用  
  15.      * 此方法大概过程是  
  16.      * 1、从SPRING中找出所实现了IBaseEventListener的具体业务类实例  
  17.      * 2、把这些实例归类装进MAP变量listeners中，此MAP变量的结构是：  
  18.      * "UserDeleteEvent.class",{ortherServiceImpl,xxxServiceImpl,...}  
  19.      * "UserUpdateEvent.class",{yyyServiceImpl,zzzServiceImpl,...}  
  20.      * key,valueList  
  21.      */  
  22.     public static void initBaseEventListener(){   
  23.         //从SPRING中得到实现了某接口的业务类   
  24.         Map<String,IBaseEventListener> beans = ContextLoader.getCurrentWebApplicationContext().getBeansOfType(IBaseEventListener.class);   
  25.         if(beans==null || beans.size()==0)   
  26.             return;   
  27.         //下面循环进行归类   
  28.         Collection<IBaseEventListener> services = beans.values();   
  29.         for (IBaseEventListener service : services) {   
  30.             List<Class<? extends BaseEvent>> eventClasses = service.getEventClasses();   
  31.             if(eventClasses==null || eventClasses.size()==0)   
  32.                 continue;   
  33.                
  34.             for (int i = 0; i < eventClasses.size(); i++) {   
  35.                 List<IBaseEventListener> list = listeners.get(eventClasses.get(i).getName());   
  36.                 if(list==null){   
  37.                     list = new ArrayList<IBaseEventListener>();   
  38.                     listeners.put(eventClasses.get(i).getName(), list);   
  39.                     list.add(service);   
  40.                 }else{   
  41.                     if(list.contains(service)){   
  42.                         continue;   
  43.                     }else{   
  44.                         list.add(service);   
  45.                     }   
  46.                 }   
  47.             }   
  48.         }   
  49.     }   
  50.        
  51.     /**  
  52.      * 发布事件的静态方法  
  53.      */  
  54.     public static void publishEvent(BaseEvent event){   
  55.         //根据实际事件名称，从listeners中找出监听了此事件的业务类，调用之   
  56.         List<IBaseEventListener> list = listeners.get(event.getClass().getName());   
  57.         if(list!=null && list.size()>0){   
  58.             for (IBaseEventListener listener : list) {   
  59.                 //此处不能捕捉异常，因为任何一个处理类实例出错都应该全部回滚   
  60.                 listener.onBaseEvent(event);   
  61.             }   
  62.         }   
  63.     }   
  64. }  
/**
 * 事件处理相关操作工具类
 */
public class EventController {
	/** KEY：事件类的类名，值：所有监听此事件的处理类实例  */
	private static Map<String,List<IBaseEventListener>> listeners = new LinkedHashMap<String, List<IBaseEventListener>>();
	
	private EventController(){
		//no instance
	}
	
	/**
	 * 扫瞄所有bean,进行事件监听（业务类按事件类型归类），此方法要在系统启动完后立即调用
	 * 此方法大概过程是
	 * 1、从SPRING中找出所实现了IBaseEventListener的具体业务类实例
	 * 2、把这些实例归类装进MAP变量listeners中，此MAP变量的结构是：
	 * "UserDeleteEvent.class",{ortherServiceImpl,xxxServiceImpl,...}
	 * "UserUpdateEvent.class",{yyyServiceImpl,zzzServiceImpl,...}
	 * key,valueList
	 */
	public static void initBaseEventListener(){
		//从SPRING中得到实现了某接口的业务类
		Map<String,IBaseEventListener> beans = ContextLoader.getCurrentWebApplicationContext().getBeansOfType(IBaseEventListener.class);
		if(beans==null || beans.size()==0)
			return;
		//下面循环进行归类
		Collection<IBaseEventListener> services = beans.values();
		for (IBaseEventListener service : services) {
			List<Class<? extends BaseEvent>> eventClasses = service.getEventClasses();
			if(eventClasses==null || eventClasses.size()==0)
				continue;
			
			for (int i = 0; i < eventClasses.size(); i++) {
				List<IBaseEventListener> list = listeners.get(eventClasses.get(i).getName());
				if(list==null){
					list = new ArrayList<IBaseEventListener>();
					listeners.put(eventClasses.get(i).getName(), list);
					list.add(service);
				}else{
					if(list.contains(service)){
						continue;
					}else{
						list.add(service);
					}
				}
			}
		}
	}
	
	/**
	 * 发布事件的静态方法
	 */
	public static void publishEvent(BaseEvent event){
		//根据实际事件名称，从listeners中找出监听了此事件的业务类，调用之
		List<IBaseEventListener> list = listeners.get(event.getClass().getName());
		if(list!=null && list.size()>0){
			for (IBaseEventListener listener : list) {
				//此处不能捕捉异常，因为任何一个处理类实例出错都应该全部回滚
				listener.onBaseEvent(event);
			}
		}
	}
}


    接着重新定义事件类本身，此类也不再继承SPRING的ApplicationEvent类，其它基本还和原来一样。

Java代码 复制代码
  1. public class BaseEvent {   
  2.     private Object source;   
  3.     public BaseEvent() {   
  4.     }   
  5.        
  6.     public BaseEvent(Object source) {   
  7.         this.source = source;   
  8.     }   
  9.   
  10.     public Object getSource() {   
  11.         return source;   
  12.     }   
  13. }  
public class BaseEvent {
	private Object source;
	public BaseEvent() {
	}
	
	public BaseEvent(Object source) {
		this.source = source;
	}

	public Object getSource() {
		return source;
	}
}



业务类顶层接改而继承自已的事件接口

Java代码 复制代码
  1. /**    
  2.  * 业务层顶层接口    
  3.  */     
  4. public interface IBaseService extends IBaseEventListener{      
  5.      
  6. }   
/**  
 * 业务层顶层接口  
 */  
public interface IBaseService extends IBaseEventListener{   
  
}



在SERVICE的抽象类中去掉onApplicationEvent方法，不需要了，改写发布事件的方法，修改后变成这样

Java代码 复制代码
  1. import org.springframework.context.ApplicationEvent;   
  2.   
  3. /**  
  4.  * 实现顶层接口的抽象类  
  5.  */  
  6. public abstract class AbstractBaseService implements IBaseService {   
  7.          /**  
  8.      * 发布事件  
  9.      */  
  10.     protected final void publishEvent(BaseEvent event) {   
  11.         //使用自已事件工具类发布事件   
  12.         EventController.publishEvent(event);   
  13.     }   
  14.   
  15.          /**    
  16.           * 默认实现处理事件的方法   
  17.             */     
  18.          public void onBaseEvent(BaseEvent event) {      
  19.          }   
  20.   
  21.          /**  
  22.      * 注意虽然也是在顶层接口中都实现了事件监听，但是只有这个方法有返回值时，才真正的会被调用  
  23.      */  
  24.     public List<Class<? extends BaseEvent>> getEventClasses(){   
  25.                    return null;   
  26.          }   
  27.   
  28. }  
import org.springframework.context.ApplicationEvent;

/**
 * 实现顶层接口的抽象类
 */
public abstract class AbstractBaseService implements IBaseService {
         /**
	 * 发布事件
	 */
	protected final void publishEvent(BaseEvent event) {
		//使用自已事件工具类发布事件
		EventController.publishEvent(event);
	}

         /**  
          * 默认实现处理事件的方法 
            */  
         public void onBaseEvent(BaseEvent event) {   
         }

         /**
	 * 注意虽然也是在顶层接口中都实现了事件监听，但是只有这个方法有返回值时，才真正的会被调用
	 */
	public List<Class<? extends BaseEvent>> getEventClasses(){
                   return null;
         }

}


    到此框架就完成了，UserServiceImpl删除用户时发布事件的代码还和原来一样，不需要改变，只是监听类要变一下，不再实现ApplicationListener接口，改而实现IBaseEventListener接口，不过不需要再具体类中实现，因为已经在顶层接口中继承了，代码

Java代码 复制代码
  1. public class OtherServiceImpl extends AbstractBaseService {   
  2.     private IBaseDAO otherDao;   
  3.   
  4.     /**  
  5.      * 重写父类的方法，处理用户删除事件  
  6.      */  
  7.     protected void onBaseEvent(BaseEvent baseEvent){   
  8.                   //如果本类只处理一个事件，这里就不需要再类型判断了   
  9.                   UserDeleteEvent event = (UserDeleteEvent)baseEvent;   
  10.         otherDao.deleteOtherData(event.getSource().getId());   
  11.     }   
  12.             
  13.          /**  
  14.      * 返回本类所要处理所有事件  
  15.      */  
  16.     public List<Class<? extends BaseEvent>> getEventClasses() {   
  17.         List<Class<? extends BaseEvent>> eventClasses = new ArrayList<Class<? extends BaseEvent>>(1);   
  18.         //本类只监听用户删除事件   
  19.         eventClasses.add(UserDeleteEvent.class);   
  20.         return eventClasses;   
  21.     }   
  22. }  
  23. 3、注解版实现：
    1、定义注解类
    Java代码 复制代码
    1. import java.lang.annotation.ElementType;   
    2. import java.lang.annotation.Retention;   
    3. import java.lang.annotation.RetentionPolicy;   
    4. import java.lang.annotation.Target;   
    5.   
    6. @Target(ElementType.METHOD)       
    7. @Retention(RetentionPolicy.RUNTIME)   
    8. public @interface HandleEvent {   
    9.     Class<? extends BaseEvent>[] events();   
    10. }  
    import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.METHOD)    
@Retention(RetentionPolicy.RUNTIME)
public @interface HandleEvent {
	Class<? extends BaseEvent>[] events();
}


    2、在顶层接口IBaseService增加一个方法getRealClass，此方法用于返回真正的业务类字节码引用，此方法在抽象业务类用统一实现即可。本来不需要此方法，但由于使用了SPRING的AOP，一时没有找到取得真正业务类字节码引用的方法，所以才定义这么个接口，代码
    Java代码 复制代码
    1. /**  
    2.  * 业务层顶层接口，自定义的小框架里可以在顶层业务接口中直接继承事件接口，不影响性能  
    3.  * 因为在初始化事件监听器时，已经过滤了没有真正实现接口方法的类，所以不会造成多余的调用  
    4.  */  
    5. public interface IBaseService extends IBaseEventListener{   
    6.     public Class<? extends IBaseService> getRealClass();   
    7. }  
    /**
 * 业务层顶层接口，自定义的小框架里可以在顶层业务接口中直接继承事件接口，不影响性能
 * 因为在初始化事件监听器时，已经过滤了没有真正实现接口方法的类，所以不会造成多余的调用
 */
public interface IBaseService extends IBaseEventListener{
	public Class<? extends IBaseService> getRealClass();
}

    抽象业务类的代码
    Java代码 复制代码
    1. /**  
    2.  * 实现顶层接口的抽象类  
    3.  */  
    4. public abstract class AbstractBaseService implements IBaseService{   
    5.     /**  
    6.      * 发布事件 2008-9-18  
    7.      */  
    8.     protected void publishEvent(BaseEvent event) {   
    9.         EventController.publishEvent2(event);   
    10.     }   
    11.     //具体子类中不需要再实现   
    12.     public Class<? extends IBaseService> getRealClass(){   
    13.         return this.getClass();   
    14.     }   
    15.        
    16.     public void onBaseEvent(BaseEvent event){   
    17.         //这里空实现，且没有注解，这样，如果具体业务类没有重写方法，   
    18.         //初始化事件监听器时就会被过滤掉，不会造成多余调用   
    19.     }   
    20. }  
    /**
 * 实现顶层接口的抽象类
 */
public abstract class AbstractBaseService implements IBaseService{
	/**
	 * 发布事件 2008-9-18
	 */
	protected void publishEvent(BaseEvent event) {
		EventController.publishEvent2(event);
	}
	//具体子类中不需要再实现
	public Class<? extends IBaseService> getRealClass(){
		return this.getClass();
	}
	
	public void onBaseEvent(BaseEvent event){
		//这里空实现，且没有注解，这样，如果具体业务类没有重写方法，
		//初始化事件监听器时就会被过滤掉，不会造成多余调用
	}
}


    改写IBaseEventListener接口，删除getEventClasses方法，因为使用注解来定义要处理事件，所以此方法不再需要。本来onBaseEvent方法也可以去除，直接由注解来定义即可，但由于以下原因，还是要保留：1、如果没有任何接口定义onBaseEvent方法，那么SPRING的代理类也不会有此方法，这样就无法使用AOP的种种好处了；2、为规范事件处理的方法名和参数，更易于后续维护，所以还是要有个接口定义为好。
    Java代码 复制代码
    1. /**  
    2.  * 事件处理接口，实现此接口并且getEventClasses方法的返回结果条数大于0，方可处理对应的事件  
    3.  */  
    4. public interface IBaseEventListener {   
    5.     /**  
    6.      * 事件处理的方法  
    7.      */  
    8.     public void onBaseEvent(BaseEvent event);   
    9. }  
    /**
 * 事件处理接口，实现此接口并且getEventClasses方法的返回结果条数大于0，方可处理对应的事件
 */
public interface IBaseEventListener {
	/**
	 * 事件处理的方法
	 */
	public void onBaseEvent(BaseEvent event);
}


    事件处理工具类
    Java代码 复制代码
    1. /**  
    2.  * 事件处理相关操作工具类  
    3.  */  
    4. public class EventController {   
    5.     private static Map<String,List<LisenerInfo>> listeners2 = new LinkedHashMap<String, List<LisenerInfo>>();   
    6.     /**  
    7.      * 扫瞄所有bean,进行事件监听  
    8.      */  
    9.     public static void initBaseEventListener2(){   
    10.         //取得所有业务类   
    11.         Map<String,IBaseService> beans = SysContext.getBeansOfType(IBaseService.class);   
    12.         if(beans==null || beans.size()==0)   
    13.             return;   
    14.         Collection<IBaseService> values = beans.values();   
    15.         for (IBaseService listener : values) {   
    16.             //注意这里不能使用listener.getClass()方法，因此方法返回的只是SPRING的代理类，此代理类的方法没有注解信息   
    17.             Method[] methods = listener.getRealClass().getDeclaredMethods();   
    18.             for (Method method : methods) {   
    19.                  //判断方法中是否有指定注解类型的注解      
    20.                 boolean hasAnnotation = method.isAnnotationPresent(HandleEvent.class);       
    21.                 if (hasAnnotation) {   
    22.                     //根据注解类型返回方法的指定类型注解      
    23.                     HandleEvent annotation = method.getAnnotation(HandleEvent.class);       
    24.                     Class<? extends BaseEvent>[] events = annotation.events();   
    25.                     if(events==null || events.length==0){//这里过滤掉没有真正实现事件监听的业务类   
    26.                         continue;   
    27.                     }   
    28.                     for (int i = 0; i < events.length; i++) {   
    29.                         try {   
    30.                             if(listeners2.containsKey(events[i].getName())){   
    31.                                 //注意这里要用代理类的方法，即listener.getClass().getMethod(method.getName())，不能直接使用method变量，下同   
    32.                                 listeners2.get(events[i].getName()).add(new LisenerInfo(listener,listener.getClass().getMethod(method.getName())));   
    33.                             }else{   
    34.                                 listeners2.put(events[i].getName(),Arrays.asList(new LisenerInfo[]{new LisenerInfo(listener,listener.getClass().getMethod(method.getName()))}));   
    35.                             }   
    36.                         } catch (Exception e) {   
    37.                             throw new UnknowException("初始化事件监听器时出错：",e);   
    38.                         }   
    39.                     }   
    40.                 }   
    41.             }   
    42.         }   
    43.     }   
    44.     /**  
    45.      * 发布事件  
    46.      */  
    47.     public static void publishEvent2(BaseEvent event){   
    48.         List<LisenerInfo> list = listeners2.get(event.getClass().getName());   
    49.         if(list!=null && list.size()>0){   
    50.             for (LisenerInfo listener : list) {   
    51.                 try {   
    52.                     listener.getMethod().invoke(listener.getService(), event);   
    53.                 } catch (Exception e) {   
    54.                     //此处不能捕捉异常，因为任何一个处理类实例出错都应该全部回滚   
    55.                     throw new UnknowException(e);   
    56.                 }    
    57.             }   
    58.         }   
    59.     }   
    60. }   
    61.   
    62. //此类记录目标方法和目标类   
    63. class LisenerInfo{   
    64.     private Method method;//目标方法   
    65.     private Object service;//业务类实例   
    66.     public LisenerInfo(Object service,Method method){   
    67.         this.method = method;   
    68.         this.service = service;   
    69.     }   
    70.     public Method getMethod() {   
    71.         return method;   
    72.     }   
    73.     public Object getService() {   
    74.         return service;   
    75.     }   
    76. }  
    /**
 * 事件处理相关操作工具类
 */
public class EventController {
	private static Map<String,List<LisenerInfo>> listeners2 = new LinkedHashMap<String, List<LisenerInfo>>();
	/**
	 * 扫瞄所有bean,进行事件监听
	 */
	public static void initBaseEventListener2(){
		//取得所有业务类
		Map<String,IBaseService> beans = SysContext.getBeansOfType(IBaseService.class);
		if(beans==null || beans.size()==0)
			return;
		Collection<IBaseService> values = beans.values();
		for (IBaseService listener : values) {
			//注意这里不能使用listener.getClass()方法，因此方法返回的只是SPRING的代理类，此代理类的方法没有注解信息
			Method[] methods = listener.getRealClass().getDeclaredMethods();
	        for (Method method : methods) {
	             //判断方法中是否有指定注解类型的注解   
	            boolean hasAnnotation = method.isAnnotationPresent(HandleEvent.class);    
	            if (hasAnnotation) {
	                //根据注解类型返回方法的指定类型注解   
	            	HandleEvent annotation = method.getAnnotation(HandleEvent.class);    
	            	Class<? extends BaseEvent>[] events = annotation.events();
	            	if(events==null || events.length==0){//这里过滤掉没有真正实现事件监听的业务类
	            		continue;
	            	}
	            	for (int i = 0; i < events.length; i++) {
	            		try {
		            		if(listeners2.containsKey(events[i].getName())){
		            			//注意这里要用代理类的方法，即listener.getClass().getMethod(method.getName())，不能直接使用method变量，下同
								listeners2.get(events[i].getName()).add(new LisenerInfo(listener,listener.getClass().getMethod(method.getName())));
		            		}else{
		            			listeners2.put(events[i].getName(),Arrays.asList(new LisenerInfo[]{new LisenerInfo(listener,listener.getClass().getMethod(method.getName()))}));
		            		}
	            		} catch (Exception e) {
							throw new UnknowException("初始化事件监听器时出错：",e);
						}
					}
	            }
			}
		}
	}
	/**
	 * 发布事件
	 */
	public static void publishEvent2(BaseEvent event){
		List<LisenerInfo> list = listeners2.get(event.getClass().getName());
		if(list!=null && list.size()>0){
			for (LisenerInfo listener : list) {
				try {
					listener.getMethod().invoke(listener.getService(), event);
				} catch (Exception e) {
					//此处不能捕捉异常，因为任何一个处理类实例出错都应该全部回滚
					throw new UnknowException(e);
				} 
			}
		}
	}
}

//此类记录目标方法和目标类
class LisenerInfo{
	private Method method;//目标方法
	private Object service;//业务类实例
	public LisenerInfo(Object service,Method method){
		this.method = method;
		this.service = service;
	}
	public Method getMethod() {
		return method;
	}
	public Object getService() {
		return service;
	}
}


    好了，框架完成，事件发布还和以前那样，来看看事件处理的实现，同样也不再需要getEventClasses方法了
    Java代码 复制代码
    1. //不再需要每个具体业务都实现IBaseEventListener接口   
    2. public class OtherServiceImpl extends AbstractBaseService implements OtherService{      
    3.     private IBaseDAO otherDao;      
    4.      
    5.     /**    
    6.      * 重写父类的方法，处理用户删除事件    
    7.      */  
    8.     @HandleEvent(events={UserDeleteEvent.class,UserUpdateEvent.class})   
    9.     public void onBaseEvent(BaseEvent baseEvent){      
    10.         if(baseEvent instanceof UserDeleteEvent){//如果是用户删除事件      
    11.             otherDao.deleteOtherData(((User)baseEvent.getSource()).getId());      
    12.         }else{   
    13.             //....   
    14.         }   
    15.     }      
    16. }    
    //不再需要每个具体业务都实现IBaseEventListener接口
public class OtherServiceImpl extends AbstractBaseService implements OtherService{   
    private IBaseDAO otherDao;   
  
    /**  
     * 重写父类的方法，处理用户删除事件  
     */
    @HandleEvent(events={UserDeleteEvent.class,UserUpdateEvent.class})
    public void onBaseEvent(BaseEvent baseEvent){   
        if(baseEvent instanceof UserDeleteEvent){//如果是用户删除事件   
            otherDao.deleteOtherData(((User)baseEvent.getSource()).getId());   
        }else{
        	//....
        }
    }   
}

框架之—监听器
PengXujing的博客
08-17 246
文章目录一、什么是监听器二、监听器的作用三、监听机制相关概念四、javaweb监听器介绍五、javaweb监听器创建步骤六、监听对象创建与销毁 一、什么是监听器 Javaweb中的监听器（Listener）是用于监听web常见对象HttpServletRequest、HttpSession、ServletContext 二、监听器的作用 监听web对象创建与销毁. 监听web对象的属性变化 监听...
事件处理框架
Bboss 每天进步一点点
05-18 561
概述 事件处理框架为系统中事件的管理提供了一个简单而灵活的框架，提供本地事件和远程事件的处理功能。 事件处理框架的主要组件和描述见如下的uml图：    l         事件激发器是指产生各种类型事件的组件 l         事件消息是指包含事件源信息、事件类型、事件广播类型信息的组件 l         事件类型是指每个事件消息特定的消息类型比如安全数据变化事件，字典数据变...
事件监听处理
qq_17190231的博客
05-23 351
监听事件处理vm数据 <body> <div id="app"> <button @click="count++">点击</button> {{count}} </div> <script> new Vue({ el: '#app', data: { ...
Layui事件监听的实现(表单和数据表格)
10-16
Layui是一款轻量级的前端框架，它提供了丰富的组件和便利的API，其中事件监听是其核心功能之一，特别在处理表单和数据表格时显得尤为重要。本文将深入讲解Layui中事件监听的实现，主要关注表单和数据表格。 **一、...
javascript在事件监听方面的兼容性小结
10-29
然而，由于不同浏览器厂商对事件监听机制的实现各不相同，导致了在编写JavaScript代码时需要对不同浏览器的兼容性问题进行处理。本文将总结JavaScript在事件监听方面的兼容性问题，以及不同浏览器之间的差异和如何...
vue各种事件监听实例(小结)
10-15
本小结将详细介绍Vue中各种事件监听实例，涵盖计算属性对象的使用、方法与计算属性的对比、v-on指令的使用、以及传参在事件监听中的应用等多个知识点。 首先，我们来看计算属性的使用。在Vue中，计算属性对象允许...
SpringMVC事件监听ApplicationListener实例解析
08-25
SpringMVC框架中提供了事件监听机制，允许开发者监听框架中的各种事件，从而可以在事件发生时执行自定义的业务逻辑。其中，ApplicationListener就是SpringMVC框架中的一种事件监听器，允许开发者监听框架中的各种...
Qt全局鼠标、键盘事件监听器库
12-10
这个库基于流行的Qt框架，为开发者提供了一个便捷的方式来监听并处理系统的输入事件，无论是来自应用程序内部还是外部。 在Qt中，通常我们可以通过继承`QWidget`类并重写其`mouseMoveEvent`、`mousePressEvent`、`...
Java事件处理框架
09-15
Java GUI事件处理框架,可以使得GUI开发像网站开发一样高可维护性,低耦合性
一个简单网络监听框架
01-10
一个简单的Android网络监听demo，通过基类的方式，使用广播实现
GraphicsView框架事件处理
08-19
图形视图框架中的事件都是首先由视图进行接收，然后传递给场景，再由场景给相应的图形项。
高性能高并发事件处理框架Libevnt
05-18
高性能事件处理框架，用于高性能网络，高性能KEY－VALUE缓存系统
事件处理框架-event_base
hello_bravo_的博客
09-25 605
分析libevent的事件处理框架event_base和libevent注册,删除事件的具体流程，这就表现为event_base结构体.由于源代码的event_base定义的变量太多就先放上书中精简过的有价值的struct event_base{ const struct eventop* evsel; void* evbase; int event_count; int event_gotterm
libevent事件处理框架：event_base
shayne000的博客
07-14 486
回想Reactor 模式的几个基本组件， 本节讲解的部分对应于Reactor 框架组件。在libevent中，Reactor 框架组件表现为event_base结构体，结构体声明如下，它位于event-internal.h 文件中： struct event_base { const struct eventop * evsel ; void * evbase; int event_count ;...
自己做的事件监听处理小框架
业精于勤荒于嬉;行成于思，毁于随。
09-14 327
基于SPRING的事件处理其实很简单，初学者不必一开始就担心搞不懂，本文先是介绍完全基于SPRING的事件监听实现(熟识Spring事件监听的朋友应该跳过第一节)，然后依葫芦画瓢自已做一个性能更好事件监听小框架，最后在回贴中加入了注解版。      为何要使用事件监听，而不是直接调用？打个比方，在系统删除一个用户时，需要把用户的其他信息和行为记录一起删除，此时最容易想到的是：删除用户时，调用其他
MUSignal - 最简洁易用的事件处理框架
Jekity的博客
10-22 418
添加事件还在用(addGestureRecognizer:/addTarget:action:forControlEvents:))或者使用其它第三方的block回调？一个Click_MUSignal(#需要响应事件的控件名称){//相应的业务代码}就能搞定!!!!!! # 传统事件存在的问题 1.反复书写添加事件代码(addGestureRecognizer:/addTarget:action:...
listener监听器框架
最新发布
weixin_62108279的博客
04-16 642
监听器是Web开发中常用的一种组件，用于监听某些事件并根据事件触发相应的处理逻辑。在Spring Boot中使用监听器可以方便地实现对程序中各种事件的监听，比如启动事件、关闭事件等。在上面的示例中，我们通过重写onApplicationEvent方法来监听应用程序中的各种事件，并根据不同的事件类型执行相应的处理逻辑。在上面的配置中，order指定了监听器的执行顺序，值越小优先级越高，classes指定了要启用的监听器的类名。// 应用程序启动时执行的逻辑。// 应用程序关闭时执行的逻辑。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值