【WEB系列】异步请求知识点与使用姿势小结

文章目录

1. I. 异步请求
   1. 1. 异步请求描述
   2. 2. 特点
   3. 3. 场景分析
2. II. 使用姿势
   1. 1. AsyncContext
   2. 2. Callable
   3. 3. WebAsyncTask
   4. 4. DeferredResult
3. II. 其他
   1. 0. 项目
   2. 1. 一灰灰Blog

在Servlet3.0就引入了异步请求的支持，但是在实际的业务开发中，可能用过这个特性的童鞋并不多？

本篇博文作为异步请求的扫盲和使用教程，将包含以下知识点

• 什么是异步请求，有什么特点，适用场景
• 四种使用姿势：
  • AsyncContext方式
  • Callable
  • WebAsyncTask
  • DeferredResult

I. 异步请求

异步对于我们而言，应该属于经常可以听到的词汇了，在实际的开发中多多少少都会用到，那么什么是异步请求呢

1. 异步请求描述

先介绍一下同步与异步：

一个正常调用，吭哧吭哧执行完毕之后直接返回，这个叫同步；

接收到调用，自己不干，新开一个线程来做，主线程自己则去干其他的事情，等后台线程吭哧吭哧的跑完之后，主线程再返回结果，这个就叫异步

异步请求：

我们这里讲到的异步请求，主要是针对web请求而言，后端响应请求的一种手段，同步/异步对于前端而言是无感知、无区别的

同步请求，后端接收到请求之后，直接在处理请求线程中，执行业务逻辑，并返回

异步请求，后端接收到请求之后，新开一个线程，来执行业务逻辑，释放请求线程，避免请求线程被大量耗时的请求沾满，导致服务不可用

2. 特点

通过上面两张图，可以知道异步请求的最主要特点

• 业务线程，处理请求逻辑
• 请求处理线程立即释放，通过回调处理线程返回结果

3. 场景分析

从特点出发，也可以很容易看出异步请求，更适用于耗时的请求，快速的释放请求处理线程，避免web容器的请求线程被打满，导致服务不可用

举一个稍微极端一点的例子，比如我以前做过的一个多媒体服务，提供图片、音视频的编辑，这些服务接口有同步返回结果的也有异步返回结果的；同步返回结果的接口有快有慢，大部分耗时可能<10ms，而有部分接口耗时则在几十甚至上百

这种场景下，耗时的接口就可以考虑用异步请求的方式来支持了，避免占用过多的请求处理线程，影响其他的服务

II. 使用姿势

接下来介绍四种异步请求的使用姿势，原理一致，只是使用的场景稍有不同

1. AsyncContext

在Servlet3.0+之后就支持了异步请求，第一种方式比较原始，相当于直接借助Servlet的规范来实现，当然下面的case并不是直接创建一个servlet，而是借助AsyncContext来实现

@RestController
@RequestMapping(path = "servlet")
public class ServletRest {

    @GetMapping(path = "get")
    public void get(HttpServletRequest request) {
        AsyncContext asyncContext = request.startAsync();
        asyncContext.addListener(new AsyncListener() {
            @Override
            public void onComplete(AsyncEvent asyncEvent) throws IOException {
                System.out.println("操作完成:" + Thread.currentThread().getName());
            }

            @Override
            public void onTimeout(AsyncEvent asyncEvent) throws IOException {
                System.out.println("超时返回!!!");
                asyncContext.getResponse().setCharacterEncoding("utf-8");
                asyncContext.getResponse().setContentType("text/html;charset=UTF-8");
                asyncContext.getResponse().getWriter().println("超时了！！！!");
            }

            @Override
            public void onError(AsyncEvent asyncEvent) throws IOException {
                System.out.println("出现了m某些异常");
                asyncEvent.getThrowable().printStackTrace();

                asyncContext.getResponse().setCharacterEncoding("utf-8");
                asyncContext.getResponse().setContentType("text/html;charset=UTF-8");
                asyncContext.getResponse().getWriter().println("出现了某些异常哦！！！!");
            }

            @Override
            public void onStartAsync(AsyncEvent asyncEvent) throws IOException {
                System.out.println("开始执行");
            }
        });

        asyncContext.setTimeout(3000L);
        asyncContext.start(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(Long.parseLong(request.getParameter("sleep")));
                    System.out.println("内部线程：" + Thread.currentThread().getName());
                    asyncContext.getResponse().setCharacterEncoding("utf-8");
                    asyncContext.getResponse().setContentType("text/html;charset=UTF-8");
                    asyncContext.getResponse().getWriter().println("异步返回!");
                    asyncContext.getResponse().getWriter().flush();
                    // 异步完成，释放
                    asyncContext.complete();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });

