11.5 使用Spring AsyncRestTemplate对象进行异步请求调用

[vieyahn2017]

AsyncRestTemplate是在Spring4.0中对RestTemplate进行扩展产生的新类，其为客户端提供了异步http请求处理的一种机制，通过返回ListenableFuture对象生成回调机制，以达到异步非阻塞发送http请求。

[vieyahn2017]

使用Spring AsyncRestTemplate对象进行异步请求调用
https://www.cnblogs.com/yzlpersonal/p/5737991.html

直接上代码：

package com.mlxs.common.server.asyncrest;

import org.apache.log4j.Logger;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Controller;
import org.springframework.util.concurrent.ListenableFuture;
import org.springframework.util.concurrent.ListenableFutureCallback;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.client.AsyncRestTemplate;
import org.springframework.web.client.RestTemplate;

/**
 * Asyncrest: AsyncRestTemplate 异步发生请求测试
 *
 * @author mlxs
 * @since 2016/8/4
 */
@Controller
@RequestMapping("/async")
public class AsyncrestController {
    Logger logger = Logger.getLogger(AsyncrestController.class);

    @RequestMapping("/fivetime")
    @ResponseBody
    public String tenTime(){
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return "5秒...";
    }

    /**
     * 同步调用
     * @return
     */
    @RequestMapping("/sync")
    @ResponseBody
    public String sync(){
        //同步调用
        RestTemplate template = new RestTemplate();
        String url = "http://localhost:8080/async/fivetime";//休眠5秒的服务
        String forObject = template.getForObject(url, String.class);
        return "同步调用结束, 结果：" + forObject;
    }

    /**
     * 异步调用
     * @return
     */
    @RequestMapping("/async")
    @ResponseBody
    public String async(){
        AsyncRestTemplate template = new AsyncRestTemplate();
        String url = "http://localhost:8080/async/fivetime";//休眠5秒的服务
        //调用完后立即返回（没有阻塞）
        ListenableFuture<ResponseEntity<String>> forEntity = template.getForEntity(url, String.class);
        //异步调用后的回调函数
        forEntity.addCallback(new ListenableFutureCallback<ResponseEntity<String>>() {
            //调用失败
            @Override
            public void onFailure(Throwable ex) {
                logger.error("=====rest response faliure======");
            }
            //调用成功
            @Override
            public void onSuccess(ResponseEntity<String> result) {
                logger.info("--->async rest response success----, result = "+result.getBody());
            }
        });
        return "异步调用结束";
    }
}

[vieyahn2017]

spring boot，使用AsyncRestTemplate进行异步Http调用，总是返回302
https://segmentfault.com/q/1010000011852396
两个web应用，WebAppA和WebAppB，WebAppA通过AsyncRestTemplate来异步调用WebAppB，调用过程中，用一个类A来互相传递数据，以Json的形式，类A如下：

public class A
    {
        private String str;

        public A()
        {
        }

        public String getStr()
        {
            return str;
        }

        public void setStr(String str)
        {
            this.str = str;
        }
    }

整个过程，就相当于是，WebAppA发过去一个

{
    "str": "123"
}

然后WebAppB把里面的str给改了，在传回给WebAppA

{
    "str": "123POST success"
}

WebAppB作为被调用者的代码是：

@RequestMapping(value = "/", method = RequestMethod.POST)
    public A test_POST(@RequestBody A a)
    {
        a.setStr(a.getStr() + "POST success");
        System.out.println("POST success WebAppB-0.0.1-SNAPSHOT.war!");
        return a;
    }

WebAppB我用PostMan测试过了，可以得到正确的返回的。

然后调用者WebAppA的调用代码是：

//POST
        a = new A();
        a.setStr("123");
        MultiValueMap<String, String> headers = new LinkedMultiValueMap<String, String>();
        headers.add("Content-Type", "application/json;charset=UTF-8");
        HttpEntity<Object> httpEntity = new HttpEntity<>(headers);

        AsyncRestTemplate template = new AsyncRestTemplate();
        String url = "http://127.0.0.1:12001/"
        //调用完后立即返回（没有阻塞）
        ListenableFuture<ResponseEntity<A>> forEntity = template.postForEntity(url, httpEntity, A.class, a);

        //异步调用后的回调函数
        forEntity.addCallback(new ListenableFutureCallback<ResponseEntity<A>>()
        {
            //调用成功
            @Override
            public void onSuccess(ResponseEntity<A> resp)
            {
                a = resp.getBody();
            }

            //调用失败
            @Override
            public void onFailure(Throwable t)
            {
                System.out.println(t.getMessage());
            }
        });

