一篇学会Spring Boot中使⽤监听器实现事件监听

守夜码农

已于 2023-12-19 16:16:28 修改

阅读量1.1k

点赞数 15

于 2023-12-19 16:14:46 首次发布

本文链接：https://blog.csdn.net/qq_51081923/article/details/135086182

版权

Spring Boot中使⽤监听器

监听器

web监听器是一种Servlet中特殊的类，他们能帮助开发者监听web中特定的事件，比如ServletContext、HttpSession、ServletRequest的创建和销毁；变量的创建、销毁和修改等。可以在某些动作前后增加处理，实现监听。
在SpringBoot中web监听器使用的场景非常多，比如监听servlet上下文用来初始化一些数据、监听HttpSession用来获取当前的在线人数、监听客户端请求的ServletRequest对象来获取用户的访问信息等等。

监听servlet上下文对象

监听servlet上下文对象可以用来初始化数据，用户缓存。比如在用户点击某个站点的首页时，一般都会展现出首页的一些信息，而这些信息基本上或者大部分时间都保持不变，但是这些信息都是来自数据库。如果用户每次点击，都要从数据库中去获取数据的话，用户量少
还可以接受，如果用户量大的话，这对数据库也是一笔很大的开销。
针对这种首页数据，大部分都不常更新的话，我们完全可以把它们缓存起来，每次用户点击的时候，我们直接从缓存中拿，这样既可以提高首页的访问速度，又可以降低服务器的压力。
如果做得更加灵活，可以再加一个定时器，定期的来更新首页缓存，接类似与csdn个人博客首页中的排名的变化一样。
例子：存在实体类User，创建对应的Mapper类，service层的类

@Setter
@Getter
@ToString
public class User {
    private Long id;
    private String username;
    private String password;
    @JsonSerialize(using = BigDecimalSerializer.class)
    private BigDecimal haveMoney;
    public User() {}
    public User(Long id, String username, String password, BigDecimal haveMoney) {
        this.id = id;
        this.username = username;
        this.password = password;
        this.haveMoney = haveMoney;
    }
}
@Service
public class UserServiceImpl extends ServiceImpl<BookMapper, Book> implements UserService {
  @Resource
  private UserMapper userMapper;
  @Override
  public User getUser() {
    // 实际中会根据具体的业务场景，从数据库中查询对应的信息
    return new User(1L, "liu", "123456",new BigDecimal(199.98));
  }

}

写⼀个监听器，实现 ApplicationListener 接⼝，重写 onApplicationEvent ⽅法，将 ContextRefreshedEvent 对象传进去。如果我们
想在加载或刷新应⽤上下⽂时（一般在SpringBoot项目启动的时候执行），也重新刷新下我们预加载的资源，就可以通过监听 ContextRefreshedEvent 来做这样的事情。

@Component
public class MyServletContextListener implements ApplicationListener<ContextRefreshedEvent> {

    @Override
    public void onApplicationEvent(ContextRefreshedEvent contextRefreshedEvent) {
        // 先获取到application上下⽂
        ApplicationContext applicationContext = contextRefreshedEvent.getApplicationContext();
        // 获取对应的service
        UserService userService = applicationContext.getBean(UserService.class);
        User user = userService.getUser();
        // 获取application域对象，将查到的信息放到application域中
        ServletContext application = applicationContext.getBean(ServletContext.class);
        application.setAttribute("user", user);
    }
}

⾸先通过 contextRefreshedEvent 来获取 application 上下⽂，再通过 application 上下⽂来获取
UserService 这个 bean，项⽬中可以根据实际业务场景，也可以获取其他的 bean，然后再调⽤⾃⼰的业务代码获取相应的数据，最后存
储到 application 域中，这样前端在请求相应数据的时候，我们就可以直接从 application 域中获取信息，减少数据库的压⼒。
在controller中，获取application域中的数据的两种方式

@RestController
@RequestMapping("/listenner")
public class TestListennerController {
  private final ServletContext servletContext;

