Java Spring 自定义事件监听

ApplicationContext 事件

定义一个context的起动监听事件

import org.springframework.context.ApplicationListener;
import org.springframework.context.event.ContextStartedEvent;

public class EventStart implements ApplicationListener<ContextStartedEvent>{

    @Override
    public void onApplicationEvent(ContextStartedEvent arg0) {
        System.out.println("上下文 开始 事件");
    }
}
要定义一个事件监听,首先你得有一个事件,ContextStartedEvent 是一个固定的、具体的事件,Java spring自带的,通过实现
ApplicationListener<ContextStartedEvent >就可以监控这个事件了
ContextStartedEvent 的定义 
@SuppressWarnings("serial")
public class ContextStartedEvent extends ApplicationContextEvent {

    /**
     * Create a new ContextStartedEvent.
     * @param source the {@code ApplicationContext} that has been started
     * (must not be {@code null})
     */
    public ContextStartedEvent(ApplicationContext source) {
        super(source);
    }

}
import org.springframework.context.ApplicationListener;
import org.springframework.context.event.ContextStoppedEvent;

public class EventStop implements ApplicationListener<ContextStoppedEvent> {

    @Override
    public void onApplicationEvent(ContextStoppedEvent arg0) {
        System.out.println("上下文 停止 事件");
    }
}

主方法

        ConfigurableApplicationContext context = new ClassPathXmlApplicationContext("b.xml");
        context.start();

        Dept dept = (Dept)context.getBean("dept");
        dept.getLeader();

        context.stop();
        context.registerShutdownHook();

b.xml

<bean id="eventStart" class="test4.EventStart"></bean>
<bean id="eventStop" class="test4.EventStop"></bean>

输出

初始化 bean.洪七公
初始化 bean.null
家
我
上下文 开始 事件
部门领导洪七公
上下文 停止 事件
销毁 bean.null
销毁 bean.洪七公

为什么主方法中一调用 start 方法,监听事件就可以自己被调用 呢

start方法真正执行的是AbstractApplicationContext的start方法,在方法里,除子真正start要处理的内容外,还额外加了事件处理,

@Override
    public void start() {
        getLifecycleProcessor().start();
        publishEvent(new ContextStartedEvent(this));
    }

所加的事件就是ContextStartedEvent事件,在将实例了ApplicationListener<ContextStartedEvent>的bean通过xml注册到spring容器中时,容器自动调用了该bean的onApplicationEvent方法

自定义事件

public class Person {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}
public class Work extends ApplicationEvent{
    private static final long serialVersionUID = 1L;
    private Person ps;

    public void setPs(Person ps) {
        this.ps = ps;
    }

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

    public void doWorking() {
        String name = this.ps.getName();
        System.out.println(name + " 今天没有完成100张图片制作,并且听到这个任务时,情绪时而激动,时而低落");
    }
}
//该类要注册到spring容器,然后容器会自动调用实现ApplicationListener接口的类的onApplicationEvent方法
public class WorkListener implements ApplicationListener<Work>{

    @Override
    public void onApplicationEvent(Work event) {
        // TODO Auto-generated method stub
        System.out.println("摄像头记录到:");
        event.doWorking();
    }
}
public class Sleep extends ApplicationEvent{

    private Person ps;
    public void setPs(Person ps) {
        this.ps = ps;
    }

    private static final long serialVersionUID = 2L;
    public Sleep(Object source) {
        super(source);
    }

    public void doSleeping() {
        String name = this.ps.getName();
        System.out.println(name + " 开始休息了");
    }
}
//该类要注册到spring容器,然后容器会自动调用实现ApplicationListener接口的类的onApplicationEvent方法
public class SleepListener implements ApplicationListener<Sleep> {

    @Override
    public void onApplicationEvent(Sleep event) {
        System.out.println("摄像头记录到:");
        event.doSleeping();
    }
}
public class Report implements ApplicationEventPublisherAware{
    private ApplicationEventPublisher publisher;

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

    public void work() {
        System.out.println("开始小明的工作报告");
        Work work = new Work(this);
        ConfigurableApplicationContext context = new ClassPathXmlApplicationContext("d.xml");
        Person xm = (Person)context.getBean("xiaoming");
        work.setPs(xm);
        this.publisher.publishEvent(work);
    }

    public void sleep() {
        System.out.println("开始小明的睡眠报告");
        Sleep sl = new Sleep(this);
        ConfigurableApplicationContext context = new ClassPathXmlApplicationContext("d.xml");
        Person xm = (Person)context.getBean("xiaoming");
        sl.setPs(xm);
        this.publisher.publishEvent(sl);
    }
}
    <bean name="xiaoming" class="test6.Person">
        <property name="name" value="小明"></property>
    </bean>

    <bean id="wkReport" class="test6.Report"></bean>
    <bean id="wkMonitor" class="test6.WorkListener"></bean>
    <bean id="slMonitor" class="test6.SleepListener"></bean>
public class Main {
    public static void main(String[] args) {
        ConfigurableApplicationContext context = new ClassPathXmlApplicationContext("d.xml");
        Report rp = (Report)context.getBean("wkReport");
        rp.work();
        rp.sleep();
        context.close();
    }
}

