使用Callable或DeferredResult实现springmvc的异步请求

时间：2022-10-29 11:18:11

使用Callable实现springmvc的异步请求

如果一个请求中的某些操作耗时很长，会一直占用线程。这样的请求多了，可能造成线程池被占满，新请求无法执行的情况。这时，可以考虑使用异步请求，即主线程只返回Callable类型，然后去处理新请求，耗时长的业务逻辑由其他线程执行。

下面是一个示例demo，用线程睡眠来模拟耗时操作，springmvc配置以及视图解析器、拦截器等组件的注册略，详见https://www.cnblogs.com/dubhlinn/p/10808879.html博文，本文只展示controller组件，欢迎页面welcome.jsp略。

package cn.monolog.annabelle.springmvc.controller;

import org.springframework.stereotype.Controller;

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

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

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

import java.util.concurrent.Callable;

/**

 * 处理器，用于测试springmvc异步请求

 * created on 2019-05-12

 */

@Controller

@RequestMapping(value = "/asyn")

public class AsynController {

    /**

     * 使用Callable发送异步请求进入欢迎页面

     * @return

     */

    @RequestMapping(value = "/welcome")

    public Callable<String> welcome() {

        //打印主线程

        System.out.println("主线程" + Thread.currentThread().getName() + "开始:" + System.currentTimeMillis());

        //使用使用Callable获取页面路径

        Callable<String> path = new Callable() {

            @Override

            public String call() throws Exception {

                //打印副线程

                System.out.println("副线程" + Thread.currentThread().getName() + "开始:" + System.currentTimeMillis());

                //线程休眠5秒钟

                Thread.sleep(5000);

                //打印副线程

                System.out.println("副线程" + Thread.currentThread().getName() + "结束:" + System.currentTimeMillis());

                //返回欢迎页面的url

                return "welcome";

            }

        };

        //打印主线程

        System.out.println("主线程" + Thread.currentThread().getName() + "结束:" + System.currentTimeMillis());

        //返回页面

        return path;

    }

}

在浏览器访问/asyn/welcome，会延时5秒钟才进入欢迎页面，然后来看服务器日志，发现是这样的：

使用Callable或DeferredResult实现springmvc的异步请求

1. 主线程开始、结束几乎是同一时刻；

2. 副线程结束比开始晚了5秒多，是在执行线程休眠，即模拟"耗时多的业务逻辑"；

3. 拦截器的preHandle方法执行了两次。

1和2都符合我们之前的描述和预期，但是为什么拦截器的preHandle方法会执行两次？来看一下springmvc异步请求的原理：

1. 当处理器的方法返回Callable(以及其他异步形式的返回值，例如DeferredResult)时，springmvc会将

Callable的实现方法交给TaskExecutor在一个隔离的线程中执行；

2. 同时，DispatcherServlet(前端控制器)和所有的拦截器退出web容器的线程，但是response仍然保持打开状态；

3. 当Callable的实现方法产生返回值时，springmvc会将请求重新派发给容器；

4. DispatcherServlet(前端控制器)重新接收请求，并根据Callable的返回值进行视图渲染或者返回数据。

因此，第一次请求之前执行了preHandle方法，当前端控制器接收到请求之后，发现返回值是Callable，

拦截器就退出主线程了，也就没有了后面的postHandle和afterCompletion方法。

使用DeferredResult实现springmvc的异步请求

实际项目中的异步请求，可能在不同的接口中执行，甚至可能在不同的应用中执行，这时Callable就无法实现。

springmvc提供了另一种异步返回类型：DeferredResult，其主要使用步骤是：

1. 在主线程中新建DeferredResult实例，然后直接返回这个实例，主线程结束；

2. 副线程在主线程新建的DeferredResult实例中设置值(调用setResult方法)；

3. 这时，主线程获取到副线程在DeferredResult实例中设置的值，重新接收请求、视图渲染或返回数据。

下面是一个示例demo，我们用一个自定义队列来模拟DeferredResult的存取。

自定义队列

package cn.monolog.annabelle.springmvc.queue;

import org.springframework.web.context.request.async.DeferredResult;

import java.util.Queue;

import java.util.concurrent.ConcurrentLinkedQueue;

/**

 * 自定义队列，用于存储DeferredResult

 * created on 2019-05-12

 */

public class DeferredResultQueue {

    //队列

    private static Queue<DeferredResult> deferredResultQueue = new ConcurrentLinkedQueue<>();

    /**

     * 添加DeferredResult进队列

     * @param deferredResult

     */

    public static void save(DeferredResult deferredResult) {

        deferredResultQueue.add(deferredResult);

    }

    /**

     * 从队列中取出第一个元素并删除

     * @return

     */

    public static DeferredResult get() {

        return deferredResultQueue.poll();

    }

}

controller组件

package cn.monolog.annabelle.springmvc.controller;

import cn.monolog.annabelle.springmvc.queue.DeferredResultQueue;

import org.springframework.stereotype.Controller;

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

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

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

import org.springframework.web.context.request.async.DeferredResult;

import java.util.UUID;

/**

 * 处理器，用于测试springmvc异步请求

 * created on 2019-05-12

 */

@Controller

@RequestMapping(value = "/asyn")

public class AsynController {

    /**

     * 异步创建订单

     * 只返回DeferredResult，并不真正创建订单

     * @return

     */

    @RequestMapping("/createOrder")

    @ResponseBody

    public DeferredResult<String> createOrder() {

        //新建DeferredResult实例，并保存到队列中，参数的意义是最长等待5秒，否则返回值自动设置为timeout

        DeferredResult<String> deferredResult = new DeferredResult<>((long)5000, "timeout");

        DeferredResultQueue.save(deferredResult);

        //返回

        return deferredResult;

    }

    /**

     * 真正的创建订单

     * @return

     */

    @RequestMapping("/create")

    @ResponseBody

    public String createOrderActioin() {

        //随机生成订单号

        String orderNum = UUID.randomUUID().toString();

        //从队列中取出DeferredResult

        DeferredResult deferredResult = DeferredResultQueue.get();

        //向DeferredResult中存值

        deferredResult.setResult(orderNum);

        //返回

        return orderNum;

    }

}

直接在浏览器访问/asyn/createOrder，因为并没有线程为DeferredResult存值，因此等待5秒之后，返回timeout。

如果在5秒之内，在浏览器的另一个标签访问/asyn/create，会发现第一个标签返回了第二个接口创建的订单编号。

相关文章