Question

我必须使用 Spring Boot 2.0.5

从我的Web应用程序构建中调用远程REST端点

我可以使用HttpURLConnection，尽管当Spring使用RestTemplate时，我检查了它的内容，发现它很快就会被弃用：

https://docs.spring.io/spring/docs/current/javadoc-api/org/springframework/web/client/RestTemplate.html

此页面还提到了通过HTTP调用的新类。可以同步和异步两种方式使用它：

WebClient通过以下方式提供了RestTemplate的现代替代方案：对同步和异步以及流的有效支持场景

问题是我在javadoc中没有看到WebClient关于同步工作方式的任何注释：

https://docs.spring.io/spring/docs/current/javadoc-api/org/springframework/web/reactive/function/client/WebClient.html

WebClient的另一个问题-要使其正常工作，我需要在类路径https://docs.spring.io/spring-boot/docs/current/reference/html/boot-features-webclient.html中安装WebFlux

但是，由于它以同步方式构建，这将使我的Spring Security配置失败。据我了解，一旦拥有WebFlux，Spring Security将使用异步配置。

如何使用Spring进行对远程端点的http调用，还是应该避免并使用HttpURLConnection类（或Apache的库）？

更新

WebFlux似乎不会以同步方式对Spring Security buit造成任何问题。

还请注意，我的应用程序不是响应式的-它是多线程的（很抱歉，如果我之前对此不太清楚）。我有交易，因此被动方式似乎不适合我的情况。

Answer 1

您可以使用Spring org.springframework.web.client.AsyncRestTemplate进行异步Rest调用。以下是我用于同步和异步调用的实用程序之一。下面是Rest实用程序和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);
}

Answer 2

您可以使用Spring Cloud提供的技术。例如，请求其他Web服务的最佳方法是使用Feign Client。对于处理Hystrix的异常。

通过Spring Boot http调用远程Web服务

2 个答案: