Spring监听事件使用

废话前言：

首先说一下我为何使用事件，好比如今建立一个订单可是我建立成功后要给客户发送一条短信和一个邮件提醒，自己没建立订单一系列操做就须要不少时间可是我还要去发送短信和邮件，期间还要调用其它服务来实现耗时比较长达不到客户的满意度，因此使用的方式能够说一下：

1：activeMQ（异步）

2：使用spring事件监听（同步+异步）

下面咱们只说第二种方式

在谈Spring的事件监听以前，让咱们先了解一下Spring容器，什么是ApplicationContext ？

它是Spring的核心，Context咱们一般解释为上下文环境，可是理解成容器会更好些。 

ApplicationContext则是应用的容器。

Spring把Bean（object）放在容器中，须要用就经过get方法取出来。

此接口提供给Spring应用配置的能力，当应用启动时，此接口的实现是只读的，可是若是该实现支持，其内容也是能够从新载入的。

ApplicationContext大概提功能以下能力：

1.获取应用组件的bean工厂方法，此能力继承自 org.springframework.beans.factory.ListableBeanFactory。

2.加载资源文件的能力，此能力继承自 org.springframework.core.io.ResourceLoader

3.发布事件到已注册的监听器，此能力继承自 ApplicationEventPublisher

4.提供国际化的消息访问，此能力继承自 MessageSource

好对ApplicationContext有必定了解以后咱们再来看看Spring提供的事件监听。

为了实现事件监听的能力Spring为咱们提供了两个顶层接口/抽象类

ApplcationEvent:是个抽象类，里面只有一个构造函数和一个长整型的timestamp。咱们自定义的Application event 须要继承这个抽象类.

ApplicationListener:是一个接口，里面只有一个方法onApplicationEvent  ，每个实现改接口的类都要本身实现这个方法。 

 

Spring的事件监听是基于标准的观察者模式的，若是在ApplicationContext部署了一个实现了ApplicationListener的bean，那么当一个ApplicationEvent发布到

ApplicationContext时，这个bean获得通知并做特定的处理。

从上面这段话咱们很容易产生两点思考:1.实现了ApplicationListener的bean如何部署到ApplicationContext  2.一个ApplicationEvent如何发布到ApplicationContext

下面咱们就经过具体的代码来看看这两个问题

废话少说，先看代码！

（同步方式，默认监听当前全部事件spring boot）

第一：先自定义一个MsgEvent,它自己提供一个print()方法:

/**
 * 自定义管理事件
 */
public class MessageEvent extends ApplicationEvent {
   /**
    * 在自定义事件的构造方法中除了第一个source参数，其余参数均可以去自定义
    * 能够根据项目实际状况进行监听传参
    */
   private final String message;//事件交互信息
   private final String JNDI;//过滤指定监听
   private final String desc;//描述可传特殊参数不知足时扩展改为MAP/Object目前没遇到太特殊的
   /*
    * 保存JNDI的信息
    * 用来过滤具体执行的监听方法
    */
   public MessageEvent(Object source,String message,String desc) {
      super(source);
      this.message = message;
      this.JNDI = (String) source;
      this.desc = desc;
   }

   public String getJNDI() {
      return JNDI;
   }

   public String getMessage() {
      return message;
   }

   public String getDesc() {
      return desc;
   }

第二：定义一个监听

/**
 * 测试用自定义监听器,监听事件为MyEvent
 */
@Component
public class MyLisenter implements ApplicationListener<MyEvent> {
    /**
     * 对监听到的事件进行处理
     * @param myEvent
     */
    @Override
    public void onApplicationEvent(MyEvent myEvent) {

        /*
          这里不作处理，只对消息进行透传打印，实际状况，
          能够根据项目进行逻辑进行处理
         */
        myEvent.printMsg(myEvent.getMsg());
        System.out.println("监听到。。。");
    }
}

第三：如今自定义事件和监听器都好了，咱们就来看看第一个问题，监听器如何部署到ApplicationContext，有四种方式能够实现，咱们一个一个看：

