第015课：Spring Boot 监听器

1. 监听器介绍

什么是 web 监听器？web 监听器是一种 Servlet 中特殊的类，它们能帮助开发者监听 web 中特定的事件，比如 ServletContext, HttpSession, ServletRequest 的创建和销毁；变量的创建、销毁和修改等。可以在某些动作前后增加处理，实现监控。

2. Spring Boot中监听器的使用

web 监听器的使用场景很多，比如监听 servlet 上下文用来初始化一些数据、监听 http session 用来获取当前在线的人数、监听客户端请求的 servlet request 对象来获取用户的访问信息等等。这一节中，我们主要通过这三个实际的使用场景来学习一下 Spring Boot 中监听器的使用。

2.1 监听Servlet上下文对象

监听 servlet 上下文对象可以用来初始化数据，用于缓存。什么意思呢？我举一个很常见的场景，比如用户在点击某个站点的首页时，一般都会展现出首页的一些信息，而这些信息基本上或者大部分时间都保持不变的，但是这些信息都是来自数据库。如果用户的每次点击，都要从数据库中去获取数据的话，用户量少还可以接受，如果用户量非常大的话，这对数据库也是一笔很大的开销。

针对这种首页数据，大部分都不常更新的话，我们完全可以把它们缓存起来，每次用户点击的时候，我们都直接从缓存中拿，这样既可以提高首页的访问速度，又可以降低服务器的压力。如果做的更加灵活一点，可以再加个定时器，定期的来更新这个首页缓存。就类似于 CSDN 个人博客首页中排名的变化一样。

下面我们针对这个功能，来写一个 demo，在实际中，读者可以完全套用该代码，来实现自己项目中的相关逻辑。首先写一个 Service，模拟一下从数据库查询数据：

/**
 * <h3>springboot-study</h3>
 * <p>UserService类</p>
 * @author : zhang.bw
 * @date : 2020-07-17 21:37
 **/
@Service
public class UserService {

    /**
     * 获取用户信息
     * @return
     */
    public User getUser() {
        // 实际中会根据具体的业务场景，从数据库中查询对应的信息
        return new User(1L, "猿码天地", "公众号【猿码天地】");
    }
}

然后写一个监听器，实现 ApplicationListener<ContextRefreshedEvent> 接口，重写 onApplicationEvent 方法，将 ContextRefreshedEvent 对象传进去。如果我们想在加载或刷新应用上下文时，也重新刷新下我们预加载的资源，就可以通过监听 ContextRefreshedEvent 来做这样的事情。如下：

/**
 * <h3>springboot-study</h3>
 * <p>使用ApplicationListener来初始化一些数据到application域中的监听器</p>
 * @author : zhang.bw
 * @date : 2020-07-17 21:37
 **/
@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 域中获取 user 信息来测试一下。

/**
 * <h3>springboot-study</h3>
 * <p>监听器测试Controller类</p>
 * @author : zhang.bw
 * @date : 2020-07-17 21:37
 **/
@RestController
@RequestMapping("/listener")
public class TestController {

    @Resource
    private UserService userService;

    /**
     * 直接从 application 域中获取 user 信息
     * @param request
     * @return
     */
    @GetMapping("/user")
    public User getUser(HttpServletRequest request) {
        ServletContext application = request.getServletContext();
        return (User) application.getAttribute("user");
    }
}

启动项目，在postman中输入 http://localhost:8080/listener/user 测试一下即可，如果正常返回 user 信息，那么说明数据已经缓存成功。不过 application 这种是缓存在内存中，对内存会有消耗，后面的课程中我会讲到 redis，到时候再给大家介绍一下 redis 的缓存。

 

2.2 监听HTTP会话 Session对象

监听器还有一个比较常用的地方就是用来监听 session 对象，来获取在线用户数量，现在有很多开发者都有自己的网站，监听 session 来获取当前在线用户数量是个很常见的使用场景，下面来介绍一下如何来使用。

/**
 * <h3>springboot-study</h3>
 * <p>使用HttpSessionListener统计在线用户数的监听器</p>
 * @author : zhang.bw
 * @date : 2020-07-17 21:37
 **/
