精华内容
下载资源
问答
  • java自定义监听器的示例代码
    2021-03-03 10:46:26

    JAVA用户自定义事件监听完整例子

    JAVA用户自定义事件监听完整例子- ---sunfruit     很多介绍用户自定义事件都没有例子,或是例子不全,下面写了一个完整的例子,并写入了注释以便参考,完整的实例源代码如下:

    package demo;

    import java.util.EventObject;

    /**

    * Title: 事件处理类,继承了事件基类

    * Description:

    * Copyright: Copyright (c) 2005

    * Company: cuijiang

    * @author not attributable

    * @version 1.0

    */

    public class DemoEvent extends EventObject

    {

    private Object obj;

    private String sName;

    public DemoEvent(Object source,String sName) {

    super(source);

    obj = source;

    this.sName=sName;

    }

    public Object getSource()

    {

    return obj;

    }

    public void say()

    {

    System.out.println("这个是 say 方法...");

    }

    public String getName()

    {

    return sName;

    }

    }

    package demo;

    import java.util.EventListener;

    /**

    * Title: 监听器接口

    * Description:

    * Copyright: Copyright (c) 2005

    * Company: cuijiang

    * @author not attributable

    * @version 1.0

    */

    public interface DemoListener extends EventListener{

    public void demoEvent(DemoEvent dm);

    }

    package demo;

    import java.util.*;

    /**

    * Title: 使用事件的类

    * Description: 该类实现了监听器的添加和监听器方法的执行,并且实现了由于属性的改变而执行事件

    * Description: 在添加、删除、执行监听器的时候都要注意同步问题

    * Copyright: Copyright (c) 2005

    * Company: cuijiang

    * @author not attributable

    * @version 1.0

    */

    public class DemoSource{

    private Vector repository = new Vector();

    private DemoListener dl;

    private String sName="";

    public DemoSource()

    {

    }

    //注册监听器,如果这里没有使用Vector而是使用ArrayList那么要注意同步问题

    public void addDemoListener(DemoListener dl)

    {

    repository.addElement(dl);//这步要注意同步问题

    }

    //如果这里没有使用Vector而是使用ArrayList那么要注意同步问题

    public void notifyDemoEvent(DemoEvent event) {

    Enumeration enum = repository.elements();//这步要注意同步问题

    while(enum.hasMoreElements())

    {

    dl = (DemoListener)enum.nextElement();

    dl.demoEvent(event);

    }

    }

    //删除监听器,如果这里没有使用Vector而是使用ArrayList那么要注意同步问题

    public void removeDemoListener(DemoListener dl)

    {

    repository.remove(dl);//这步要注意同步问题

    }

    /**

    * 设置属性

    * @param str1 String

    */

    public void setName(String str1)

    {

    boolean bool=false;

    if(str1==null && sName!=null) bool=true;

    else if(str1!=null && sName==null) bool=true;

    else if(!sName.equals(str1)) bool=true;

    this.sName=str1;

    //如果改变则执行事件

    if(bool) notifyDemoEvent(new DemoEvent(this,sName));

    }

    public String getName()

    {

    return sName;

    }

    }

    package demo;

    import java.lang.Thread;

    /**

    * Title: 测试类

    * Description: 测试了由于改变属性而引起的事件发生

    * Copyright: Copyright (c) 2005

    * Company: cuijiang

    * @author not attributable

    * @version 1.0

    */

    public class TestDemo

    implements DemoListener {

    private DemoSource ds;

    public TestDemo()

    {

    ds=new DemoSource();

    ds.addDemoListener(this);

    System.out.println("添加监听器完毕");

    try {

    Thread.sleep(3000);

    //改变属性,触发事件

    ds.setName("改变属性,触发事件");

    }

    catch (InterruptedException ex) {

    ex.printStackTrace();

    }

    ds.addDemoListener(this);

    System.out.println("添加监听器完毕2");

    try {

    Thread.sleep(3000);

    //改变属性,触发事件

    ds.setName("改变属性,触发事件2");

    }

    catch (InterruptedException ex) {

    ex.printStackTrace();

    }

    ds.removeDemoListener(this);

    System.out.println("添加监听器完毕3");

    try {

    Thread.sleep(3000);

    //改变属性,触发事件

    ds.setName("改变属性,触发事件3");

    }

    catch (InterruptedException ex) {

    ex.printStackTrace();

    }

    }

    public static void main(String args[])

    {

    new TestDemo();

    }

    /**

    * demoEvent

    *

    * @param dm DemoEvent

    * @todo Implement this test.DemoListener method

    */

    public void demoEvent(DemoEvent dm) {

    System.out.println("事件处理方法");

    System.out.println(dm.getName());

    dm.say();

    }

    }

    更多相关内容
  • 主要介绍了Java使用自定义注解实现为事件源绑定事件监听器操作,结合实例形式分析了java自定义注解注解处理、事件监听与响应等相关操作技巧,需要的朋友可以参考下
  • 一定义注解import java.lang....@Target(ElementType.FIELD)@Retention(RetentionPolicy.RUNTIME)public @interface ActionListenerFor{// 定义一个成员变量,用于设置元数据// 该listener成员变量用于保存监听器实...

    一 定义注解

    import java.lang.annotation.*;

    import java.awt.event.*;

    @Target(ElementType.FIELD)

    @Retention(RetentionPolicy.RUNTIME)

    public @interface ActionListenerFor

    {

    // 定义一个成员变量,用于设置元数据

    // 该listener成员变量用于保存监听器实现类

    Class extends ActionListener> listener();

    }

    二 注解处理程序

    import java.lang.reflect.*;

    import java.awt.event.*;

    import javax.swing.*;

    public class ActionListenerInstaller

    {

    // 处理Annotation的方法,其中obj是包含Annotation的对象

    public static void processAnnotations(Object obj)

    {

    try

    {

    // 获取obj对象的类

    Class cl = obj.getClass();

    // 获取指定obj对象的所有成员变量,并遍历每个成员变量

    for (Field f : cl.getDeclaredFields())

    {

    // 将该成员变量设置成可自由访问。

    f.setAccessible(true);

    // 获取该成员变量上ActionListenerFor类型的Annotation

    ActionListenerFor a = f.getAnnotation(ActionListenerFor.class);

    // 获取成员变量f的值

    Object fObj = f.get(obj);

    // 如果f是AbstractButton的实例,且a不为null

    if (a != null && fObj != null

    && fObj instanceof AbstractButton)

    {

    // 获取a注解里的listner元数据(它是一个监听器类)

    Class extends ActionListener> listenerClazz = a.listener();

    // 使用反射来创建listner类的对象

    ActionListener al = listenerClazz.newInstance();

    AbstractButton ab = (AbstractButton)fObj;

    // 为ab按钮添加事件监听器

    ab.addActionListener(al);

    }

    }

    }

    catch (Exception e)

    {

    e.printStackTrace();

    }

    }

    }

    三 测试注解程序

    import java.awt.event.*;

    import javax.swing.*;

    public class AnnotationTest

    {

    private JFrame mainWin = new JFrame("使用注解绑定事件监听器");

    // 使用Annotation为ok按钮绑定事件监听器

    @ActionListenerFor(listener=OkListener.class)

    private JButton ok = new JButton("确定");

    // 使用Annotation为cancel按钮绑定事件监听器

    @ActionListenerFor(listener=CancelListener.class)

    private JButton cancel = new JButton("取消");

    public void init()

    {

    // 初始化界面的方法

    JPanel jp = new JPanel();

    jp.add(ok);

    jp.add(cancel);

    mainWin.add(jp);

    ActionListenerInstaller.processAnnotations(this); // ①

    mainWin.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

    mainWin.pack();

    mainWin.setVisible(true);

    }

    public static void main(String[] args)

    {

    new AnnotationTest().init();

    }

    }

    // 定义ok按钮的事件监听器实现类

    class OkListener implements ActionListener

    {

    public void actionPerformed(ActionEvent evt)

    {

    JOptionPane.showMessageDialog(null , "单击了确认按钮");

    }

    }

    // 定义cancel按钮的事件监听器实现类

    class CancelListener implements ActionListener

    {

    public void actionPerformed(ActionEvent evt)

    {

    JOptionPane.showMessageDialog(null , "单击了取消按钮");

    }

    }

    四 运行

    b6b99adccc4a8ab7b4f66f06b94ce322.png

    c22ed16ebbd602fa5dfb12e41c425ac5.png

    标签:Java,自定义,ActionListenerFor,public,obj,监听器,import,class

    来源: https://blog.csdn.net/chengqiuming/article/details/95848753

    展开全文
  • java相关:在spring中使用自定义注解注册监听器的方法发布于 2020-4-21|复制链接本篇文章主要介绍了在spring中使用自定义注解注册监听器的方法,本文就是在分析监听器回调原理的基础上,在spring环境中使用自定义的...

    java相关:在spring中使用自定义注解注册监听器的方法

    发布于 2020-4-21|

    复制链接

    本篇文章主要介绍了在spring中使用自定义注解注册监听器的方法,本文就是在分析监听器回调原理的基础上,在spring环境中使用自定义的注解实现一个监听器。小妖觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小妖过来看看吧

    接口回调监听器本质上就是利用回调机制,在某个动作发生前或后,执行我们自己的一些代码。在Java语言中,可以使用接口来实现。实现一个监听器案例为了方便,直接在spring环境中定义:以工作(work)为例,定义工作开始时(或结束时)的监听器。1. 定义回调的接口

    ```java

    package com.yawn.demo.listener;

    /**

    * @author Created by yawn on 2018-01-21 13:53

    */

    public interface WorkListener {

    void onStart(String name);

    }

    ```

    2. 定义动作

    ```java

    package com.yawn.demo.service;

    import com.yawn.demo.listener.WorkListener;

    /**

    * @author Created by yawn on 2018-01-21 13:39

    */

    @Service

    public class MyService {

    @Resource

    private PersonService personService;

    private WorkListener listener;

    public void setWorkListener(WorkListener workListener) {

    this.listener = workListener;

    }

    public void work(String name) {

    listener.onStart(name);

    personService.work();

    }

    }

    ```

    动作work为一个具体的方法,在work()方法的适当时机,调用前面定义的接口。此外,在这个动作定义类中,需要提高设置监听器的方法。3. 监听测试

    ```java

    @RunWith(SpringRunner.class)

    @SpringBootTest

    public class DemoSpringAnnotationApplicationTests {

    @Resource

    private MyService myService;

    @Test

    public void test1() {

    // 接口设置监听器

    myService.setWorkListener(new WorkListener() {

    @Override

    public void onStart(String name) {

    System.out.println("Start work for " + name + " !");

    }

    });

    // // lambda 表达式设置监听器

    // myService.setWorkListener(name -> System.out.println("Start work for " + name + " !"));

    // 工作

    myService.work("boss");

    }

    @Test

    public void test2() {

    // 继承实现类设置监听器

    myService.setWorkListener(new myWorkListener());

    // 工作

    myService.work("boss");

    }

    class myWorkListener extends WorkListenerAdaptor {

    @Override

    public void onStart(String name) {

    System.out.println("Start work for " + name + " !");

    }

    }

    }

    ```

    使用以上两种方法测试,得到了结果为:

    ```plain

    Start work for boss !

    working hard ...

    ```

    说明在动作work发生之前,执行了我们在测试类中写下的监听代码,实现类监听的目的。使用注解实现监听器在以上代码中,调用 setWorkListener(WorkListener listener)  方法一般称作设置(注册)监听器,就是将自己写好的监听代码,设置为动作的监听器。然而,在每次注册监听器时,一般需要写一个类,实现定义好的接口或继承实现接口的类,再重写接口定义的方法即可。因此,聪明的程序员就想简化这个过程,所以就想出了使用注解的方法。使用注解,将监听代码段写在一个方法中,使用一个注解标记这个方法即可。的确,使用变得简单了,但实现却不见得。1. 定义一个注解

    ```java

    package com.yawn.demo.anno;

    @Target(ElementType.METHOD)

    @Retention(RetentionPolicy.RUNTIME)

    public @interface WorkListener {

    }

    ```

    2. 解析注解

    ```java

    package com.yawn.demo.anno;

    import com.yawn.demo.service.MyService;

    import org.springframework.beans.BeansException;

    import org.springframework.beans.factory.InitializingBean;

    import org.springframework.context.ApplicationContext;

    import org.springframework.context.ApplicationContextAware;

    import org.springframework.stereotype.Component;

    import javax.annotation.Resource;

    import java.lang.annotation.Annotation;

    import java.lang.reflect.Method;

    import java.util.LinkedHashMap;

    import java.util.Map;

    /**

    * @author Created by yawn on 2018-01-21 14:46

    */

    @Component

    public class WorkListenerParser implements ApplicationContextAware, InitializingBean {

    @Resource

    private MyService myService;

    private ApplicationContext applicationContext;

    @Override

    public void afterPropertiesSet() throws Exception {

    Map listenerBeans = getExpectListenerBeans(Controller.class, RestController.class, Service.class, Component.class);

    for (Object listener : listenerBeans.values()) {

    for (Method method : listener.getClass().getDeclaredMethods()) {

    if (!method.isAnnotationPresent(WorkListener.class)) {

    continue;

    }

    myService.setWorkListener(name -> {

    try {

    method.invoke(listener, name);

    } catch (Exception e) {

    e.printStackTrace();

    }

    });

    }

    }

    }

    /**

    * 找到有可能使用注解的bean

    * @param annotationTypes 需要进行扫描的类级注解类型

    * @return 扫描到的beans的map

    */

    private Map getExpectListenerBeans(Class... annotationTypes) {

    Map listenerBeans = new LinkedHashMap();

    for (Class annotationType : annotationTypes) {

    Map annotatedBeansMap = applicationContext.getBeansWithAnnotation(annotationType);

    listenerBeans.putAll(annotatedBeansMap);

    }

    return listenerBeans;

    }

    @Override

    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {

    this.applicationContext = applicationContext;

    }

    }

    ```

    在注解的解析过程中,设置监听器。在解析类中,实现了接口ApplicationContextAware,为了在类中拿到ApplicationContext的引用,用于得到 IOC 容器中的 Bean;而实现接口InitializingBean,则是为了在一个合适的时机执行解析注解、设置监听器的代码。 如果不这样做,可以在CommandLineRunner执行时调用解析、设置的代码,而ApplicationContext也可以自动注入。3. 测试在执行完以上代码后,监听器就已经设置好了,可以进行测试了。

    ```java

    package com.yawn.demo.controller;

    import com.yawn.demo.anno.WorkListener;

    import com.yawn.demo.service.MyService;

    import org.springframework.web.bind.annotation.GetMapping;

    import org.springframework.web.bind.annotation.RestController;

    import javax.annotation.Resource;

    /**

    * @author Created by yawn on 2018-01-21 13:28

    */

    @RestController

    public class TestController {

    @Resource

    private MyService myService;

    @GetMapping("/work")

    public Object work() {

    myService.work("boss");

    return "done";

    }

    @WorkListener

    public void listen(String name) {

    System.out.println("Start work for " + name + " !");

    }

    }

    ```

    写一个监听方法,参数类型和个数与接口相同,然后加上自定义的注解即可。当启动环境后,监听器就已经设置好了。然后通过url调用myService的work()方法,可以看到结果:

    ```plain

    Start work for boss !

    working hard ...

    ```

    已经调用了监听方法。在接下来的开发中,就可以使用这个注解注册监听器了。

    展开全文
  • Java 监听器

    2021-02-13 01:08:49
    1: 监听器的定义2:监听器的用途3:实例4:监听器分类5:Servlet3.0下监听器的使用6:实际项目常用的案例1: 监听器的定义:监听器实际上是一个类,这个类实现了特定的接口,然后将这个类在 web.xml 文件中进行描述...

    1: 监听器的定义

    2:监听器的用途

    3:实例

    4:监听器分类

    5:Servlet3.0下监听器的使用

    6:实际项目常用的案例

    1: 监听器的定义:

    监听器实际上是一个类,这个类实现了特定的接口,然后将这个类在 web.xml 文件中进行描述,这样服务器在启动的时候就可以实例化这个类,启动监听器。当范围对象的状态发生变化的时候,服务器自动调用监听器对象中的方法。例如统计用户在线人数。

    3750e70c834cdcc8bf0c04e01caf7291.png

    72cc944af304075623dfb4eec582392e.png

    web监听器是Servlet规范中定义的一种特殊类,用于监听ServletContext,HttpSession,ServletRequest等域对象的创建、销毁、以及属性的变化等,可以在事件发生前、发生后进行一些处理。

    2、监听器的用途

    1、统计在线人数和在线用户

    2、系统加载时进行信息的初始化工作

    3、统计网站的访问量

    4、跟Spring结合

    3、实例

    在web.xml文件中进行配置

    7569d3ae9d43affcac515957b9d7154c.png

    listenr-class中是自己定义的Listener的类路径

    public class MyRequestListener implements ServletContextListener{

    public void contextInitialized(ServletContextEvent event){

    System.out.println("启动监听器");

    }

    public void contextDestroy(ServletContextEvent event){

    System.out.println("结束监听器");

    }

    }

    编译器会为我们自动生成contextInitialized和contextDestroy两个函数

    监听器>过滤器>serlvet,在 web.xml 文件中配置的时候注意顺序

    4 监听器的分类

    按监听的对象划分,可以分为监听

    ServletContext对象

    HttpSession对象

    ServletRequest对象

    按监听的事件划分

    域对象自身的创建和销毁

    域对象中属性的创建和消除

    绑定到session中的某个对象的状态

    由于很多监听的方式一致,因此我们只考虑其中的HttpSession对象:

    在web.xml中配置session超时

    30

    当超过30秒后,session会自动过期

    public class MyRequestListener implements HttpSessionListener{

    public void sessionCreate(HttpSessionEvent event){

    System.out.println("event 创建:");

    }

    public void sessionDestroy(HttpSessionEvent event){

    System.out.println("event 销毁:");

    }

    }

    另外,我们可以实现HttpSessionAttributeListener来实现session对象属性的增加(added)、删除(removed)、替换(replaced)的功能

    public class MyRequestListener implements HttpSessionAttributeListener{

    public void attributeAdded(HttpSessionBindEvent event){

    }

    public void attributeRemoved(HttpSessionBindEvent event){

    }

    public void attributeReplaced(HttpSessionBindEvent event){

    }

    }

    5、Servlte3.0下的使用

    在Servlet3.0下通过注解@WebListener("")就可以实现了,不需要在web.xml中进行配置

    6、实战

    public class MyRequestListener implements HttpSessionListener{

    private int counts = 0;//用于统计在线人数

    public void sessionCreate(HttpSessionEvent event){

    counts++;

    event.getSession().getServletContext.setAttribute("name",counts); //用户人数+1

    }

    public void sessionDestroy(HttpSessionEvent event){

    counts--;

    event.getSession().getServletContext.setAttribute("name",counts);//用户人数-1

    }

    }

    @WebListener

    public class MyRequestListener2 implements ServletRequestListener{

    private ArrayListlist; //创建一个在线用户的列表

    public void requestCreate(ServletRequestEvent event){

    HttpServletRequest request = (HttpServletRequest) request.getServletContext();

    String sessionId = request.getSession().getSessionId();

    if(sessionId ...){

    ....

    list.add(...);

    }

    }

    public void requestDestroy(ServletRequestEvent event){

    }

    }

    public class User{

    private int sessionId;

    }

    注意,以上代码只是大致的代码,并不全面和正确。

    参考:java Web开发技术应用 - 监听器

    展开全文
  • java-监听器的使用
  • Java监听器详解

    万次阅读 多人点赞 2019-08-17 18:47:42
    监听器的定义 是指专门用于对其他对象身上发生的事件或状态改变进行监听和相应处理的对象,当被监视的对象发生变化时,立即采取相应的行动。 Web应用当中监听器是什么? web监听器由servlet规范提供的,它可以监听...
  • 浅谈java监听器的作用

    2021-02-27 11:05:49
    监听器JAVA Web开发中很重要的内容,其中涉及到的知识,可以参考下面导图:Web监听器1 什么是web监听器?web监听器是一种Servlet中的特殊的类,它们能帮助开发者监听web中的特定事件,比如ServletContext,...
  • java 监听器

    2021-03-01 10:22:44
    一、监听器定义监听器实际上是一个类,这个类实现了特定的接口,然后将这个类在 web.xml 文件中进行描述,这样服务器在启动的时候就可以实例化这个类,启动监听器。当范围对象的状态发生变化的时候,服务器自动调用...
  • JAVA用户自定义事件监听完整例子JAVA用户自定义事件监听完整例子- —sunfruit 很多介绍用户自定义事件都没有例子,或是例子不全,下面写了一个完整的例子,并写入了注释以便参考,完整的实例源代码如下:package ...
  • 注释处理器为了开始写注释处理器,你首先应该熟悉javax.annotation.processing 和 javax.lang.model的包组。一般来说,你可以直接掠过执行处理器接口,进入抽象类javax.annotation.processing.AbstractProcessor。...
  • 当范围对象的状态发生变化的时候,服务器自动调用监听器对象中的方法。常用于统计在线人数和在线用户,系统加载时进行信息初始化,统计网站的访问量等等。分类:按监听的对象划分,可以分为ServletC...
  • 接口回调监听器本质上就是利用回调机制,在某个动作发生前或后,执行我们自己的一些代码。在Java语言中,可以使用接口来实现。实现一个监听器案例为了方便,直接在spring环境中定义:以工作(work)为例,定义工作开始...
  • 1.过滤 过滤 package com.cnooc.dictionary.utils.filter; import lombok.extern.slf4j.Slf4j; import org.springframework.stereotype.Component; import javax.servlet.*; import javax.servlet....
  • 监听器在JavaWeb开发中用得比较多Java Web开发中的监听器(listener)就是application、session、request三个对象创建、销毁或者往其中添加修改删除属性时自动执行代码的功能组件,如下所示:①ServletContextListener...
  • 监听器用于监听Web应用中某些对象的创建、销毁、增加,修改,删除等动作的发生,然后作出相应的响应处理。当监听范围的对象的状态发生变化的时候,服务器自动调用监听器对象中的方法。常用于统计网站在线人数、系统...
  • Java用户自定义事件监听完整例子- ---sunfruit,很多介绍用户自定义事件都没有例子,或是例子不全,下面写了一个完整的例子,并写入了注释以便参考,完整的实例源代码如下:package demo;import java.util....
  • Web监听器导图详解监听器JAVA Web开发中很重要的内容,其中涉及到的知识,能够参考下面导图:html 1、Web监听器1. 什么是web监听器?web监听器是一种Servlet中的特殊的类,它们能帮助开发者监听web中的特定事件,...
  • 监听器用于监听web应用中某些对象、信息的创建、销毁、增加,修改,删除等动作的发生,然后作出相应的响应处理。当范围对象的状态发生变化的时候,服务器自动调用监听器对象中的方法。常用于统计在线人数和在线用户...
  • java web的Listener(监听器

    千次阅读 2022-04-03 22:18:38
    java web的Listener(监听器) 介绍 监听器是Servlet规范中的一员,就像Filiter一样,Filter也是Servlet规范中的一员, 在servlet中,所有的监听器接口都是以“Listener”结尾 作用 监听器实际上是Servlet规范...
  • java监听器里面使用service

    千次阅读 2018-01-30 15:58:43
    Java监听器众多,我们可以通过实现不通的接口创建监听器。 说到监听器,那我们就不可避免的须在监听器里面实现某些功能,这些功能基本上都是和数据库相关的。 根据我们之前的项目经验,基本上都是系统化的,创建...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 89,418
精华内容 35,767
关键字:

java注解监听器

java 订阅