结果，总是会返回302.
如图：
图片描述

（无视url中的路径，路径肯定没有问题，我在tomcat里面配了一个根目录，上面贴的代码体现不到，为了各位看着方便，我就把截图中的给删了，路径测过的，肯定没有问题）

麻烦各位帮我看一下，大概是什么问题导致的，多谢了。

[vieyahn2017]

AsyncRestTemplate 异步服务访问
https://blog.csdn.net/liangwenmail/article/details/78615468

2017年11月23日 15:45:15 要争气 阅读数：1692
需要先配置SpringMVC支持异步访问，需要Servlet 3.0支持，导入3.0包

<dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.0.1</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>jsp-api</artifactId>
            <version>2.2</version>
            <scope>provided</scope>
        </dependency>

web.xml 也需要用3.0的配置，一下不支持 true

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="3.0" xmlns="http://java.sun.com/xml/ns/javaee"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee 
    http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd">
  <display-name>Archetype Created Web Application</display-name>
  <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:spring/spring.xml</param-value>
    </context-param>
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
    
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:spring/spring-mvc1.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
        <async-supported>true</async-supported>
    </servlet>
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

spring配置

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:p="http://www.springframework.org/schema/p" xmlns:context="http://www.springframework.org/schema/context"
    xmlns:util="http://www.springframework.org/schema/util"
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
        http://www.springframework.org/schema/beans/spring-beans-4.1.xsd 
        http://www.springframework.org/schema/context 
        http://www.springframework.org/schema/context/spring-context-4.1.xsd 
        http://www.springframework.org/schema/mvc 
        http://www.springframework.org/schema/mvc/spring-mvc-4.1.xsd
        http://www.springframework.org/schema/util
        http://www.springframework.org/schema/util/spring-util-4.0.xsd">

    <context:component-scan base-package="com.smart.web"/>
    <mvc:annotation-driven />    

</beans>

Controller

package com.smart.web;

import java.util.concurrent.Callable;

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

import com.smart.domain.User;

@RestController
@RequestMapping("/sp1")
public class Sp1Controller {
    @RequestMapping("/m1")
    public String m1(){
        return "1";
    }
    @RequestMapping("/m2")
    public Callable<User> m2(){
        System.out.println("abc");
        return new Callable<User>() {
            @Override
            public User call() throws Exception {
                Thread.sleep(10L*1000);
                User user = new User();
                user.setUserId("1");
                user.setUserName("tom");
                return user;
            }
            
        };
    }
}

m2方法，模拟延时10秒

测试：

package com.smart.test;

import org.junit.Test;
import org.springframework.http.ResponseEntity;
import org.springframework.util.concurrent.ListenableFuture;
import org.springframework.util.concurrent.ListenableFutureCallback;
import org.springframework.web.client.AsyncRestTemplate;

import com.smart.domain.User;

public class Sp1Test {
    
    @Test
    public void m2Test() throws InterruptedException{
        AsyncRestTemplate template = new AsyncRestTemplate();
        
        ListenableFuture<ResponseEntity<User>> future = template.getForEntity("http://localhost:8086/s3/sp1/m2", User.class);
        
        future.addCallback(new ListenableFutureCallback<ResponseEntity<User>>() {

            @Override
            public void onSuccess(ResponseEntity<User> arg0) {
                System.out.println("### handler OK"+arg0.getBody());
                
            }

            @Override
            public void onFailure(Throwable arg0) {
                System.out.println("### handler error"+arg0);
                
            }
        });
        System.out.println("=========no wait");
        Thread.sleep(20L*1000); //为了防止测试提前结束，关闭程序
        
    }  
}

使用junit测试，为防止主程序结束而结束整个执行，需要加入延时20秒

日志：

客户端：

