springboot restTemplate 使用说明

最新推荐文章于 2023-07-03 11:14:18 发布
最新推荐文章于 2023-07-03 11:14:18 发布
阅读量597 收藏
点赞数
分类专栏： restTemplate
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43931625/article/details/107005790
版权

springboot restTemplate 使用说明

 

 

***********************

相关类与接口

 

RestTemplate

public class RestTemplate extends InterceptingHttpAccessor implements RestOperations {
    private static final boolean romePresent;
    private static final boolean jaxb2Present;
    private static final boolean jackson2Present;
    private static final boolean jackson2XmlPresent;
    private static final boolean jackson2SmilePresent;
    private static final boolean jackson2CborPresent;
    private static final boolean gsonPresent;
    private static final boolean jsonbPresent;
    private final List<HttpMessageConverter<?>> messageConverters;
    private ResponseErrorHandler errorHandler;
    private UriTemplateHandler uriTemplateHandler;
    private final ResponseExtractor<HttpHeaders> headersExtractor;


***********
构造方法

    public RestTemplate() {
        this.messageConverters = new ArrayList();
        this.errorHandler = new DefaultResponseErrorHandler();
        this.headersExtractor = new RestTemplate.HeadersExtractor();
        this.messageConverters.add(new ByteArrayHttpMessageConverter());
        this.messageConverters.add(new StringHttpMessageConverter());
        this.messageConverters.add(new ResourceHttpMessageConverter(false));

        try {
            this.messageConverters.add(new SourceHttpMessageConverter());
        } catch (Error var2) {
        }

        this.messageConverters.add(new AllEncompassingFormHttpMessageConverter());
        if (romePresent) {
            this.messageConverters.add(new AtomFeedHttpMessageConverter());
            this.messageConverters.add(new RssChannelHttpMessageConverter());
        }

        if (jackson2XmlPresent) {
            this.messageConverters.add(new MappingJackson2XmlHttpMessageConverter());
        } else if (jaxb2Present) {
            this.messageConverters.add(new Jaxb2RootElementHttpMessageConverter());
        }

        if (jackson2Present) {
            this.messageConverters.add(new MappingJackson2HttpMessageConverter());
        } else if (gsonPresent) {
            this.messageConverters.add(new GsonHttpMessageConverter());
        } else if (jsonbPresent) {
            this.messageConverters.add(new JsonbHttpMessageConverter());
        }

        if (jackson2SmilePresent) {
            this.messageConverters.add(new MappingJackson2SmileHttpMessageConverter());
        }

        if (jackson2CborPresent) {
            this.messageConverters.add(new MappingJackson2CborHttpMessageConverter());
        }

        this.uriTemplateHandler = initUriTemplateHandler();
    }

    public RestTemplate(ClientHttpRequestFactory requestFactory) {
        this();
        this.setRequestFactory(requestFactory);
    }

    public RestTemplate(List<HttpMessageConverter<?>> messageConverters) {
        this.messageConverters = new ArrayList();
        this.errorHandler = new DefaultResponseErrorHandler();
        this.headersExtractor = new RestTemplate.HeadersExtractor();
        this.validateConverters(messageConverters);
        this.messageConverters.addAll(messageConverters);
        this.uriTemplateHandler = initUriTemplateHandler();
    }


***********
普通方法

    private static DefaultUriBuilderFactory initUriTemplateHandler() {
        DefaultUriBuilderFactory uriFactory = new DefaultUriBuilderFactory();
        uriFactory.setEncodingMode(EncodingMode.URI_COMPONENT);
        return uriFactory;
    }