  public TestListennerController(ServletContext servletContext) {
    this.servletContext = servletContext;
  }
  // 获取方式1
  @GetMapping("/user")
  public User getUser(HttpServletRequest request) {
    ServletContext application = request.getServletContext();
    return (User) application.getAttribute("user");
  }
  // 获取方式2
  @GetMapping("/getData")
  public String getDataFromApplicationScope() {
    // 从application域中获取数据
    String data = (String) servletContext.getAttribute("myData");
    return data;
  }
}

监听HTTP会话Session对象

监听器还有一个常用的地方就是监听session对象，来获取在线用户数量，现在有很多开发者都有自己的网站，监听session来获取当前在线用户数量是个常见的场景。
创建对应的监听类

@Component
public class MyHttpSessionListener implements HttpSessionListener {
    private final static Logger logger = LoggerFactory.getLogger(MyHttpSessionListener.class);

    public Integer count = 0;

    @Override
    public synchronized void sessionCreated(HttpSessionEvent httpSessionEvent){
        logger.info("用户上线了");
        count++;
        httpSessionEvent.getSession().getServletContext().setAttribute("count",count);
    }

    @Override
    public synchronized void sessionDestroyed(HttpSessionEvent httpSessionEvent){
        logger.info("用户下线了");
        count--;
        httpSessionEvent.getSession().getServletContext().setAttribute("count",count);
    }
}

⾸先该监听器需要实现 HttpSessionListener 接⼝，然后重写 sessionCreated 和 sessionDestroyed ⽅法，
在 sessionCreated ⽅法中传递⼀个 HttpSessionEvent 对象，然后将当前 session 中的⽤户数量加1，sessionDestroyed ⽅法刚好相
反，创建对应的controller类进行测试。

@RestController
@RequestMapping("/listenner")
public class TestListennerController {
    /**
     * 获取当前在线⼈数，该⽅法有bug
     * @param request
     * @return
     */
    @GetMapping("/total")
    public String getTotalUser(HttpServletRequest request) {
        Integer count = (Integer) request.getSession().getServletContext().getAttribute("count");
        return "当前在线⼈数：" + count;
    }
}

该 Controller 中是直接获取当前 session 中的⽤户数量，启动服务器，在浏览器中输⼊ localhost:8080/listener/total 可以看到返回的结果
是1，再打开⼀个浏览器，请求相同的地址可以看到 count 是 2 ，这没有问题。但是如果关闭⼀个浏览器再打开，理论上应该还是2，但是
实际测试却是 3。原因是 session 销毁的⽅法没有执⾏（可以在后台控制台观察⽇志打印情况），当重新打开时，服务器找不到⽤户原来
的 session，于是⼜重新创建了⼀个 session，那怎么解决该问题呢？我们可以将上⾯的 Controller ⽅法改造⼀下：

