spring基本使用(9)-Spring的ApplicationEvent事件体系

1、Spring的ApplicationEvent：事件
   ApplicationEvent：应用事件，职责为定义业务。
   类图：
           
   Spring 提供了一个继承于java.util.EventObject 类的ApplicationEvent的的抽象类，
   并提供了应用上线文事件的抽象实现ApplicationContextEvent 下面的容器关闭、刷新、
   启动、停止等容器事件 以及RequestHandledEvent(http 请求处理完成事件)，可自定义
   事件（只需要实现ApplicationEvent 抽象类定义有参构造函数即可，source表示事件源，
   可按照自己的需求制定），如下：

   public class MyEvent2 extends ApplicationEvent {
     public MyEvent2(Object source) {
         super(source);
     }
   }

2、Spring的ApplicationListener：事件监听器
   ApplicationListener：事件监听器,职责为处理事件广播器发布的事件。
   类图：
         
   Spring提供了继承于java.util.EventListener接口的应用监听器接口，  ApplicationListener，此接口源码：

   public interface ApplicationListener extends EventListener {
     void onApplicationEvent(E var1);
   }

   并提供了两个实现：
      SmartApplicationListener(接口)、GenericApplicationListener（接口）。

   2.1、SmartApplicationListener
        提供了监听器对泛型事件的支持，spring3.0 添加的。
        源码如下:

         public interface SmartApplicationListener extends ApplicationListener, Ordered {
            boolean supportsEventType(Class var1);
            boolean supportsSourceType(Class var1);
         }

          supportsEventType() 方法：指定监听器处理的事件类型。
          supportsSourceType()方法：指定监听器仅对何种事件源做出相应。

   2.2、GenericApplicationListener
        增强对泛型事件的支持（支持泛型方式不同与SmartApplicationListener）,spring4.2 添加的。
        源码如下：

      public interface GenericApplicationListener extends ApplicationListener, Ordered {
            boolean supportsEventType(ResolvableType var1);
            boolean supportsSourceType(Class var1);
      }

          supportsEventType() 方法：采用可解析的类型ResolvableType 来控制监听器处理的事件类型，ResolvableType 是spring4.0提供的一个更加简单易用的泛型处理类。
          supportsSourceType()方法：指定监听器仅对何种事件源做出相应。

3、ApplicationEventMulticaster：事件广播器
   事件广播器，职责为将EventPubsher(事件发布者)发布的event 广播给事件EventListener(事件监听器)。
   类图：
            
   Spring提供了默认的实现SimpleApplicationEventMulticaster，如果用户没有配置自定义事件广播器，
   则会默认使用SimpleApplicationEventMulticaster作为事件广播器。在容器刷新的过程中会实例化、初始化事件广播器

4、ApplicationEventPublisher：事件发布器
   事件发布者，职责为发布事件。
   spring的ApplicationContext 本来就实现了ApplicationEventPublisher接口，因此应用上下文本来就是
   一个事件发布者，在AbstractApplicationContext中实现了事件发布的业务。

   我们如何发布事件呢？
     方式一：直接使用应用上下文发布：

        applicationContext.publishEvent();

     方式二：直接注入ApplicationEventPublisher:

        @Autowired
        private ApplicationEventPublisher applicationEventPublisher;
 
        使用：applicationEventPublisher.publishEvent(myEvent);

 

     方式三：使用ApplicationEventPublisherAware：
             使用如下：
             

        public class MyEventPubsher implements ApplicationEventPublisherAware {
            public static ApplicationEventPublisher eventPublisher = null;
                 
            @Override
            public void setApplicationEventPublisher(ApplicationEventPublisher applicationEventPublisher) {
                this.eventPublisher = applicationEventPublisher;
            }

            public void pubshEvent(MyEvent event){
                eventPublisher.publishEvent(event);
            }
        }

10.5、容器事件使用案例

    案例1：使用ApplicationContext 发布自定义事件 ：

public class MyEvent extends ApplicationEvent {
    public MyEvent(Object source) {
        super(source);
    }
}

@Component
public class MyEventListener implements ApplicationListener {
    public void onApplicationEvent(MyEvent myEvent) {
        System.out.println(myEvent.getSource().toString());
    }
}

测试代码: 
  ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-context.xml");
  applicationContext.publishEvent(new MyEvent("event1"));

 

    案例2：使用ApplicationEventPublisher 发布自定义事件:

public class MyEvent extends ApplicationEvent {
    public MyEvent(Object source) {
        super(source);
    }
}

@Component
public class MyEventListener implements ApplicationListener {
    public void onApplicationEvent(MyEvent myEvent) {
        System.out.println(myEvent.getSource().toString());
    }
}

@Component
public class MyEventPubsher1 {

    @Autowired
    private ApplicationEventPublisher applicationEventPublisher;

    public void pushMyEvent(String source){
        MyEvent myEvent = new MyEvent(source);
        applicationEventPublisher.publishEvent(myEvent);
    }
}

测试代码：
     ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-context.xml");
     MyEventPubsher1 myEventPubsher1 = applicationContext.getBean(MyEventPubsher1.class);
     myEventPubsher1.pushMyEvent("event1");

 

    案例3：使用GenericApplicationListener监听器:   

public class MyEvent2 extends ApplicationEvent {
    public MyEvent2(Object source) {
        super(source);
    }
}

@Component
public class MyGenericApplicationListener implements GenericApplicationListener {
    public boolean supportsEventType(ResolvableType resolvableType) {
        return MyEvent2.class.isAssignableFrom(resolvableType.getRawClass());
    }

    public boolean supportsSourceType(Class  aClass) {
        return aClass==String.class;
    }

    public void onApplicationEvent(ApplicationEvent applicationEvent) {
        System.out.println(applicationEvent.getSource());
    }

    public int getOrder() {
        return Ordered.LOWEST_PRECEDENCE;
    }
}

@Component
public class MyEventPubsher implements ApplicationEventPublisherAware {

    public static ApplicationEventPublisher eventPublisher = null;

    @Override
    public void setApplicationEventPublisher(ApplicationEventPublisher applicationEventPublisher) {
        this.eventPublisher = applicationEventPublisher;
    }

    public void pubshEvent(MyEvent2 event2){
        eventPublisher.publishEvent(event2);
    }
}

测试代码：
     ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-context.xml");
     MyEventPubsher myEventPubsher = applicationContext.getBean(MyEventPubsher.class);
     myEventPubsher.pubshEvent(new MyEvent2("event2"));