        System.out.println("主线程over!!! " + Thread.currentThread().getName());
    }
}

完整的实现如上，简单的来看一下一般步骤

• javax.servlet.ServletRequest#startAsync()获取AsyncContext
• 添加监听器 asyncContext.addListener(AsyncListener)（这个是可选的）
  • 用户请求开始、超时、异常、完成时回调
• 设置超时时间 asyncContext.setTimeout(3000L) （可选）
• 异步任务asyncContext.start(Runnable)

2. Callable

相比较于上面的复杂的示例，SpringMVC可以非常easy的实现，直接返回一个Callable即可

@RestController
@RequestMapping(path = "call")
public class CallableRest {

    @GetMapping(path = "get")
    public Callable<String> get() {
        Callable<String> callable = new Callable<String>() {
            @Override
            public String call() throws Exception {
                System.out.println("do some thing");
                Thread.sleep(1000);
                System.out.println("执行完毕，返回!!!");
                return "over!";
            }
        };

        return callable;
    }


    @GetMapping(path = "exception")
    public Callable<String> exception() {
        Callable<String> callable = new Callable<String>() {
            @Override
            public String call() throws Exception {
                System.out.println("do some thing");
                Thread.sleep(1000);
                System.out.println("出现异常，返回!!!");
                throw new RuntimeException("some error!");
            }
        };

        return callable;
    }
}

请注意上面的两种case，一个正常返回，一个业务执行过程中，抛出来异常

分别请求，输出如下

# http://localhost:8080/call/get
do some thing
执行完毕，返回!!!

异常请求: http://localhost:8080/call/exception

do some thing
出现异常，返回!!!
2020-03-29 16:12:06.014 ERROR 24084 --- [nio-8080-exec-5] o.a.c.c.C.[.[.[/].[dispatcherServlet]    : Servlet.service() for servlet [dispatcherServlet] threw exception

java.lang.RuntimeException: some error!
	at com.git.hui.boot.async.rest.CallableRest$2.call(CallableRest.java:40) ~[classes/:na]
	at com.git.hui.boot.async.rest.CallableRest$2.call(CallableRest.java:34) ~[classes/:na]
	at org.springframework.web.context.request.async.WebAsyncManager.lambda$startCallableProcessing$4(WebAsyncManager.java:328) ~[spring-web-5.2.1.RELEASE.jar:5.2.1.RELEASE]
	at java.util.concurrent.Executors$RunnableAdapter.call(Executors.java:511) ~[na:1.8.0_171]
	at java.util.concurrent.FutureTask.run$$$capture(FutureTask.java:266) ~[na:1.8.0_171]
	at java.util.concurrent.FutureTask.run(FutureTask.java) ~[na:1.8.0_171]
	at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149) ~[na:1.8.0_171]
	at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624) ~[na:1.8.0_171]
	at java.lang.Thread.run(Thread.java:748) [na:1.8.0_171]

3. WebAsyncTask

callable的方式，非常直观简单，但是我们经常关注的超时+异常的处理却不太好，这个时候我们可以用WebAsyncTask，实现姿势也很简单，包装一下callable，然后设置各种回调事件即可

@RestController
@RequestMapping(path = "task")
public class WebAysncTaskRest {

    @GetMapping(path = "get")
    public WebAsyncTask<String> get(long sleep, boolean error) {
        Callable<String> callable = () -> {
            System.out.println("do some thing");
            Thread.sleep(sleep);

            if (error) {
                System.out.println("出现异常，返回!!!");
                throw new RuntimeException("异常了!!!");
            }

            return "hello world";
        };

        // 指定3s的超时
        WebAsyncTask<String> webTask = new WebAsyncTask<>(3000, callable);
        webTask.onCompletion(() -> System.out.println("over!!!"));

        webTask.onTimeout(() -> {
            System.out.println("超时了");
            return "超时返回!!!";
        });

        webTask.onError(() -> {
            System.out.println("出现异常了!!!");
            return "异常返回";
        });

        return webTask;
    }
}

4. DeferredResult

DeferredResult与WebAsyncTask最大的区别就是前者不确定什么时候会返回结果，