@RestController
@RequestMapping("/listenner")
public class TestListennerController {
    @GetMapping("/total2")
    public String getTotalUser(HttpServletRequest request, HttpServletResponse response) {
        Cookie cookie;
        try {
            // 把sessionId记录在浏览器中
            cookie = new Cookie("JSESSIONID", URLEncoder.encode(request.getSession().getId(), "utf-8"));
            cookie.setPath("/");
            //设置cookie有效期为2天，设置长⼀点
            cookie.setMaxAge( 48*60 * 60);
            response.addCookie(cookie);
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        Integer count = (Integer) request.getSession().getServletContext().getAttribute("count");
        return "当前在线⼈数：" + count;
    }

}

该处理逻辑是让服务器记得原来那个 session，即把原来的 sessionId 记录在浏览器中，下次再打开时，把这个 sessionId 传
过去，这样服务器就不会重新再创建了。重启⼀下服务器，在浏览器中再次测试⼀下，即可避免上⾯的问题。

监听客户端请求Servlet Request对象

使⽤监听器获取⽤户的访问信息⽐较简单，实现 ServletRequestListener 接⼝即可，然后通过 request 对象获取⼀些信息。

@Component
public class MyServletRequestListener implements ServletRequestListener {
    private static final Logger logger = LoggerFactory.getLogger(MyServletRequestListener.class);
    @Override
    public void requestInitialized(ServletRequestEvent servletRequestEvent) {
        HttpServletRequest request = (HttpServletRequest) servletRequestEvent.getServletRequest();
        logger.info("session id为：{}", request.getRequestedSessionId());
        logger.info("request url为：{}", request.getRequestURL());
        request.setAttribute("name", "刘建福");
    }
    @Override
    public void requestDestroyed(ServletRequestEvent servletRequestEvent) {
        logger.info("request end");
        HttpServletRequest request = (HttpServletRequest) servletRequestEvent.getServletRequest();
        logger.info("request域中保存的name值为：{}", request.getAttribute("name"));
    }
}

创建一个controller进行测试

@RestController
@RequestMapping("/listenner")
public class TestListennerController {
    @GetMapping("/request")
    public String getRequestInfo(HttpServletRequest request) {
        System.out.println("requestListener中的初始化的name数据：" + request.getAttribute("name"));
        return "success";
    }
}

Spring Boot中⾃定义事件监听

在实际项⽬中，我们往往需要⾃定义⼀些事件和监听器来满⾜业务场景，⽐如在微服务中会有这样的场景：微服务 A 在处理完某个逻辑之
后，需要通知微服务 B 去处理另⼀个逻辑，或者微服务 A 处理完某个逻辑之后，需要将数据同步到微服务 B，这种场景⾮常普遍，这个时
候，我们可以⾃定义事件以及监听器来监听，⼀旦监听到微服务 A 中的某事件发⽣，就去通知微服务 B 处理对应的逻辑。
自定义事件:自定义事件需要继承ApplicationEvent，在事件中定义一个User对象来模拟数据，构造方法将User对象传进来初始化。

@Setter
@Getter
public class MyEvent extends ApplicationEvent {
    private User user;
    public MyEvent(Object source, User user) {
        super(source);
        this.user = user;
    }
}

自定义监听器：⾃定义⼀个监听器来监听上⾯定义的 MyEvent 事件，⾃定义监听器需要实现 ApplicationListener 接⼝即可。
然后重写 onApplicationEvent ⽅法，将⾃定义的 MyEvent 事件传进来，因为该事件中，我们定义了 User 对象（该对象在实际中就是需要
处理的数据，在下⽂来模拟），然后就可以使⽤该对象的信息了.

@Component
public class MyEventListener implements ApplicationListener<MyEvent> {
    @Override
    public void onApplicationEvent(MyEvent myEvent) {
        // 把事件中的信息获取到
        User user = myEvent.getUser();
        // 处理事件，实际项⽬中可以通知别的微服务或者处理其他逻辑等等
        System.out.println("⽤户名：" + user.getUsername());
        System.out.println("密码：" + user.getPassword());
    }
}

定义好了事件和监听器之后，需要⼿动发布事件，这样监听器才能监听到，这需要根据实际业务场景来触发，针对本⽂的例⼦，我写
个触发逻辑.

@Service
public class UserServiceImpl extends ServiceImpl<BookMapper, Book> implements UserService {
    @Resource
    private ApplicationContext applicationContext;
    @Override
    public User getUser2() {
        User user = new User(1L, "liu", "123456",null);
        // 发布事件
        MyEvent event = new MyEvent(this, user);
        applicationContext.publishEvent(event);
        return user;
    }

}

在 service 中注⼊ ApplicationContext，在业务代码处理完之后，通过 ApplicationContext 对象⼿动发布 MyEvent 事件，这样我们⾃
定义的监听器就能监听到，然后处理监听器中写好的业务逻辑。
创建controller类测试，在方法中调用新建的方法

@RestController
@RequestMapping("/listenner")
public class TestListennerController {
  @Resource
  UserService userService;
  @GetMapping("/request2")
  public String getRequestInf2(HttpServletRequest request) {
    userService.getUser2();
    System.out.println("requestListener中的初始化的name数据：" + request.getAttribute("name"));
    return "success";
  }
}