@Component
public class MyHttpSessionListener implements HttpSessionListener {

    private static final 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 来测试一下。

/**
 * <h3>springboot-study</h3>
 * <p>监听器测试Controller类</p>
 * @author : zhang.bw
 * @date : 2020-07-17 21:37
 **/
@RestController
@RequestMapping("/listener")
public class TestController {

    @Resource
    private UserService userService;

    /**
     * 统计在线人数事件，该方法有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/total1 可以看到返回的结果是1，再打开一个浏览器，请求相同的地址可以看到 count 是 2 ，这没有问题。但是如果关闭一个浏览器再打开，理论上应该还是2，但是实际测试却是 3。原因是 session 销毁的方法没有执行（可以在后台控制台观察日志打印情况），当重新打开时，服务器找不到用户原来的 session，于是又重新创建了一个 session，那怎么解决该问题呢？我们可以将上面的 Controller 方法改造一下：

/**
 * <h3>springboot-study</h3>
 * <p>监听器测试Controller类</p>
 * @author : zhang.bw
 * @date : 2020-07-17 21:37
 **/
@RestController
@RequestMapping("/listener")
public class TestController {

    @Resource
    private UserService userService;

    /**
     * 统计在线人数事件
     * @param request
     * @param response
     * @return
     */
    @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 传过去，这样服务器就不会重新再创建了。重启一下服务器，在浏览器中再次测试一下，即可避免上面的问题。

2.3 监听客户端请求Servlet Request对象

使用监听器获取用户的访问信息比较简单，实现 ServletRequestListener 接口即可，然后通过 request 对象获取一些信息。如下：

/**
 * <h3>springboot-study</h3>
 * <p>使用ServletRequestListener获取访问信息</p>
 * @author : zhang.bw
 * @date : 2020-07-17 21:37
 **/
@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 测试一下即可。

/**
 * <h3>springboot-study</h3>
 * <p>监听器测试Controller类</p>
 * @author : zhang.bw
 * @date : 2020-07-17 21:37
 **/
@RestController
@RequestMapping("/listener")
public class TestController {

    @Resource
    private UserService userService;

    /**
     * 使用ServletRequestListener获取访问信息
     * @param request
     * @return
     */
    @GetMapping("/request")
    public String getRequestInfo(HttpServletRequest request) {
        System.out.println("requestListener中的初始化的name数据：" + request.getAttribute("name"));
        return (String)request.getAttribute("name");
    }
}

 

2020-08-09 09:06:38.358  INFO 10020 --- [nio-8080-exec-4] c.b.listener.MyServletRequestListener : session id为：64AA4C131EFABD10AC0EF8EB9F93F7BF
2020-08-09 09:06:41.173  INFO 10020 --- [nio-8080-exec-4] c.b.listener.MyServletRequestListener : request url为：http://localhost:8080/listener/request
requestListener中的初始化的name数据：公众号【猿码天地】
2020-08-09 09:06:57.305  INFO 10020 --- [nio-8080-exec-4] c.b.listener.MyServletRequestListener : request end
2020-08-09 09:07:02.195  INFO 10020 --- [nio-8080-exec-4] c.b.listener.MyServletRequestListener : request域中保存的name值为：公众号【猿码天地】

3. Spring Boot中自定义事件监听

在实际项目中，我们往往需要自定义一些事件和监听器来满足业务场景，比如在微服务中会有这样的场景：微服务 A 在处理完某个逻辑之后，需要通知微服务 B 去处理另一个逻辑，或者微服务 A 处理完某个逻辑之后，需要将数据同步到微服务 B，这种场景非常普遍，这个时候，我们可以自定义事件以及监听器来监听，一旦监听到微服务 A 中的某事件发生，就去通知微服务 B 处理对应的逻辑。

3.1 自定义事件

自定义事件需要继承 ApplicationEvent 对象，在事件中定义一个 User 对象来模拟数据，构造方法中将 User 对象传进来初始化。如下：

/**
 * <h3>springboot-study</h3>
 * <p>自定义事件</p>
 * @author : zhang.bw
 * @date : 2020-07-17 21:37
 **/
public class MyEvent extends ApplicationEvent {