    public void setMessageConverters(List<HttpMessageConverter<?>> messageConverters) {
    private void validateConverters(List<HttpMessageConverter<?>> messageConverters) {
    public List<HttpMessageConverter<?>> getMessageConverters() {

    public void setErrorHandler(ResponseErrorHandler errorHandler) {
    public ResponseErrorHandler getErrorHandler() {

    public void setDefaultUriVariables(Map<String, ?> uriVars) {

    public void setUriTemplateHandler(UriTemplateHandler handler) {
    public UriTemplateHandler getUriTemplateHandler() {



************
get 方法

    public <T> T getForObject(String url, Class<T> responseType, Object... uriVariables) throws RestClientException {
    public <T> T getForObject(String url, Class<T> responseType, Map<String, ?> uriVariables) throws RestClientException {
    public <T> T getForObject(URI url, Class<T> responseType) throws RestClientException {

    public <T> ResponseEntity<T> getForEntity(String url, Class<T> responseType, Object... uriVariables) throws RestClientException {
    public <T> ResponseEntity<T> getForEntity(String url, Class<T> responseType, Map<String, ?> uriVariables) throws RestClientException {
    public <T> ResponseEntity<T> getForEntity(URI url, Class<T> responseType) throws RestClientException {



************
post 方法

    public URI postForLocation(String url, @Nullable Object request, Object... uriVariables) throws RestClientException {
    public URI postForLocation(String url, @Nullable Object request, Map<String, ?> uriVariables) throws RestClientException {
    public URI postForLocation(URI url, @Nullable Object request) throws RestClientException {


    public <T> T postForObject(String url, @Nullable Object request, Class<T> responseType, Object... uriVariables) throws RestClientException {
    public <T> T postForObject(String url, @Nullable Object request, Class<T> responseType, Map<String, ?> uriVariables) throws RestClientException {
    public <T> T postForObject(URI url, @Nullable Object request, Class<T> responseType) throws RestClientException {

    public <T> ResponseEntity<T> postForEntity(String url, @Nullable Object request, Class<T> responseType, Object... uriVariables) throws RestClientException {
    public <T> ResponseEntity<T> postForEntity(String url, @Nullable Object request, Class<T> responseType, Map<String, ?> uriVariables) throws RestClientException {
    public <T> ResponseEntity<T> postForEntity(URI url, @Nullable Object request, Class<T> responseType) throws RestClientException {



************
put 方法

    public void put(String url, @Nullable Object request, Object... uriVariables) throws RestClientException {
    public void put(String url, @Nullable Object request, Map<String, ?> uriVariables) throws RestClientException {
    public void put(URI url, @Nullable Object request) throws RestClientException {



************
delete 方法

    public void delete(String url, Object... uriVariables) throws RestClientException {
    public void delete(String url, Map<String, ?> uriVariables) throws RestClientException {
    public void delete(URI url) throws RestClientException {



************
head 方法

    public HttpHeaders headForHeaders(String url, Object... uriVariables) throws RestClientException {
    public HttpHeaders headForHeaders(String url, Map<String, ?> uriVariables) throws RestClientException {
    public HttpHeaders headForHeaders(URI url) throws RestClientException {



************
patch方法

    public <T> T patchForObject(String url, @Nullable Object request, Class<T> responseType, Object... uriVariables) throws RestClientException {
    public <T> T patchForObject(String url, @Nullable Object request, Class<T> responseType, Map<String, ?> uriVariables) throws RestClientException {
    public <T> T patchForObject(URI url, @Nullable Object request, Class<T> responseType) throws RestClientException {



************
options 方法

    public Set<HttpMethod> optionsForAllow(String url, Object... uriVariables) throws RestClientException {
    public Set<HttpMethod> optionsForAllow(String url, Map<String, ?> uriVariables) throws RestClientException {
    public Set<HttpMethod> optionsForAllow(URI url) throws RestClientException {



************
exchange 方法

    public <T> ResponseEntity<T> exchange(String url, HttpMethod method, @Nullable HttpEntity<?> requestEntity, Class<T> responseType, Object... uriVariables) throws RestClientException {
    public <T> ResponseEntity<T> exchange(String url, HttpMethod method, @Nullable HttpEntity<?> requestEntity, Class<T> responseType, Map<String, ?> uriVariables) throws RestClientException {
    public <T> ResponseEntity<T> exchange(String url, HttpMethod method, @Nullable HttpEntity<?> requestEntity, ParameterizedTypeReference<T> responseType, Object... uriVariables) throws RestClientException {
    public <T> ResponseEntity<T> exchange(String url, HttpMethod method, @Nullable HttpEntity<?> requestEntity, ParameterizedTypeReference<T> responseType, Map<String, ?> uriVariables) throws RestClientException {
                                         //httpEntity自定义请求头，路径及参数可直接设置

    public <T> ResponseEntity<T> exchange(URI url, HttpMethod method, @Nullable HttpEntity<?> requestEntity, Class<T> responseType) throws RestClientException {
    public <T> ResponseEntity<T> exchange(URI url, HttpMethod method, @Nullable HttpEntity<?> requestEntity, ParameterizedTypeReference<T> responseType) throws RestClientException {

    public <T> ResponseEntity<T> exchange(RequestEntity<?> requestEntity, Class<T> responseType) throws RestClientException {
    public <T> ResponseEntity<T> exchange(RequestEntity<?> requestEntity, ParameterizedTypeReference<T> responseType) throws RestClientException {

    public <T> ResponseEntity<T> exchange(URI url, HttpMethod method, @Nullable HttpEntity<?> requestEntity, Class<T> responseType) throws RestClientException {




************
execute 方法

    public <T> T execute(String url, HttpMethod method, @Nullable RequestCallback requestCallback, @Nullable ResponseExtractor<T> responseExtractor, Object... uriVariables) throws RestClientException {
    public <T> T execute(String url, HttpMethod method, @Nullable RequestCallback requestCallback, @Nullable ResponseExtractor<T> responseExtractor, Map<String, ?> uriVariables) throws RestClientException {

    public <T> T execute(URI url, HttpMethod method, @Nullable RequestCallback requestCallback, @Nullable ResponseExtractor<T> responseExtractor) throws RestClientException {



************
其他方法

    protected <T> T doExecute(URI url, @Nullable HttpMethod method, @Nullable RequestCallback requestCallback, @Nullable ResponseExtractor<T> responseExtractor) throws RestClientException {

    protected void handleResponse(URI url, HttpMethod method, ClientHttpResponse response) throws IOException {

    public <T> RequestCallback acceptHeaderRequestCallback(Class<T> responseType) {
    public <T> RequestCallback httpEntityCallback(@Nullable Object requestBody) {
    public <T> RequestCallback httpEntityCallback(@Nullable Object requestBody, Type responseType) {

    public <T> ResponseExtractor<ResponseEntity<T>> responseEntityExtractor(Type responseType) {
    protected ResponseExtractor<HttpHeaders> headersExtractor() {

    private static <T> T nonNull(@Nullable T result) {


    static {
        ClassLoader classLoader = RestTemplate.class.getClassLoader();
        romePresent = ClassUtils.isPresent("com.rometools.rome.feed.WireFeed", classLoader);
        jaxb2Present = ClassUtils.isPresent("javax.xml.bind.Binder", classLoader);
        jackson2Present = ClassUtils.isPresent("com.fasterxml.jackson.databind.ObjectMapper", classLoader) && ClassUtils.isPresent("com.fasterxml.jackson.core.JsonGenerator", classLoader);
        jackson2XmlPresent = ClassUtils.isPresent("com.fasterxml.jackson.dataformat.xml.XmlMapper", classLoader);
        jackson2SmilePresent = ClassUtils.isPresent("com.fasterxml.jackson.dataformat.smile.SmileFactory", classLoader);
        jackson2CborPresent = ClassUtils.isPresent("com.fasterxml.jackson.dataformat.cbor.CBORFactory", classLoader);
        gsonPresent = ClassUtils.isPresent("com.google.gson.Gson", classLoader);
        jsonbPresent = ClassUtils.isPresent("javax.json.bind.Jsonb", classLoader);
    }



**************
内部类：Resttemplate.HeadersExtractor

    private static class HeadersExtractor implements ResponseExtractor<HttpHeaders> {
        private HeadersExtractor() {
        }

        public HttpHeaders extractData(ClientHttpResponse response) {
            return response.getHeaders();
        }
    }


**************
内部类：Resttemplate.ResponseEntityResponseExtractor

    private class ResponseEntityResponseExtractor<T> implements ResponseExtractor<ResponseEntity<T>> {
        @Nullable
        private final HttpMessageConverterExtractor<T> delegate;

        public ResponseEntityResponseExtractor(@Nullable Type responseType) {


        public ResponseEntity<T> extractData(ClientHttpResponse response) throws IOException {



**************
内部类：Resttemplate.HttpEntityRequestCallback

    private class HttpEntityRequestCallback extends RestTemplate.AcceptHeaderRequestCallback {
        private final HttpEntity<?> requestEntity;

        public HttpEntityRequestCallback(@Nullable Object requestBody) {


        public HttpEntityRequestCallback(@Nullable Object requestBody, @Nullable Type responseType) {

        public void doWithRequest(ClientHttpRequest httpRequest) throws IOException {
        private void logBody(Object body, @Nullable MediaType mediaType, HttpMessageConverter<?> converter) {



**************
内部类：Resttemplate.AcceptHeaderRequestCallback

    private class AcceptHeaderRequestCallback implements RequestCallback {
        @Nullable
        private final Type responseType;

        public AcceptHeaderRequestCallback(@Nullable Type responseType) {


        public void doWithRequest(ClientHttpRequest request) throws IOException {
        private boolean canReadResponse(Type responseType, HttpMessageConverter<?> converter) {
        private Stream<MediaType> getSupportedMediaTypes(HttpMessageConverter<?> messageConverter) {

 

RestOperations

public interface RestOperations {


***********
get 方法

    <T> T getForObject(String var1, Class<T> var2, Object... var3) throws RestClientException;
    <T> T getForObject(String var1, Class<T> var2, Map<String, ?> var3) throws RestClientException;
    <T> T getForObject(URI var1, Class<T> var2) throws RestClientException;

    <T> ResponseEntity<T> getForEntity(String var1, Class<T> var2, Object... var3) throws RestClientException;
    <T> ResponseEntity<T> getForEntity(String var1, Class<T> var2, Map<String, ?> var3) throws RestClientException;
    <T> ResponseEntity<T> getForEntity(URI var1, Class<T> var2) throws RestClientException;



***********
post 方法

    URI postForLocation(String var1, @Nullable Object var2, Object... var3) throws RestClientException;
    URI postForLocation(String var1, @Nullable Object var2, Map<String, ?> var3) throws RestClientException;
    URI postForLocation(URI var1, @Nullable Object var2) throws RestClientException;

    <T> T postForObject(String var1, @Nullable Object var2, Class<T> var3, Object... var4) throws RestClientException;
    <T> T postForObject(String var1, @Nullable Object var2, Class<T> var3, Map<String, ?> var4) throws RestClientException;
    <T> T postForObject(URI var1, @Nullable Object var2, Class<T> var3) throws RestClientException;

    <T> ResponseEntity<T> postForEntity(String var1, @Nullable Object var2, Class<T> var3, Object... var4) throws RestClientException;
    <T> ResponseEntity<T> postForEntity(String var1, @Nullable Object var2, Class<T> var3, Map<String, ?> var4) throws RestClientException;
    <T> ResponseEntity<T> postForEntity(URI var1, @Nullable Object var2, Class<T> var3) throws RestClientException;



***********
put 方法

    void put(String var1, @Nullable Object var2, Object... var3) throws RestClientException;
    void put(String var1, @Nullable Object var2, Map<String, ?> var3) throws RestClientException;
    void put(URI var1, @Nullable Object var2) throws RestClientException;



***********
delete 方法

    void delete(String var1, Object... var2) throws RestClientException;
    void delete(String var1, Map<String, ?> var2) throws RestClientException;
    void delete(URI var1) throws RestClientException;



***********
head方法

    HttpHeaders headForHeaders(String var1, Object... var2) throws RestClientException;
    HttpHeaders headForHeaders(String var1, Map<String, ?> var2) throws RestClientException;
    HttpHeaders headForHeaders(URI var1) throws RestClientException;



***********
patch 方法

    <T> T patchForObject(String var1, @Nullable Object var2, Class<T> var3, Object... var4) throws RestClientException;
    <T> T patchForObject(String var1, @Nullable Object var2, Class<T> var3, Map<String, ?> var4) throws RestClientException;
    <T> T patchForObject(URI var1, @Nullable Object var2, Class<T> var3) throws RestClientException;



***********
options 方法

    Set<HttpMethod> optionsForAllow(String var1, Object... var2) throws RestClientException;
    Set<HttpMethod> optionsForAllow(String var1, Map<String, ?> var2) throws RestClientException;
    Set<HttpMethod> optionsForAllow(URI var1) throws RestClientException;



***********
exchange 方法

    <T> ResponseEntity<T> exchange(String var1, HttpMethod var2, @Nullable HttpEntity<?> var3, Class<T> var4, Object... var5) throws RestClientException;
    <T> ResponseEntity<T> exchange(String var1, HttpMethod var2, @Nullable HttpEntity<?> var3, Class<T> var4, Map<String, ?> var5) throws RestClientException;
    <T> ResponseEntity<T> exchange(String var1, HttpMethod var2, @Nullable HttpEntity<?> var3, ParameterizedTypeReference<T> var4, Object... var5) throws RestClientException;
    <T> ResponseEntity<T> exchange(String var1, HttpMethod var2, @Nullable HttpEntity<?> var3, ParameterizedTypeReference<T> var4, Map<String, ?> var5) throws RestClientException;

    <T> ResponseEntity<T> exchange(URI var1, HttpMethod var2, @Nullable HttpEntity<?> var3, Class<T> var4) throws RestClientException;
    <T> ResponseEntity<T> exchange(URI var1, HttpMethod var2, @Nullable HttpEntity<?> var3, ParameterizedTypeReference<T> var4) throws RestClientException;

    <T> ResponseEntity<T> exchange(RequestEntity<?> var1, Class<T> var2) throws RestClientException;
    <T> ResponseEntity<T> exchange(RequestEntity<?> var1, ParameterizedTypeReference<T> var2) throws RestClientException;



***********
execute 方法

    <T> T execute(String var1, HttpMethod var2, @Nullable RequestCallback var3, @Nullable ResponseExtractor<T> var4, Object... var5) throws RestClientException;
    <T> T execute(String var1, HttpMethod var2, @Nullable RequestCallback var3, @Nullable ResponseExtractor<T> var4, Map<String, ?> var5) throws RestClientException;

    <T> T execute(URI var1, HttpMethod var2, @Nullable RequestCallback var3, @Nullable ResponseExtractor<T> var4) throws RestClientException;

 

 

InterceptingHttpAccessor：拦截器设置

public abstract class InterceptingHttpAccessor extends HttpAccessor {
    private final List<ClientHttpRequestInterceptor> interceptors = new ArrayList();
    @Nullable
    private volatile ClientHttpRequestFactory interceptingRequestFactory;

    public InterceptingHttpAccessor() {
    }

    public void setInterceptors(List<ClientHttpRequestInterceptor> interceptors) {
    public List<ClientHttpRequestInterceptor> getInterceptors() {

    public void setRequestFactory(ClientHttpRequestFactory requestFactory) {
    public ClientHttpRequestFactory getRequestFactory() {

 

HttpAccessor

public abstract class HttpAccessor {
    protected final Log logger = HttpLogging.forLogName(this.getClass());
    private ClientHttpRequestFactory requestFactory = new SimpleClientHttpRequestFactory();
    private final List<ClientHttpRequestInitializer> clientHttpRequestInitializers = new ArrayList();

    public HttpAccessor() {
    }

    public void setRequestFactory(ClientHttpRequestFactory requestFactory) {
        Assert.notNull(requestFactory, "ClientHttpRequestFactory must not be null");
        this.requestFactory = requestFactory;
    }

    public ClientHttpRequestFactory getRequestFactory() {
        return this.requestFactory;
    }

    public void setClientHttpRequestInitializers(List<ClientHttpRequestInitializer> clientHttpRequestInitializers) {
        if (this.clientHttpRequestInitializers != clientHttpRequestInitializers) {
            this.clientHttpRequestInitializers.clear();
            this.clientHttpRequestInitializers.addAll(clientHttpRequestInitializers);
            AnnotationAwareOrderComparator.sort(this.clientHttpRequestInitializers);
        }

    }

    public List<ClientHttpRequestInitializer> getClientHttpRequestInitializers() {
        return this.clientHttpRequestInitializers;
    }

    protected ClientHttpRequest createRequest(URI url, HttpMethod method) throws IOException {
        ClientHttpRequest request = this.getRequestFactory().createRequest(url, method);
        this.initialize(request);
        if (this.logger.isDebugEnabled()) {
            this.logger.debug("HTTP " + method.name() + " " + url);
        }

        return request;
    }

    private void initialize(ClientHttpRequest request) {
        this.clientHttpRequestInitializers.forEach((initializer) -> {
            initializer.initialize(request);
        });
    }
}

 

ClientHttpRequestInterceptor：拦截器接口

@FunctionalInterface
public interface ClientHttpRequestInterceptor {
    ClientHttpResponse intercept(HttpRequest var1, byte[] var2, ClientHttpRequestExecution var3) throws IOException;
}

 

ClientHttpRequestExecution：拦截器执行接口

@FunctionalInterface
public interface ClientHttpRequestExecution {
    ClientHttpResponse execute(HttpRequest var1, byte[] var2) throws IOException;
}

 

 

RequestEntity

public class RequestEntity<T> extends HttpEntity<T> {
    @Nullable
    private final HttpMethod method;
    private final URI url;
    @Nullable
    private final Type type;



*************
构造方法

    public RequestEntity(HttpMethod method, URI url) {
    public RequestEntity(@Nullable T body, HttpMethod method, URI url) {
    public RequestEntity(@Nullable T body, HttpMethod method, URI url, Type type) {

    public RequestEntity(MultiValueMap<String, String> headers, HttpMethod method, URI url) {
    public RequestEntity(@Nullable T body, @Nullable MultiValueMap<String, String> headers, @Nullable HttpMethod method, URI url) {
    public RequestEntity(@Nullable T body, @Nullable MultiValueMap<String, String> headers, @Nullable HttpMethod method, URI url, @Nullable Type type) {



*************
普通方法

    public static RequestEntity.BodyBuilder method(HttpMethod method, URI url) {
    public static RequestEntity.BodyBuilder post(URI url) {
    public static RequestEntity.BodyBuilder put(URI url) {
    public static RequestEntity.BodyBuilder patch(URI url) {


    public static RequestEntity.HeadersBuilder<?> get(URI url) {
    public static RequestEntity.HeadersBuilder<?> head(URI url) {
    public static RequestEntity.HeadersBuilder<?> delete(URI url) {
    public static RequestEntity.HeadersBuilder<?> options(URI url) {

    public HttpMethod getMethod() {
    public URI getUrl() {
    public Type getType() {

    public boolean equals(@Nullable Object other) {
    public int hashCode() {
    public String toString() {



*************
内部类：RequestEntity.DefaultBodyBuilder

    private static class DefaultBodyBuilder implements RequestEntity.BodyBuilder {
        private final HttpMethod method;
        private final URI url;
        private final HttpHeaders headers = new HttpHeaders();

        public DefaultBodyBuilder(HttpMethod method, URI url) {


        public RequestEntity.BodyBuilder header(String headerName, String... headerValues) {
        public RequestEntity.BodyBuilder headers(@Nullable HttpHeaders headers) {
        public RequestEntity.BodyBuilder headers(Consumer<HttpHeaders> headersConsumer) {

        public <T> RequestEntity<T> body(T body) {
        public <T> RequestEntity<T> body(T body, Type type) {

        public RequestEntity.BodyBuilder accept(MediaType... acceptableMediaTypes) {
        public RequestEntity.BodyBuilder acceptCharset(Charset... acceptableCharsets) {

        public RequestEntity.BodyBuilder contentLength(long contentLength) {
        public RequestEntity.BodyBuilder contentType(MediaType contentType) {

        public RequestEntity.BodyBuilder ifModifiedSince(ZonedDateTime ifModifiedSince) {
        public RequestEntity.BodyBuilder ifModifiedSince(Instant ifModifiedSince) {
        public RequestEntity.BodyBuilder ifModifiedSince(long ifModifiedSince) {

        public RequestEntity.BodyBuilder ifNoneMatch(String... ifNoneMatches) {

        public RequestEntity<Void> build() {



*************
内部接口：RequestEntity.BodyBuilder

    public interface BodyBuilder extends RequestEntity.HeadersBuilder<RequestEntity.BodyBuilder> {
        RequestEntity.BodyBuilder contentLength(long var1);
        RequestEntity.BodyBuilder contentType(MediaType var1);

        <T> RequestEntity<T> body(T var1);
        <T> RequestEntity<T> body(T var1, Type var2);



*************
内部接口：RequestEntity.HeadersBuilder

    public interface HeadersBuilder<B extends RequestEntity.HeadersBuilder<B>> {

        B header(String var1, String... var2);
        B headers(@Nullable HttpHeaders var1);
        B headers(Consumer<HttpHeaders> var1);

        B accept(MediaType... var1);
        B acceptCharset(Charset... var1);

        B ifModifiedSince(ZonedDateTime var1);
        B ifModifiedSince(Instant var1);
        B ifModifiedSince(long var1);
        B ifNoneMatch(String... var1);

        RequestEntity<Void> build();

 

ResponseEntity

public class ResponseEntity<T> extends HttpEntity<T> {
    private final Object status;


**********
构造方法

    public ResponseEntity(HttpStatus status) {
    public ResponseEntity(@Nullable T body, HttpStatus status) {

    public ResponseEntity(MultiValueMap<String, String> headers, HttpStatus status) {
    public ResponseEntity(@Nullable T body, @Nullable MultiValueMap<String, String> headers, HttpStatus status) {
    private ResponseEntity(@Nullable T body, @Nullable MultiValueMap<String, String> headers, Object status) {



**********
普通方法

    public HttpStatus getStatusCode() {
    public int getStatusCodeValue() {

    public boolean equals(@Nullable Object other) {
    public int hashCode() {
    public String toString() {

    public static ResponseEntity.BodyBuilder status(HttpStatus status) {
    public static ResponseEntity.BodyBuilder status(int status) {
        return new ResponseEntity.DefaultBuilder(status);
    }

    public static ResponseEntity.BodyBuilder ok() {
    public static <T> ResponseEntity<T> ok(T body) {
    public static <T> ResponseEntity<T> of(Optional<T> body) {

    public static ResponseEntity.BodyBuilder created(URI location) {
    public static ResponseEntity.BodyBuilder accepted() {
    public static ResponseEntity.BodyBuilder badRequest() {
    public static ResponseEntity.BodyBuilder unprocessableEntity() {

    public static ResponseEntity.HeadersBuilder<?> noContent() {
    public static ResponseEntity.HeadersBuilder<?> notFound() {



**********
内部类：ResponseEntity.DefaultBuilder

    private static class DefaultBuilder implements ResponseEntity.BodyBuilder {
        private final Object statusCode;
        private final HttpHeaders headers = new HttpHeaders();

        public DefaultBuilder(Object statusCode) {
            this.statusCode = statusCode;
        }

        public ResponseEntity.BodyBuilder header(String headerName, String... headerValues) {
        public ResponseEntity.BodyBuilder headers(Consumer<HttpHeaders> headersConsumer) {

        public <T> ResponseEntity<T> body(@Nullable T body) {

        public ResponseEntity.BodyBuilder contentLength(long contentLength) {
        public ResponseEntity.BodyBuilder contentType(MediaType contentType) {

        public ResponseEntity.BodyBuilder lastModified(ZonedDateTime date) {
        public ResponseEntity.BodyBuilder lastModified(Instant date) {
        public ResponseEntity.BodyBuilder lastModified(long date) {

        public ResponseEntity.BodyBuilder location(URI location) {
        public ResponseEntity.BodyBuilder allow(HttpMethod... allowedMethods) {
        public ResponseEntity.BodyBuilder cacheControl(CacheControl cacheControl) {
        public ResponseEntity.BodyBuilder varyBy(String... requestHeaders) {
        public ResponseEntity.BodyBuilder eTag(String etag) {

        public <T> ResponseEntity<T> build() {



**********
内部类：ResponseEntity.BodyBuilder

    public interface BodyBuilder extends ResponseEntity.HeadersBuilder<ResponseEntity.BodyBuilder> {

        ResponseEntity.BodyBuilder contentLength(long var1);
        ResponseEntity.BodyBuilder contentType(MediaType var1);

        <T> ResponseEntity<T> body(@Nullable T var1);



**********
内部类：ResponseEntity.HeadersBuilder

    public interface HeadersBuilder<B extends ResponseEntity.HeadersBuilder<B>> {

        B header(String var1, String... var2);
        B headers(@Nullable HttpHeaders var1);
        B headers(Consumer<HttpHeaders> var1);

        B lastModified(ZonedDateTime var1);
        B lastModified(Instant var1);
        B lastModified(long var1);

        B location(URI var1);
        B allow(HttpMethod... var1);
        B cacheControl(CacheControl var1);
        B varyBy(String... var1);
        B eTag(String var1);

        <T> ResponseEntity<T> build();

 

HttpEntity

public class HttpEntity<T> {
    public static final HttpEntity<?> EMPTY = new HttpEntity();
    private final HttpHeaders headers;
    @Nullable
    private final T body;



************
构造方法

    protected HttpEntity() {
    public HttpEntity(T body) {

    public HttpEntity(MultiValueMap<String, String> headers) {
    public HttpEntity(@Nullable T body, @Nullable MultiValueMap<String, String> headers) {



************
普通方法

    public HttpHeaders getHeaders() {

    public T getBody() {
    public boolean hasBody() {

    public boolean equals(@Nullable Object other) {
    public int hashCode() {
    public String toString() {

 

 

ResponseErrorHander：响应异常处理

public interface ResponseErrorHandler {
    boolean hasError(ClientHttpResponse var1) throws IOException;

    void handleError(ClientHttpResponse var1) throws IOException;

    default void handleError(URI url, HttpMethod method, ClientHttpResponse response) throws IOException {
        this.handleError(response);
    }
}

 

DefaultResponseErrorHandler

public class DefaultResponseErrorHandler implements ResponseErrorHandler {
    public DefaultResponseErrorHandler() {
    }

    public boolean hasError(ClientHttpResponse response) throws IOException {

    protected boolean hasError(HttpStatus statusCode) {
    protected boolean hasError(int unknownStatusCode) {


    public void handleError(ClientHttpResponse response) throws IOException {
        HttpStatus statusCode = HttpStatus.resolve(response.getRawStatusCode());
        if (statusCode == null) {
            byte[] body = this.getResponseBody(response);
            String message = this.getErrorMessage(response.getRawStatusCode(), response.getStatusText(), body, this.getCharset(response));
            throw new UnknownHttpStatusCodeException(message, response.getRawStatusCode(), response.getStatusText(), response.getHeaders(), body, this.getCharset(response));
        } else {
            this.handleError(response, statusCode);
        }
    }

    private String getErrorMessage(int rawStatusCode, String statusText, @Nullable byte[] responseBody, @Nullable Charset charset) {
    protected void handleError(ClientHttpResponse response, HttpStatus statusCode) throws IOException {

    protected byte[] getResponseBody(ClientHttpResponse response) {
    protected Charset getCharset(ClientHttpResponse response) {

 

 

ResponseExtrator

@FunctionalInterface
public interface ResponseExtractor<T> {
    @Nullable
    T extractData(ClientHttpResponse var1) throws IOException;
}

 

RestTemplate.HeadersExtrator

public class RestTemplate extends InterceptingHttpAccessor implements RestOperations {


***********
内部类：RestTemplate.HeadersExtrator

    private static class HeadersExtractor implements ResponseExtractor<HttpHeaders> {
        private HeadersExtractor() {
        }

        public HttpHeaders extractData(ClientHttpResponse response) {
            return response.getHeaders();
        }
    }

 

 

o_瓜田李下_o
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringBoot RestTemplate 使用说明
weixin_34297704的博客
04-24 156
为什么80%的码农都做不了架构师？>>> ...
SpringBoot系列 - 使用RestTemplate
热门推荐
张衍斌的博客
05-09 3万+
spring框架提供的RestTemplate类可用于在应用中调用rest服务，它简化了与http服务的通信方式，统一了RESTful的标准，封装了http链接， 我们只需要传入url及返回值类型即可。相较于之前常用的HttpClient，RestTemplate是一种更优雅的调用RESTful服务的方式。RestTemplate默认依赖JDK提供http连接的能力（HttpURLConnecti...
spring Boot 中session取值null问题
oschina_40188932的博客
03-31 1634
在维护一个老项目时候发现，该项目业务请求，大多是基于session里取存储的用户信息，作为业务操作流程，必要条件之一。 出现了一问题，在特别多的请求下，从session取值用户信息null的问题，时有出现。查找日志，信息，定位出现取值为null的请求，均未查找到原因，因正常的请求过来，也会时候发生取值null情况。 排查原因，我这边的问题是spring Boot版本的问题 版本是2.1.10 将配置文件内的session时效配置server.servl server.servlet.session.
SpringBoot使用RestTemplate
jcc4261的博客
03-25 513
RestTemplate 是由 Spring 提供的一个 HTTP 请求工具，它提供了常见的REST请求方案的模版，例如 GET 请求、POST 请求、PUT 请求、DELETE 请求以及一些通用的请求执行方法 exchange 以及 execute。
RestTemplate创建解析 之request请求的建立
water
10-11 1433
RestTemplate底层使用的是java.net.URLConnection底层包，如果想其它诸如OkHttp,HttpClient，可以在项目里面配置。 RestTemplate继承体系图： HttpAccessor 这是一个抽象类：也就是在这里默认使用SimpleClientHttpRequestFactory创建的request请求对象 RestOperat...
RESTFUL的实现-springboot2.0版本
05-29
RESTFUL的实现-springboot2.0版本 网址：https://blog.csdn.net/chenwewi520feng/article/details/130634490 使用一个示例来说明restful的使用，是以springboot的2.0版本作为基础的
SpringBoot.zip
08-15
在“SpringBoot.zip”这个压缩包中，我们可以看到关于如何使用SpringBoot开发REST服务、如何进行单元测试（包括单独使用JUnit以及与RestTemplate结合的方式）的相关资料。以下是对这些知识点的详细说明： 1. **...
SpringBoot-OneNet.zip
03-03
SpringBoot提供了丰富的HTTP客户端库，如RestTemplate或WebClient，用于处理这些网络请求。 4. **OneNet云平台**： OneNet是中国移动物联网公司提供的一个物联网开放平台，提供设备连接、数据处理、数据分析等功能...
基于SpringBoot开发的在线教育系统源码+项目说明.7z
12-20
基于SpringBoot开发的在线教育系统源码+项目说明.7z 在线教育平台服务端基于Spring Boot构建，采用Spring Cloud微服务框架。 持久层：MySQL、MongoDB、Redis、ElasticSearch 数据访问层：使用Spring Data JPA 、...
springBootTest
03-28
以下是对`@SpringBootTest`注解及其相关测试概念的详细说明： 1. **注解功能**：`@SpringBootTest`注解启动了一个Spring Boot应用的ApplicationContext，它包含了所有配置类和Bean定义。你可以通过设置`classes`...
SpringBoot代码示例，结合Swagger、MyBatis Plus、RestTemplate等技术，是学习微服务的基础demo示例
09-12
该示例结合Swagger生成在线API，MyBatis Plus快速分页查询、RestTemplate实现远程访问服务端接口等基于SpringBoot框架的demo示例，对大家学习SpringCloud打下良好基础
springboot中restTemplate请求时的异常处理以及编码格式
Anhk丶
12-28 973
import com.cignacmb.handler.CustomErrorHandler; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; import org.springframework.context.annotation.Bean; import org.springframework.http.conv
SpringBoot 中使用 RestTemplate 自定义 异常处理，捕获最原始的错误信息
phubing
01-14 7525
一些 API 的报错信息通过 Response 的 body返回。 使用 HttpClient 能正常获取到 StatusCode 和 body 中的错误提示。然而使用 RestTemplate ，会直接抛出下面的异常。 如果想获取原始的信息并进一步处理会比较麻烦。 类似下面这种404、403响应码直接抛出异常并不是我们想要的 org.springframework.web.clie...
Spring boot 之 RestTemplate访问
hogwarts_ziqi的博客
08-02 294
本文主要向大家介绍了RestTemplate这样一个HTTP请求工具类的常见用法，并没有涉及到源码，其实内部源码很多很深，包括和解析url模板，绑定参数的UriBuilderFactoryUriTemplateHandler等等，建议跟踪源码跑一遍会更加理解restTemplate。**注意**postForLocation方法返回的URI实际上是指响应头的Location字段，所以，请求的接口的响应头必须要有Location字段（即请求的接口实际上是一个重定向的接口），否则返回值为null。...
springboot中RestTemplate的用法
weixin_42304484的博客
11-08 2569
Springboot中RestTemplate的用法
javaweb--Rest访问（RestTemplate）
liuzebin9的专栏
02-04 4130
Rest访问（RestTemplate） 在实际的项目中，往往需要发送一个Get/Post请求到其他的系统（Rest API），比如向人员管理部门请求，然后解析返回信息获取该用户的基本信息等。JDK传统的HttpURLConnection、Apache HttpClient、Netty 4和OkHttp等可以实现访问请求。不过spring的RestTemplate封装了这些操作库，使之更容易使用
Spring Boot使用RestTemplate消费REST服务的几个问题记录
weixin_34111819的博客
05-17 355
我们可以通过Spring Boot快速开发REST接口，同时也可能需要在实现接口的过程中，通过Spring Boot调用内外部REST接口完成业务逻辑。 在Spring Boot中，调用REST Api常见的一般主要有两种方式，通过自带的RestTemplate或者自己开发http客户端工具实现服务调用。 RestTemplate基本功能非常强大，不过某些特殊场景，我们可能还是更习惯用自己封装...
Springboot — 用更优雅的方式发HTTP请求(RestTemplate详解)
weixin_33807284的博客
10-25 1508
RestTemplate是Spring提供的用于访问Rest服务的客户端，RestTemplate提供了多种便捷访问远程Http服务的方法,能够大大提高客户端的编写效率。 我之前的HTTP开发是用apache的HttpClient开发，代码复杂，还得操心资源回收等。代码很复杂，冗余代码多，稍微截个图，这是我封装好的一个post请求工具： 本教程将带领大家实现Spring生态内RestTem...
Spring Boot 中调用外部接口的 3 种方式
Wen先森的博客
07-03 9503
SpringBoot不仅继承了Spring框架原有的优秀特性，而且还通过简化配置来进一步简化了Spring应用的整个搭建和开发过程。在Spring-Boot项目开发中，存在着本模块的代码需要访问外面模块接口，或外部url链接的需求。调用外部接口是指在应用程序中与其他系统、服务或服务端点进行通信，以获取数据或执行某些操作。这种通信可以通过 HTTP、HTTPS、SOAP、gRPC 等协议来实现。
springboot RestTemplate 使用
最新发布
08-30
- *1* *2* *3* [SpringBoot使用RestTemplate](https://blog.csdn.net/weixin_42408447/article/details/117560736)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值