spring之自定义事件及监听

spring的事件及监听和ApplicationContext

  ApplicationContext中的事件处理都是通过applicationEvent类和ApplicationListener接口来实现的。在spring发展历史上从spring4.2开始一直到spring5和springBoot新增了注解实现。所以现在分为编程式实现和注解实现。

老版本xml配置实现事件及监听的实现

       ①自定义事件(继承ApplicationEvent) 

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

    ②监听器类RainListener1和RainListener2

       RainListener1 

public class RainListener1 implements ApplicationListener<MyEvent>{

        @Override
        public void onApplicationEvent(MyEvent event) {
            System.out.println("唐僧大喊：" + event.getSource() + "赶快收衣服喽！");
        }
    }

 RainListener12

public class RainListener2 implements ApplicationListener<MyEvent>{
        public void onApplicationEvent(MyEventevent) {
            System.out.println("我们：" + event.getSource() + "太好了不用上课了！");
        }
    }

③xml配置

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.2.xsd">
<!-- 把监听器注册到spring容器中 -->
<!-- 通过spring容器发布事件后,监听器会调用指定方法进行处理 -->
<bean class="com.lut.eventListener.MyListener2"></bean>
<bean class="com.lut.eventListener.MyListener1"></bean>
</beans>

④main方法实现

String path = "com/lut/eventListener/event.xml";2     ApplicationContext container = 
        new ClassPathXmlApplicationContext(path);
    container.publishEvent(new RainEvent("下雨了！"));

结果(顺序和xml配置顺序相关。)：

我们：下雨了！太好了不用上课了！
唐僧大喊：下雨了！赶快收衣服喽！

springBoot下的实现

  自定义事件

    

package lut.eventlistener;
import org.springframework.context.ApplicationEvent;
public class Myevent extends ApplicationEvent {
    String name ;
    String age;
    public Myevent(Object source,String name,String age) {
        super(source);
        this.age=age;
        this.name=name;
    }
    public Myevent(Object source) {
        super(source);
    }
}

2、监听

   实现1非注解（implements ApplicationListener<Myevent>） 

package lut.eventlistener;

import org.springframework.context.ApplicationListener;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;

@Component
public class ProcessListener implements ApplicationListener<Myevent> {
    @Async
    @Override
    public void onApplicationEvent(Myevent event) {
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("监听到了："+event.getSource()+event.name+"--"+event.age);
    }
}

注解方式

package lut.eventlistener;

import org.springframework.context.event.EventListener;
import org.springframework.stereotype.Component;

@Component
public class AnnListener {
    @EventListener
    public void say(Myevent event){
        System.out.println("注解监听到了："+event.getSource()+event.name+"--"+event.age);
    }
}

3、controller方法

package lut.eventlistener;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class EventController {

    @Autowired
    private ApplicationContext context;
    @RequestMapping("event")
    public String getEvent(){
         context.publishEvent(new Myevent("相遇了","xiaogang","12"));
        System.out.println("controller执行到return了");
        return "hello";
    }
}

结果：

非注解结果

监听到了：相遇了xiaogang--12
controller执行到return了

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

注解结果：2种监听可同时存在注解打印在非注解打印输出之前

注解监听到了：相遇了xiaogang--12（注解式的输出）
监听到了：相遇了xiaogang--12（非注解式的输出）
controller执行到return了

总结：

ApplicationEvent和ApplicationListener抽象类的接口到spring 5 一直未改变。

ApplicationEvent源码：

package org.springframework.context;
import java.util.EventObject;
 * @author Rod Johnson
 * @author Juergen Hoeller
 * @see org.springframework.context.ApplicationListener
 * @see org.springframework.context.event.EventListener
 */
public abstract class ApplicationEvent extends EventObject {
    /** use serialVersionUID from Spring 1.2 for interoperability. */
    private static final long serialVersionUID = 7099057708183571937L;

    /** System time when the event happened. */
    private final long timestamp;
    /**
     * Create a new {@code ApplicationEvent}.
     * @param source the object on which the event initially occurred or with
     * which the event is associated (never {@code null})
     */
    public ApplicationEvent(Object source) {
        super(source);
        this.timestamp = System.currentTimeMillis();
    }

    /**
     * Return the system time in milliseconds when the event occurred.
     */
    public final long getTimestamp() {
        return this.timestamp;
    }

}

ApplicationListener源码：

/*
 * Copyright 2002-2019 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.springframework.context;

import java.util.EventListener;

/**
 * Interface to be implemented by application event listeners.
 *
 * <p>Based on the standard {@code java.util.EventListener} interface
 * for the Observer design pattern.
 *
 * <p>As of Spring 3.0, an {@code ApplicationListener} can generically declare
 * the event type that it is interested in. When registered with a Spring
 * {@code ApplicationContext}, events will be filtered accordingly, with the
 * listener getting invoked for matching event objects only.
 *
 * @author Rod Johnson
 * @author Juergen Hoeller
 * @param <E> the specific {@code ApplicationEvent} subclass to listen to
 * @see org.springframework.context.ApplicationEvent
 * @see org.springframework.context.event.ApplicationEventMulticaster
 * @see org.springframework.context.event.EventListener
 */
@FunctionalInterface
public interface ApplicationListener<E extends ApplicationEvent> extends EventListener {

    /**
     * Handle an application event.
     * @param event the event to respond to
     */
    void onApplicationEvent(E event);

}