 1.应用启动以前调用SpringApplication的addListeners方法将自定义的监听器加入。

2.监听器部署到ApplicationContext，实际上就是将将监听器交给Spring 容器管理，因此最简单的方法只需在自定义的PrintListener上加上@Component注解就好了把上图//事件配置监听注掉就好了这个注解就能够实现。

3.在配置文件中加入context.listener.classes: com.snow.listener.PrintListener

注释掉PrintListener上的@Component注解

源码分析：

Spring内置DelegatingApplicationListener会监听ApplicationEnvironmentPreparedEvent事件（Environment已经准备好可是Context尚未建立事件），

读取Environment中的context.listener.classes属性值（监听器类全路径，多个以逗号隔开）来建立ApplicationListener，详情见以下源码中个人注释。

4.使用@EventListener注解，先看代码,创建一个普通的java类并交给spring容器，其中一个处理event的方法，加上该注解，删掉配置文件中的配置。

好以上四点就回答了咱们开头提出的第一个问题：

实现了ApplicationListener的bean如何部署到ApplicationContext。接下来轮到第二个问题了，

一个ApplicationEvent如何发布到ApplicationContext。咱们仍是来看测试的主代码：

上面的这段代码能够看出ConfigurableApplicationContext具备发布事件的能力，而经过下面的类图咱们知道ConfigurableApplicationContext是

ApplicationContext的子接口，文章开头对ApplicationContext的分析咱们知道ApplicationContext具备发布事件的能力，这项能力是经过继承

ApplicationEventPublisher得到的。

经过以上分析，咱们不难发现，只要咱们在一个普通的java bean注入ApplicationContext的实例，那么这个bean就得到了发布事件的能力。

那么怎样才能在一个普通的bean中注入ApplicationContext的实例呢？看ApplicationContext的源码，源码中有这一段注释：

这段注释大概的意思是ApplicationContext的实例能够探测和唤起AppliationContextAware ,ResourceLoaderAware,ApplicationEventPublisherAware,MessageSourceAware等，

咱们顺势看下AppliationContextAware的代码，以下：

咱们注意到ApplicationContext的事件发布能力是继承自ApplicationEventPublisher,而且ApplicationContextAware中有这样一段注释：

这段注释能够看出，若是仅仅想获取发布事件的能力，只须要实现ApplicationEventPublisherAware就好了。

照着这样的思路代码以下：定义一个事件发布器

测试代码：

（异步方式，可指定监听事件）

第一步：在启动类添加注解@EnableAsync，自定义线程池类

建立一个配置类ExecutorConfig，用来定义如何建立一个ThreadPoolTaskExecutor，要使用@Configuration和@EnableAsync这两个注解，表示这是个配置类，而且是线程池的配置类

以下所示：

/**
 * 链接池配置
 */
@Configuration  
@EnableAsync  
public class TaskExecutePool {
    private static final Logger log = LoggerFactory.getLogger(TaskExecutePool.class);
    @Bean("myTaskAsyncPool")
    public Executor myTaskAsyncPool() {
        log.info("start TaskExecutePool myTaskAsyncPool");
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        //配置核心线程数
        executor.setCorePoolSize(10);
        //配置核心线程数
        executor.setMaxPoolSize(20);
        //配置队列容量
        executor.setQueueCapacity(1000);
        //设置线程活跃时间
        executor.setKeepAliveSeconds(60);
        //设置线程名
        executor.setThreadNamePrefix("myTaskAsyn-");
        //设置拒绝策略
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());  
        executor.initialize();  
        return executor;  
    }  
}

注意，上面的方法名称为asyncServiceExecutor，

@Async("asyncServiceExecutor")：即配置线程池的方法名，此处若是不写自定义线程池的方法名，会使用默认的线程池 

 第二步：自定义事件发布类

/**
 * 自定义管理事件
 */
public class MessageEvent extends ApplicationEvent {
   /**
    * 在自定义事件的构造方法中除了第一个source参数，其余参数均可以去自定义
    * 能够根据项目实际状况进行监听传参
    */
   private final String message;//事件交互信息
   private final String JNDI;//过滤指定监听
   private final String desc;//描述可传特殊参数不知足时扩展改为MAP/Object目前没遇到太特殊的
   /*
    * 保存JNDI的信息
    * 用来过滤具体执行的监听方法
    */
   public MessageEvent(Object source,String message,String desc) {
      super(source);
      this.message = message;
      this.JNDI = (String) source;
      this.desc = desc;
   }

   public String getJNDI() {
      return JNDI;
   }

   public String getMessage() {
      return message;
   }

   public String getDesc() {
      return desc;
   }

第三步：抽取事件发布公共类

/**
 * 事件发布类
 */
@Component
public class EventPublisher implements ApplicationEventPublisherAware {
   private static ApplicationEventPublisher applicationEventPublisher;
   
   @Override
   public void setApplicationEventPublisher(ApplicationEventPublisher applicationEventPublisher) {
      this.applicationEventPublisher = applicationEventPublisher;

   }
    public static void publishEvent(ApplicationEvent applicationEvent) {
       applicationEventPublisher.publishEvent(applicationEvent);
   }

}

第四步：编写监听事件

@EventListener有个参数condition进行event属性过滤。

好比我查的看的有这样的目前没研究太多：

@EventListener

@EventListener(condition = "#event.test == 'foo'")（我使用的这个）

@EventListener({ContextStartedEvent.class, ContextRefreshedEvent.class})

@EventListener(classes = {BlackListEvent.class})

/**
 * 监听事件：送开通
 */
@Component
public class ProvNotifier {

   private static final Logger log = LoggerFactory.getLogger(ProvNotifier.class);

   @Autowired
   private IProvSvc iProvSvc;

   /**
    * 监听送开通的消息
    * @param event
    */
   @Async
   @EventListener( condition= "#event.JNDI == 'sendToProv'")
   public void onApplicationEvent(MessageEvent event) {
      log.info(" ==>异步事件启动 onApplicationEvent sendToProv Message：" + event.getMessage());
      try {
         iProvSvc.sendToProv(event.getMessage(),event.getDesc());
         log.info(" ==>送开通成功！");
      } catch (Exception e) {
         log.error(" %%%%%% onApplicationEvent listener sendToProv：" + e.getMessage());
         e.printStackTrace();
      }
   }
}

 第五步：测试

结果：

这是异步的实现基本结束，也能够根据本身的业务规则实现配置化。

看了不少大神贴也有抄袭多见谅：https://blog.csdn.net/LouisQMei/article/details/79605590

 若是有优化还会更细，也请有好的想法指教指教。