一 定义注解

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 , "单击了取消按钮");

}

}

四 运行

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

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

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 ...

```

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

1： 监听器的定义

2：监听器的用途

3：实例

4：监听器分类

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

6：实际项目常用的案例

1： 监听器的定义：

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

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

2、监听器的用途

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

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

3、统计网站的访问量

4、跟Spring结合

3、实例

在web.xml文件中进行配置

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开发技术应用 - 监听器