You can use Spring org.springframework.web.client.AsyncRestTemplate for async Rest call. Below is one of the Utility I have used for Sync and Async call. Below are the Rest utility and CallBack for Async.
/**
*
*/
package com.debopam.services.policyenquiryservice.rest.util;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpMethod;
import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import org.springframework.util.concurrent.ListenableFuture;
import org.springframework.web.client.AsyncRestTemplate;
/**
* @author dpoddar
*
*/
public class RestUtil {
private String url;
private HttpMethod httpMethod;
private MultiValueMap<String, String> headers;
private Map<String, Object> params;
private Class<?> responseType;
private List<Object> uriVariables;
private HttpEntity<Object> httpEntity;
//AsyncRestTemplate asyncRestTemplate = (AsyncRestTemplate) ContextProvider.getBean("customAsyncRestTemplate");
/**
* @param url
* @param httpMethod
* @param headers
* @param params
* @param responseType
* @param uriVariables
*/
public RestUtil(String url, HttpMethod httpMethod, MultiValueMap<String, String> headers,
Map<String, Object> params, Class<?> responseType, List<Object> uriVariables) {
super();
this.url = url;
this.httpMethod = httpMethod;
this.headers = headers;
this.params = params;
this.responseType = responseType;
this.uriVariables = uriVariables;
}
@SuppressWarnings({ "rawtypes", "unchecked" })
public Foo callServicesync(RestTemplate restTemplate) {
//DO a sync Call
HttpEntity<Foo> request = new HttpEntity<>(new Foo("bar"));
Foo foo = restTemplate.postForObject(fooResourceUrl, request, Foo.class);
}
@SuppressWarnings({ "rawtypes", "unchecked" })
public void callServiceAsync(AsyncRestTemplate asyncRestTemplate,ResponseCallBack responseCallBack) {
if(asyncRestTemplate.getMessageConverters().isEmpty()){
asyncRestTemplate.getMessageConverters().add(new MappingJackson2HttpMessageConverter());
}
ListenableFuture restCall = null;
if(null != uriVariables){
restCall = asyncRestTemplate.exchange(this.url, this.httpMethod, this.httpEntity, responseType,uriVariables);
}else{
restCall = asyncRestTemplate.exchange(this.url, this.httpMethod, this.httpEntity, responseType);
}
restCall.addCallback(responseCallBack);
}
public static class RestUtilBuilder {
private String url;
private HttpMethod httpMethod;
private MultiValueMap<String, String> headers;
private Map<String, Object> params;
private Class<?> responseType;
private List<Object> uriVariables;
public RestUtilBuilder url(String url) {
this.url = url;
return this;
}
public RestUtilBuilder httpMethod(HttpMethod httpMethod) {
this.httpMethod = httpMethod;
return this;
}
public RestUtilBuilder headers(MultiValueMap<String, String> headers) {
this.headers = headers;
return this;
}
public RestUtilBuilder addHeader(String key,String value) {
if(null == this.headers){
this.headers = new LinkedMultiValueMap<>();
}
this.headers.add(key, value);
return this;
}
public RestUtilBuilder params(Map<String, Object> params) {
this.params = params;
return this;
}
public RestUtilBuilder addparam(String key,Object value) {
if(null == this.params){
this.params = new HashMap<>();
}
this.params.put(key, value);
return this;
}
public RestUtilBuilder responseType(Class<?> responseType) {
this.responseType = responseType;
return this;
}
public RestUtilBuilder uriVariables(List<Object> uriVariables) {
this.uriVariables = uriVariables;
return this;
}
public RestUtil build() {
RestUtil util = new RestUtil(url, httpMethod, headers, params, responseType, uriVariables);
util.httpEntity = new HttpEntity<Object>(util.params, util.headers);
return util;
}
}
public static RestUtilBuilder restUtil() {
return new RestUtilBuilder();
}
}
package com.debopam.services.policyenquiryservice.rest.util;
import java.util.Map;
import java.util.concurrent.CountDownLatch;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.cloud.sleuth.Span;
import org.springframework.cloud.sleuth.Tracer;
import org.springframework.http.ResponseEntity;
import org.springframework.util.concurrent.ListenableFutureCallback;
/**
Response Call back for Async Call
*/
public abstract class ResponseCallBack<T> implements ListenableFutureCallback<ResponseEntity<T>>{
private static final Logger logger = LoggerFactory.getLogger(ResponseCallBack.class.getName());
Map<String,Object> inputs;
public ResponseCallBack(Map<String,Object> inputs){
this.inputs = inputs;
}
@Override
public void onSuccess(ResponseEntity<T> stringResponseEntity) {
onCallSuccess(this.inputs,stringResponseEntity);
}
@Override
public void onFailure(Throwable ex) {
logger.error(ex.getMessage(),ex);
onCallFailure(this.inputs, ex);
}
//Do your stuff
public abstract void onCallSuccess(Map<String,Object> inputs,ResponseEntity<T> stringResponseEntity);
public abstract void onCallFailure(Map<String,Object> inputs,Throwable ex);
}
//Example
private void createRestUtilForAsync()
{
RestUtil restUtil = RestUtil.restUtil().url(url).addHeader("Accept", "application/json").addHeader("Content-Type", "application/json").addparam("xxx", 10).addparam("yyyy", "").addparam("zzz", "dsadsa").httpMethod(HttpMethod.POST).responseType(Policy.class).build();
//create inputs
ResponseCallBack<Policy> responseCallBack = new ResponseContractValuesCallBack(inputs);
//asyncRestTemplate is autowired in the class
restUtil.callServiceAsync(this.asyncRestTemplate, responseCallBack);
}
private void createRestUtilForSync()
{
RestUtil restUtil = RestUtil.restUtil().url(url).addHeader("Accept", "application/json").addHeader("Content-Type", "application/json").addparam("xxx", 10).addparam("yyyy", "").addparam("zzz", "dsadsa").httpMethod(HttpMethod.POST).responseType(Policy.class).build();
//asyncRestTemplate is autowired in the class
Foo foo = restUtil.callServiceAsync(this.restTemplate);
}