DeferredResult的这个特点，可以用来做实现很多有意思的东西，如后面将介绍的SseEmitter就用到了它

下面给出一个实例

@RestController
@RequestMapping(path = "defer")
public class DeferredResultRest {

    private Map<String, DeferredResult> cache = new ConcurrentHashMap<>();

    @GetMapping(path = "get")
    public DeferredResult<String> get(String id) {
        DeferredResult<String> res = new DeferredResult<>();
        cache.put(id, res);

        res.onCompletion(new Runnable() {
            @Override
            public void run() {
                System.out.println("over!");
            }
        });
        return res;
    }

    @GetMapping(path = "pub")
    public String publish(String id, String content) {
        DeferredResult<String> res = cache.get(id);
        if (res == null) {
            return "no consumer!";
        }

        res.setResult(content);
        return "over!";
    }
}

在上面的实例中，用户如果先访问http://localhost:8080/defer/get?id=yihuihui，不会立马有结果，直到用户再次访问http://localhost:8080/defer/pub?id=yihuihui&content=哈哈时，前面的请求才会有结果返回

那么这个可以设置超时么，如果一直把前端挂住，貌似也不太合适吧

• 在构造方法中指定超时时间: new DeferredResult<>(3000L)
• 设置全局的默认超时时间

@Configuration
@EnableWebMvc
public class WebConf implements WebMvcConfigurer {

    @Override
    public void configureAsyncSupport(AsyncSupportConfigurer configurer) {
        // 超时时间设置为60s
        configurer.setDefaultTimeout(TimeUnit.SECONDS.toMillis(10));
    }
}

II. 其他

0. 项目

相关博文

• 007-优化web请求三-异步调用【WebAsyncTask】
• 高性能关键技术之—体验Spring MVC的异步模式（Callable、WebAsyncTask、DeferredResult） 基础使用篇

系列博文

• 200105-SpringBoot系列web篇之自定义返回Http-Code的n种姿势
• 191222-SpringBoot系列教程web篇之自定义请求匹配条件RequestCondition
• 191206-SpringBoot系列教程web篇Listener四种注册姿势
• 191122-SpringBoot系列教程web篇Servlet 注册的四种姿势
• 191120-SpringBoot系列教程Web篇之开启GZIP数据压缩
• 191018-SpringBoot系列教程web篇之过滤器Filter使用指南扩展篇
• 191016-SpringBoot系列教程web篇之过滤器Filter使用指南
• 191012-SpringBoot系列教程web篇之自定义异常处理HandlerExceptionResolver
• 191010-SpringBoot系列教程web篇之全局异常处理
• 190930-SpringBoot系列教程web篇之404、500异常页面配置
• 190929-SpringBoot系列教程web篇之重定向
• 190913-SpringBoot系列教程web篇之返回文本、网页、图片的操作姿势
• 190905-SpringBoot系列教程web篇之中文乱码问题解决
• 190831-SpringBoot系列教程web篇之如何自定义参数解析器
• 190828-SpringBoot系列教程web篇之Post请求参数解析姿势汇总
• 190824-SpringBoot系列教程web篇之Get请求参数解析姿势汇总
• 190822-SpringBoot系列教程web篇之Beetl环境搭建
• 190820-SpringBoot系列教程web篇之Thymeleaf环境搭建
• 190816-SpringBoot系列教程web篇之Freemaker环境搭建
• 190421-SpringBoot高级篇WEB之websocket的使用说明
• 190327-Spring-RestTemplate之urlencode参数解析异常全程分析
• 190317-Spring MVC之基于java config无xml配置的web应用构建
• 190316-Spring MVC之基于xml配置的web应用构建
• 190213-SpringBoot文件上传异常之提示The temporary upload location xxx is not valid

源码

• 工程：https://github.com/liuyueyi/spring-boot-demo
• 项目源码: https://github.com/liuyueyi/spring-boot-demo/blob/master/spring-boot/219-web-asyn

1. 一灰灰Blog

尽信书则不如，以上内容，纯属一家之言，因个人能力有限，难免有疏漏和错误之处，如发现bug或者有更好的建议，欢迎批评指正，不吝感激

下面一灰灰的个人博客，记录所有学习和工作中的博文，欢迎大家前去逛逛

• 一灰灰Blog个人博客 https://blog.hhui.top
• 一灰灰Blog-Spring专题博客 http://spring.hhui.top

打赏 如果觉得我的文章对您有帮助，请随意打赏。

微信打赏

支付宝打赏