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);

}