[DEBUG] [2017-11-23 15:43:08,290] [org.springframework.web.client.AsyncRestTemplate main] - Created asynchronous GET request for "http://localhost:8086/s3/sp1/m2"
[DEBUG] [2017-11-23 15:43:08,383] [org.springframework.web.client.RestTemplate main] - Setting request Accept header to [application/json, application/*+json]
=========no wait
[DEBUG] [2017-11-23 15:43:18,411] [org.springframework.web.client.AsyncRestTemplate SimpleAsyncTaskExecutor-1] - Async GET request for "http://localhost:8086/s3/sp1/m2" resulted in 200 (OK)
[DEBUG] [2017-11-23 15:43:18,413] [org.springframework.web.client.RestTemplate SimpleAsyncTaskExecutor-1] - Reading [class com.smart.domain.User] as "application/json;charset=UTF-8" using [org.springframework.http.converter.json.MappingJackson2HttpMessageConverter@66720ae]
### handler OKcom.smart.domain.User@321bc965

服务端

abc
[DEBUG] [2017-11-23 15:43:08,409] [org.springframework.web.context.request.async.WebAsyncManager http-bio-8080-exec-3] - Concurrent handling starting for GET [/s3/sp1/m2]
[DEBUG] [2017-11-23 15:43:08,409] [org.springframework.web.servlet.DispatcherServlet http-bio-8080-exec-3] - Leaving response open for concurrent processing
[DEBUG] [2017-11-23 15:43:18,406] [org.springframework.web.context.request.async.WebAsyncManager MvcAsync2] - Concurrent result value [com.smart.domain.User@646ce1c3] - dispatching request to resume processing
[DEBUG] [2017-11-23 15:43:18,406] [org.springframework.web.servlet.DispatcherServlet http-bio-8080-exec-4] - DispatcherServlet with name 'springmvc' resumed processing GET request for [/s3/sp1/m2]
[DEBUG] [2017-11-23 15:43:18,407] [org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping http-bio-8080-exec-4] - Looking up handler method for path /sp1/m2
[DEBUG] [2017-11-23 15:43:18,407] [org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping http-bio-8080-exec-4] - Returning handler method [public java.util.concurrent.Callable<com.smart.domain.User> com.smart.web.Sp1Controller.m2()]
[DEBUG] [2017-11-23 15:43:18,407] [org.springframework.beans.factory.support.DefaultListableBeanFactory http-bio-8080-exec-4] - Returning cached instance of singleton bean 'sp1Controller'
[DEBUG] [2017-11-23 15:43:18,407] [org.springframework.web.servlet.DispatcherServlet http-bio-8080-exec-4] - Last-Modified value for [/s3/sp1/m2] is: -1
[DEBUG] [2017-11-23 15:43:18,407] [org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter http-bio-8080-exec-4] - Found concurrent result value [com.smart.domain.User@646ce1c3]
[DEBUG] [2017-11-23 15:43:18,408] [org.springframework.web.servlet.mvc.method.annotation.RequestResponseBodyMethodProcessor http-bio-8080-exec-4] - Written [com.smart.domain.User@646ce1c3] as "application/json;charset=UTF-8" using [org.springframework.http.converter.json.MappingJackson2HttpMessageConverter@2eab8f37]
[DEBUG] [2017-11-23 15:43:18,409] [org.springframework.web.servlet.DispatcherServlet http-bio-8080-exec-4] - Null ModelAndView returned to DispatcherServlet with name 'springmvc': assuming HandlerAdapter completed request handling
[DEBUG] [2017-11-23 15:43:18,409] [org.springframework.web.servlet.DispatcherServlet http-bio-8080-exec-4] - Successfully completed request

[vieyahn2017]

我的测试:

    /**
     * 异步调用测试， (大概是没必要用异步?)
     *
     * @param caseInfo
     * @return
     */
    @RequestMapping("/test3")
    public Response asyncTestAddCase (@RequestBody CaseInfo caseInfo)
    {
        Response response = new Response();
        AsyncRestTemplate template = new AsyncRestTemplate();
        MultiValueMap<String, String> headers = new LinkedMultiValueMap<String, String>();
        headers.add("Content-Type", "application/json;charset=UTF-8");
        //headers.add("Content-Type", "application/x-www-form-urlencoded; charset=UTF-8");
        HttpEntity<CaseInfo> httpEntity = new HttpEntity<>(caseInfo, headers);
        ListenableFuture<ResponseEntity<Response>> future = template.postForEntity(getUrl("cases"), httpEntity, Response.class, response);

        future.addCallback(new ListenableFutureCallback<ResponseEntity<Response>>() {
            @Override
            public void onSuccess(ResponseEntity<Response> arg0) {
                System.out.println("### handler OK" + arg0.getBody());
            }

            @Override
            public void onFailure(Throwable arg0) {
                System.out.println("### handler error" + arg0);
            }
        });
        try
        {
            response = future.get().getBody();
        } catch (Exception e)
        {
            response.setCode(ConstantConfig.RESPONSE_FAILURE);
            response.setMsg("连接失败");
        }
        return response;
    }

[vieyahn2017]

使用AsyncRestTemplate对象进行异步请求调用

2018年08月20日 17:23:13 我走路靠风 阅读数：235
最近在公司写了个项目，需要优化下业务逻辑层。由于第三方需要短时间大量调用第三方API，那么之前的同步调用就会特别慢，而且这种等待是不方便用户的、对用户不友好的。你设想下同时附近1000个司机、1000个乘客同时发布行程。同步调用的方法，必须等待一个request请求高德得到返回值后才会执行下一个request，响应时间就会特别慢。

AsyncRestTemplate是在Spring4.0中对RestTemplate进行扩展产生的新类，其为客户端提供了异步http请求处理的一种机制，通过返回ListenableFuture对象生成回调机制，以达到异步非阻塞发送http请求。

下面直接给代码：（休眠5s是模拟第三方）

import org.apache.log4j.Logger;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Controller;
import org.springframework.util.concurrent.ListenableFuture;
import org.springframework.util.concurrent.ListenableFutureCallback;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.client.AsyncRestTemplate;
import org.springframework.web.client.RestTemplate;

/**
 * Asyncrest: AsyncRestTemplate 异步发生请求测试
 *
 * @author mlxs
 * @since 2016/8/4
 */
@Controller
@RequestMapping("/async")
public class AsyncrestController {
    Logger logger = Logger.getLogger(AsyncrestController.class);

    @RequestMapping("/fivetime")
    @ResponseBody
    public String tenTime(){
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return "5秒...";
    }

    /**
     * 同步调用
     * @return
     */
    @RequestMapping("/sync")
    @ResponseBody
    public String sync(){
        //同步调用
        RestTemplate template = new RestTemplate();
        String url = "http://localhost:8080/async/fivetime";//休眠5秒的服务
        String forObject = template.getForObject(url, String.class);
        return "同步调用结束, 结果：" + forObject;
    }

    /**
     * 异步调用
     * @return
     */
    @RequestMapping("/async")
    @ResponseBody
    public String async(){
        AsyncRestTemplate template = new AsyncRestTemplate();
        String url = "http://localhost:8080/async/fivetime";//休眠5秒的服务
        //调用完后立即返回（没有阻塞）
        ListenableFuture<ResponseEntity<String>> forEntity = template.getForEntity(url, String.class);
        //异步调用后的回调函数
        forEntity.addCallback(new ListenableFutureCallback<ResponseEntity<String>>() {
            //调用失败
            @Override
            public void onFailure(Throwable ex) {
                logger.error("=====rest response faliure======");
            }
            //调用成功
            @Override
            public void onSuccess(ResponseEntity<String> result) {
                logger.info("--->async rest response success----, result = "+result.getBody());
            }
        });
        return "异步调用结束";
    }
}

[vieyahn2017]

下面的两篇文章较有深度，一个涉及原理，一个涉及实现扩展

[vieyahn2017]

【Spring-web】AsyncRestTemplate源码学习

2017-01-23 by 安静的下雪天 http://www.cnblogs.com/quiet-snowy-day/p/6343347.html

本篇概要
类说明
类图
简单例子
精辟的内部类

类说明
AsyncRestTemplate 是 Spring中提供异步的客户端HTTP访问的核心类。与RestTemplate类相似，它提供了一些类似的方法，只不过返回类型不是具体的结果，而是ListenableFuture包装类。

通过getRestOperations()方法，对外提供了一个同步的RestTemplate对象，并且通过这个RestTemplate对象来共享错误处理和消息转换。

注意：默认情况下，AsyncRestTemplate依靠标准JDK工具来创建HTTP链接。通过使用构造函数来接收AsyncClientHttpRequestFactory接口的具体实现类对象，你可以选用不同的HTTP库，例如Apache HttpComponents，Netty，以及OkHttp。

• Spring's central class for asynchronous client-side HTTP access. Exposes similar methods as RestTemplate, but returns ListenableFuture wrappers as opposed to concrete results.
  The AsyncRestTemplate exposes a synchronous RestTemplate via the getRestOperations() method and shares its error handler and message converters with that RestTemplate.
  Note: by default AsyncRestTemplate relies on standard JDK facilities to establish HTTP connections. You can switch to use a different HTTP library such as Apache HttpComponents, Netty, and OkHttp by using a constructor accepting an AsyncClientHttpRequestFactory.

类图
类图中省略了一些参数类型及重载的方法，在不影响理解的情况下，保证各要素在一幅图中展现。

简单例子

    private String result = "";

    @Test
    public void testAsyncPost() throws Exception {
        String posturl = "http://xxxxxx";
        String params = "xxxxxx";
        
        MultiValueMap<String, String> headers = new LinkedMultiValueMap<String, String>();
        headers.add("Content-Type", "application/x-www-form-urlencoded; charset=UTF-8");
        
        HttpEntity<Object> hpEntity = new HttpEntity<Object>(params, headers);
        AsyncRestTemplate asyncRt = new AsyncRestTemplate();
        
        ListenableFuture<ResponseEntity<String>> future = asyncRt.postForEntity(posturl, hpEntity, String.class);
        
        future.addCallback(new ListenableFutureCallback<ResponseEntity<String>>() {
            public void onSuccess(ResponseEntity<String> resp) {
                result = resp.getBody();
            }
            public void onFailure(Throwable t) {
                System.out.println(t.getMessage());
            }
        });
        System.out.println(result);
    }

精辟的内部类
AsyncRequestCallbackAdapter源码

我觉得AsyncRestTemplate类巧妙之处就在于复用了RestTemplate类，而最精辟之处就是AsyncRequestCallbackAdapter内部类（名字太长，下文简称Adapter）。从这个内部类的名字就可以知道，此处使用了适配器设计模式。适配器模式的设计意图就是在两个不兼容的接口之间建立起沟通的桥梁。
那么，这里是如何将两个类连接起来的呢？答案关键在于匿名类的使用。

Adapter类中的成员变量adaptee，实际上引用的是RestTemplate中的RequestCallback内部类对象。
Adapter.doWithRequest方法的参数类型是AsyncClientHttpRequest，而RequestCallback.doWithRequest方法的参数类型是ClientHttpRequest。
通过创建匿名类对象，重写接口方法，将各方法的返回指向AsyncClientHttpRequest参数对象。
在Adapter.doWithRequest方法中，以刚刚创建的匿名类对象作为参数，直接调用*RequestCallback.doWithRequest方法。
这个匿名类对象就是两个方法之间的桥梁。

平时工作中匿名类用的比较少，刚看这段源码的时候真的有点蒙，接口怎么能直接new一个对象了呢？忍不住开始怀疑人生-_-|||
baidu之后明白了，这不正是匿名类嘛~~~只不过它看起来像new了一个接口的对象，但是实际上编译后会自动生成一个实现类。

其实，上面代码写成这样↓↓↓就容易理解了。由此可以看出，使用匿名类省略了一个实现类的定义和开销。

    @Override
    public void doWithRequest(final AsyncClientHttpRequest request) throws IOException {
        if (this.adaptee != null) {
            this.adaptee.doWithRequest(new ClientHttpRequestImpl(request));
        }
    }
    private class ClientHttpRequestImpl implements ClientHttpRequest{
        
        private AsyncClientHttpRequest request;
        
        public ClientHttpRequestImpl(AsyncClientHttpRequest request){
            this.request = request;
        }
        @Override
        public ClientHttpResponse execute() throws IOException {
            throw new UnsupportedOperationException("execute not supported");
        }
        @Override
        public HttpMethod getMethod() {
            return request.getMethod();
        }
        @Override
        public URI getURI() {
            return request.getURI();
        }
        @Override
        public HttpHeaders getHeaders() {
            return request.getHeaders();
        }
        @Override
        public OutputStream getBody() throws IOException {
            return request.getBody();
        }
    }

[vieyahn2017]

基于AsyncRestTemplate异步HTTP请求的一种轻量级技术实现

置顶 2016年05月16日 21:50:52 皮斯特劳沃 阅读数：20389
版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/pistolove/article/details/51428562
本文是在学习中的总结，欢迎转载但请注明出处：http://blog.csdn.net/pistolove/article/details/51428562

Ⅰ、前言

在上一篇博客中讲述ListenableFuture通过异步回调机制来实现请求的非阻塞。通常情况下，客户端获取数据并不会只发送一次http请求，可能会有多个http请求。这样，使用上一篇博客中的方法，就会产生大量的冗余代码，因为请求处理的代码除了一些参数不同外，其它地方都大致相同。我们发现不同请求之间的区别在于：请求地址的不同、响应类型的不同，可能还会有额外请求参数的不同。我们可以将请求数据和响应数据进行封装，这样，只需要一个字段来标识每一次http请求属于哪一个业务就可以实现批量发送http请求，整个过程是异步非阻塞的，一旦获取到数据就会触发回调函数，进而获取到响应数据，最后再进行业务逻辑相关处理