    private User user;

    public MyEvent(Object source, User user) {
        super(source);
        this.user = user;
    }

    public User getUser() {
        return user;
    }

    public void setUser(User user) {
        this.user = user;
    }
}

3.2 自定义监听器

接下来，自定义一个监听器来监听上面定义的 MyEvent 事件，自定义监听器需要实现 ApplicationListener 接口即可。如下：

/**
 * 自定义监听器，监听MyEvent事件
 * @author shengwu ni
 * @date 2018/07/05
 */
@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());

    }
}

然后重写 onApplicationEvent 方法，将自定义的 MyEvent 事件传进来，因为该事件中，我们定义了 User 对象（该对象在实际中就是需要处理的数据），然后就可以使用该对象的信息了。

OK，定义好了事件和监听器之后，需要手动发布事件，这样监听器才能监听到，这需要根据实际业务场景来触发，针对本文的例子，我写个触发逻辑，如下：

/**
 * <h3>springboot-study</h3>
 * <p>UserService类</p>
 * @author : zhang.bw
 * @date : 2020-07-17 21:37
 **/
@Service
public class UserService {

    @Resource
    private ApplicationContext applicationContext;

    /**
     * 发布事件
     * @return
     */
    public User publish() {
        User user = new User(1L, "猿码天地", "公众号【猿码天地】");
        // 发布事件
        MyEvent event = new MyEvent(this, user);
        applicationContext.publishEvent(event);
        return user;
    }
}

在 service 中注入 ApplicationContext，在业务代码处理完之后，通过 ApplicationContext 对象手动发布 MyEvent 事件，这样我们自定义的监听器就能监听到，然后处理监听器中写好的业务逻辑。

最后，在 Controller 中写一个接口来测试一下：

/**
 * <h3>springboot-study</h3>
 * <p>监听器测试Controller类</p>
 * @author : zhang.bw
 * @date : 2020-07-17 21:37
 **/
@RestController
@RequestMapping("/listener")
public class TestController {

    @Resource
    private UserService userService;

    /**
     * 发布事件
     * @return
     */
    @GetMapping("/publish")
    public User publishEvent() {
        return userService.publish();
    }

}

在postman中输入 http://localhost:8080/listener/publish，然后观察一下控制台打印的用户名和密码，即可说明自定义监听器已经生效。

2020-08-09 11:37:39.674  INFO 12488 --- [nio-8080-exec-7] c.b.listener.MyServletRequestListener: session id为：64AA4C131EFABD10AC0EF8EB9F93F7BF
2020-08-09 11:37:39.674  INFO 12488 --- [nio-8080-exec-7] c.b.listener.MyServletRequestListener: request url为：http://localhost:8080/listener/publish
用户名：猿码天地
密码：公众号【猿码天地】
2020-08-09 11:38:31.921  INFO 12488 --- [nio-8080-exec-7] c.b.listener.MyServletRequestListener: request end
2020-08-09 11:38:31.921  INFO 12488 --- [nio-8080-exec-7] c.b.listener.MyServletRequestListener: request域中保存的name值为：公众号【猿码天地】

4. 总结

本节课系统的介绍了监听器原理，以及在 Spring Boot 中如何使用监听器，列举了监听器的三个常用的案例，有很好的实战意义。最后讲解了项目中如何自定义事件和监听器，并结合微服务中常见的场景，给出具体的代码模型，均能运用到实际项目中去，希望读者认真消化。

源码下载地址：关注公众号【猿码天地】并回复 springboot 获取

文章推荐

女博士年薪156万入职华为！网友：实力演绎美貌与智慧并重

Mybatis传多个参数（三种解决方案）

阿里Java开发手册（嵩山版）免费领取

程序员接私活平台，你有技术就有钱！

SpringBoot Utils类注入Bean 详解

滴滴开源项目整理，非常好的实战项目

扫描二维码关注公众号 : 猿码天地

你多学一样本事，就少说一句求人的话，现在的努力，是为了以后的不求别人，实力是最强的底气。记住，活着不是靠泪水博得同情，而是靠汗水赢得掌声。

——《写给程序员朋友》