输出

开始小明的工作报告
摄像头记录到:
小明 今天没有完成100张图片制作,并且听到这个任务时,情绪时而激动,时而低落
开始小明的睡眠报告
摄像头记录到:
小明 开始休息了

事件本身,Work,Sleep不需要注册到sping容器中。

想要让

rp.work();rp.sleep();工作,睡觉这样的方法/行为,可以被监控,除了这些方法本身要处理的内容外,还需要为这个方法定义一个具体的事件类(此例中是Work,Sleep,这些具体的事件类不需要注册到spring容器,因为他们在工作、睡觉这些方法中已经被调用了),然后将对应的事件类添加到ApplicationEventPublisher事件处理的逻辑中;在我们调用 工作、睡觉这些方法时,就会触发事件处理逻辑,spring容器会自动检测哪些bean实现了与之相对应的ApplicationListener监听类,然后调用其onApplicationEvent方法

原文地址:https://www.cnblogs.com/perfei/p/12183405.html

时间: 2024-11-07 13:20:32

Java Spring 自定义事件监听的相关文章

cocos2d-js 自定义事件监听派发

熟悉js的dom事件或者flash事件的,基本都能立马明白cc.eventManager的用法. cc.eventManager有两种注册监听器的方式,一种是原生事件,例如 cc.eventManager.addListener({ event: cc.EventListener.KEYBOARD, onKeyReleased: function(keyCode, event) { if (keyCode == cc.KEY.back) { cc.director.end(); } }}, th

十一、Spring之事件监听

Spring之事件监听 ApplicationListener ApplicationListener是Spring事件机制的一部分,与抽象类ApplicationEvent类配合来完成ApplicationContext的事件机制. 如果容器中存在ApplicationListener的Bean,当ApplicationContext调用publishEvent方法时,对应的Bean会被触发.这一过程是典型的观察者模式的实现. 源码: @FunctionalInterface public i

JavaScript自定义事件监听

一.事件的属性和方法 1 //事件Event 2 //属性:` 3 `bubbles`:布尔值,是否会冒泡 4 `cancelable`:布尔值,是否可以取消默认动作 5 `target`:目标对象 6 `currentTarget`:当前对象 7 `timeStamp`:时间戳(相对于某个时刻) 8 `type`:事件类型,即注册该事件的名字 9 `eventPhase`:返回事件传播的当前阶段 10 11 12 //方法 13 1.event.stopPropagation(); 阻止冒泡

Java中的事件监听机制

鼠标事件监听机制的三个方面: 1.事件源对象: 事件源对象就是能够产生动作的对象.在Java语言中所有的容器组件和元素组件都是事件监听中的事件源对象.Java中根据事件的动作来区分不同的事件源对象,动作发生在哪个组件上,那么该组件就是事件源对象 2.事件监听方法: addMouseListener(MouseListener ml) ;该方法主要用来捕获鼠标的释放,按下,点击,进入和离开的动作:捕获到相应的动作后,交由事件处理类(实现MouseListener接口)进行处理. addAction

Java 中的事件监听机制

看项目代码时遇到了好多事件监听机制相关的代码.现学习一下: java事件机制包含三个部分:事件.事件监听器.事件源. 1.事件:继承自java.util.EventObject类,开发人员自己定义. package com.shuyan.javatest.EventTest; import java.util.EventObject; public class DnsEvent extends EventObject { private String userData; private long

c++中怎么自定义事件监听(回调函数)

废话不多说,上代码: 1 #include <iostream> 2 #include <vector> 3 using namespace std; 4 class A 5 { 6 private: 7 int a = 5; 8 vector<void(*)(int)> funcs; 9 public: 10 void setA(int a_); 11 void registerCallback(void(*p)(int)); 12 }; 13 14 void dis

JAVA自定义事件监听完整例子---sunfruit[转]

http://cache.baiducontent.com/c?m=9f65cb4a8c8507ed4fece763105392230e54f733628a854d2c90c05f93130716017bb2e1707e4e5f8099297a52ef0f07bbae61332a032ab59bc2835dddccc86e70d633712d5cd04e4a805dfcdc4654d651e34d98af0e97cbe746e4b9d3a3c82551dd27736df6f59c2c01&p=9

Spring Boot实践——事件监听

借鉴:https://blog.csdn.net/Harry_ZH_Wang/article/details/79691994 https://blog.csdn.net/ignorewho/article/details/80702827     https://www.jianshu.com/p/edd4cb960da7 事件监听介绍 Spring提供5种标准的事件监听: 上下文更新事件(ContextRefreshedEvent):该事件会在ApplicationContext被初始化或者

java 事件监听

事件监听实现: 三要素: 1.事件源(数据源,要处理的数据) 2.事件 (承载数据,传递信息并被监听) 3.监听器 (负责对数据的业务处理) --该开发用例采用了Spring的事件监听 1.  定义事件类型 public class MyEvent extends ApplicationEvent { private static final long serialVersionUID = 7937618461275424515L; // 其他属性 (非必须) ... ... public My