如何使用 Spring RestTemplate

最新推荐文章于 2024-07-31 22:32:46 发布
最新推荐文章于 2024-07-31 22:32:46 发布
阅读量3.5k 收藏 4
点赞数 1
分类专栏： Restful spring 文章标签： spring rest resttemplate
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bigtree_3721/article/details/72866503
版权
spring 同时被 2 个专栏收录
102 篇文章 2 订阅
订阅专栏
Restful
13 篇文章 0 订阅
订阅专栏

先简单介绍下RestTemplate的概念

RestTemplate是Spring提供的用于访问Rest服务的客户端，它提供了多种便捷访问远程Http服务的方法，能够大大提高客户端的编写效率。调用RestTemplate的默认构造函数，RestTemplate对象在底层通过使用java.net包下的实现创建HTTP 请求。

可以通过使用ClientHttpRequestFactory指定不同的HTTP请求方式。
ClientHttpRequestFactory接口主要提供了两种实现方式

  • 一种是SimpleClientHttpRequestFactory，使用J2SE提供的方式（既java.net包提供的方式）创建底层的Http请求连接。
  • 一种方式是使用HttpComponentsClientHttpRequestFactory方式，底层使用HttpClient访问远程的Http服务，使用HttpClient可以配置连接池和证书等信息。

 RestTemplate默认是使用SimpleClientHttpRequestFactory，内部是调用jdk的HttpConnection，默认超时为-1

RestTemplate有两个构造方法，分别是：


/**
 * Create a new instance of the {@link RestTemplate} using default settings.
 */
public RestTemplate() {
    this.messageConverters.add(new ByteArrayHttpMessageConverter());
    this.messageConverters.add(new StringHttpMessageConverter());
    this.messageConverters.add(new ResourceHttpMessageConverter());
    this.messageConverters.add(new SourceHttpMessageConverter());
    this.messageConverters.add(new AllEncompassingFormHttpMessageConverter());
    if (romePresent) {
        this.messageConverters.add(new AtomFeedHttpMessageConverter());
        this.messageConverters.add(new RssChannelHttpMessageConverter());
    }
    if (jaxb2Present) {
        this.messageConverters.add(new Jaxb2RootElementHttpMessageConverter());
    }
    if (jackson2Present) {
        this.messageConverters.add(new MappingJackson2HttpMessageConverter());
    }
    else if (jacksonPresent) {
        this.messageConverters.add(new MappingJacksonHttpMessageConverter());
    }
}

/**
 * Create a new instance of the {@link RestTemplate} based on the given {@link ClientHttpRequestFactory}.
 * @param requestFactory HTTP request factory to use
 * @see org.springframework.http.client.SimpleClientHttpRequestFactory
 * @see org.springframework.http.client.HttpComponentsClientHttpRequestFactory
 */
public RestTemplate(ClientHttpRequestFactory requestFactory) {
    this();
    setRequestFactory(requestFactory);
}

其中，第二个构造方法中可以传入ClientHttpRequestFactory参数，第一个进行默认初始化，因为我们经常需要对请求超时进行设置并能 够对超时进行后续处理，而第一个构造方法，我们无法控制超时时间，第二个构造中的ClientHttpRequestFactory接口的实现类中存在 timeout属性，因此选用第二个构造方法。

基于jdk的spring的RestTemplate


<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans 
　　　　http://www.springframework.org/schema/beans/spring-beans.xsd"
       default-autowire="byName" default-lazy-init="true">
 
    <!--方式一、使用jdk的实现-->
    <bean id="myrequestFactory" class="org.springframework.http.client.SimpleClientHttpRequestFactory">
        <property name="readTimeout" value="10000"/>
        <property name="connectTimeout" value="5000"/>
    </bean>
 
    <bean id="simpleRestTemplate" class="org.springframework.web.client.RestTemplate">
        <constructor-arg ref="myrequestFactory"/>
        <property name="messageConverters">
            <list>
                <bean class="org.springframework.http.converter.FormHttpMessageConverter"/>
                <bean class="org.springframework.http.converter.xml.MappingJackson2XmlHttpMessageConverter"/>
                <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter"/>
                <bean class="org.springframework.http.converter.StringHttpMessageConverter">
                    <property name="supportedMediaTypes">
                        <list>
                            <value>text/plain;charset=UTF-8</value>
                        </list>
                    </property>
                </bean>
            </list>
        </property>
    </bean>
 
</beans>

 


import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.Lazy;
import org.springframework.http.client.SimpleClientHttpRequestFactory;
import org.springframework.http.converter.FormHttpMessageConverter;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.http.converter.StringHttpMessageConverter;
import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
import org.springframework.http.converter.xml.MappingJackson2XmlHttpMessageConverter;
import org.springframework.stereotype.Component;
import org.springframework.web.client.DefaultResponseErrorHandler;
import org.springframework.web.client.RestTemplate;
 
import javax.annotation.PostConstruct;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.List;
 
@Component
@Lazy(false)
public class SimpleRestClient {
 
    private static final Logger LOGGER = LoggerFactory.getLogger(SimpleRestClient.class);
 
    private static RestTemplate restTemplate;
 
    static {
        SimpleClientHttpRequestFactory requestFactory = new SimpleClientHttpRequestFactory();
        requestFactory.setReadTimeout(5000);
        requestFactory.setConnectTimeout(5000);
 
        // 添加转换器
        List<HttpMessageConverter<?>> messageConverters = new ArrayList<>();
        messageConverters.add(new StringHttpMessageConverter(Charset.forName("UTF-8")));
        messageConverters.add(new FormHttpMessageConverter());
        messageConverters.add(new MappingJackson2XmlHttpMessageConverter());
        messageConverters.add(new MappingJackson2HttpMessageConverter());
 
        restTemplate = new RestTemplate(messageConverters);
        restTemplate.setRequestFactory(requestFactory);
        restTemplate.setErrorHandler(new DefaultResponseErrorHandler());
 
        LOGGER.info("SimpleRestClient初始化完成");
    }
 
    private SimpleRestClient() {
 
    }
 
    @PostConstruct
    public static RestTemplate getClient() {
        return restTemplate;
    }
 
}

 

使用Httpclient连接池的方式(推荐)


<!--使用httpclient的实现，带连接池-->
<!--在httpclient4.3版本后才有-->
<bean id="httpClientBuilder" class="org.apache.http.impl.client.HttpClientBuilder" factory-method="create">
    <property name="connectionManager">
        <bean class="org.apache.http.impl.conn.PoolingHttpClientConnectionManager">
            <!--整个连接池的并发-->
            <property name="maxTotal" value="50"/>
            <!--每个主机的并发-->
            <property name="defaultMaxPerRoute" value="50"/>
        </bean>
    </property>
    <!--开启重试-->
    <property name="retryHandler">
        <bean class="org.apache.http.impl.client.DefaultHttpRequestRetryHandler">
            <constructor-arg value="2"/>
            <constructor-arg value="true"/>
        </bean>
    </property>
    <property name="defaultHeaders">
        <list>
            <bean class="org.apache.http.message.BasicHeader">
                <constructor-arg value="Content-Type"/>
                <constructor-arg value="text/html;charset=UTF-8"/>
            </bean>
            <bean class="org.apache.http.message.BasicHeader">
                <constructor-arg value="Accept-Encoding"/>
                <constructor-arg value="gzip,deflate"/>
            </bean>
            <bean class="org.apache.http.message.BasicHeader">
                <constructor-arg value="Accept-Language"/>
                <constructor-arg value="zh-CN"/>
            </bean>
        </list>
    </property>
</bean>

<bean id="httpClient" factory-bean="httpClientBuilder" factory-method="build"/>

<bean id="restTemplate" class="org.springframework.web.client.RestTemplate">
    <property name="messageConverters">
        <list value-type="org.springframework.http.converter.HttpMessageConverter">
            <bean class="org.springframework.http.converter.StringHttpMessageConverter">
                <property name="supportedMediaTypes">
                    <value>text/html;charset=UTF-8</value>
                </property>
            </bean>
            <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
                <property name="supportedMediaTypes">
                    <value>application/json;charset=UTF-8</value>
                </property>
            </bean>
            <bean class="org.springframework.http.converter.ResourceHttpMessageConverter"/>
            <bean class="org.springframework.http.converter.support.AllEncompassingFormHttpMessageConverter"/>
            <bean class="org.springframework.http.converter.FormHttpMessageConverter"/>
            <bean class="org.springframework.http.converter.xml.MappingJackson2XmlHttpMessageConverter"/>
        </list>
    </property>
    <property name="requestFactory">
        <bean class="org.springframework.http.client.HttpComponentsClientHttpRequestFactory">
            <constructor-arg ref="httpClient"/>
            <!--连接时间(毫秒)-->
            <property name="connectTimeout" value="20000"/>
            <!--读取时间(毫秒)-->
            <property name="readTimeout" value="20000"/>
        </bean>
    </property>
</bean>

 


import org.apache.http.Header;
import org.apache.http.client.HttpClient;
import org.apache.http.impl.client.DefaultConnectionKeepAliveStrategy;
import org.apache.http.impl.client.DefaultHttpRequestRetryHandler;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
import org.apache.http.message.BasicHeader;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.Lazy;
import org.springframework.http.client.HttpComponentsClientHttpRequestFactory;
import org.springframework.http.converter.FormHttpMessageConverter;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.http.converter.StringHttpMessageConverter;
import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
import org.springframework.http.converter.xml.MappingJackson2XmlHttpMessageConverter;
import org.springframework.stereotype.Component;
import org.springframework.web.client.DefaultResponseErrorHandler;
import org.springframework.web.client.RestTemplate;
 
import javax.annotation.PostConstruct;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;
 
@Component
@Lazy(false)
public class RestClient {
 
    private static final Logger LOGGER = LoggerFactory.getLogger(SimpleRestClient.class);
 
    private static RestTemplate restTemplate;
 
    static {
        // 长连接保持30秒
        PoolingHttpClientConnectionManager pollingConnectionManager = new PoolingHttpClientConnectionManager(30, TimeUnit.SECONDS);
        // 总连接数
        pollingConnectionManager.setMaxTotal(1000);
        // 同路由的并发数
        pollingConnectionManager.setDefaultMaxPerRoute(1000);
 
        HttpClientBuilder httpClientBuilder = HttpClients.custom();
        httpClientBuilder.setConnectionManager(pollingConnectionManager);
        // 重试次数，默认是3次，没有开启
        httpClientBuilder.setRetryHandler(new DefaultHttpRequestRetryHandler(2, true));
        // 保持长连接配置，需要在头添加Keep-Alive
        httpClientBuilder.setKeepAliveStrategy(new DefaultConnectionKeepAliveStrategy());
 
//        RequestConfig.Builder builder = RequestConfig.custom();
//        builder.setConnectionRequestTimeout(200);
//        builder.setConnectTimeout(5000);
//        builder.setSocketTimeout(5000);
//
//        RequestConfig requestConfig = builder.build();
//        httpClientBuilder.setDefaultRequestConfig(requestConfig);
 
        List<Header> headers = new ArrayList<>();
        headers.add(new BasicHeader("User-Agent", "Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/31.0.1650.16 Safari/537.36"));
        headers.add(new BasicHeader("Accept-Encoding", "gzip,deflate"));
        headers.add(new BasicHeader("Accept-Language", "zh-CN"));
        headers.add(new BasicHeader("Connection", "Keep-Alive"));
 
        httpClientBuilder.setDefaultHeaders(headers);
 
        HttpClient httpClient = httpClientBuilder.build();
 
        // httpClient连接配置，底层是配置RequestConfig
        HttpComponentsClientHttpRequestFactory clientHttpRequestFactory = new HttpComponentsClientHttpRequestFactory(httpClient);
        // 连接超时
        clientHttpRequestFactory.setConnectTimeout(5000);
        // 数据读取超时时间，即SocketTimeout
        clientHttpRequestFactory.setReadTimeout(5000);
        // 连接不够用的等待时间，不宜过长，必须设置，比如连接不够用时，时间过长将是灾难性的
        clientHttpRequestFactory.setConnectionRequestTimeout(200);
        // 缓冲请求数据，默认值是true。通过POST或者PUT大量发送数据时，建议将此属性更改为false，以免耗尽内存。
        // clientHttpRequestFactory.setBufferRequestBody(false);
 
        // 添加内容转换器
        List<HttpMessageConverter<?>> messageConverters = new ArrayList<>();
        messageConverters.add(new StringHttpMessageConverter(Charset.forName("UTF-8")));
        messageConverters.add(new FormHttpMessageConverter());
        messageConverters.add(new MappingJackson2XmlHttpMessageConverter());
        messageConverters.add(new MappingJackson2HttpMessageConverter());
 
        restTemplate = new RestTemplate(messageConverters);
        restTemplate.setRequestFactory(clientHttpRequestFactory);
        restTemplate.setErrorHandler(new DefaultResponseErrorHandler());
 
        LOGGER.info("RestClient初始化完成");
    }
 
    private RestClient() {
 
    }
 
    @PostConstruct
    public static RestTemplate getClient() {
        return restTemplate;
    }
 
}

Spring的RestTemplate对post的常用接口：

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

rest POST 使用例子


HttpHeaders headers = new HttpHeaders();
headers.add("X-Auth-Token", "e348bc22-5efa-4299-9142-529f07a18ac9");

MultiValueMap<String, String> postParameters = new LinkedMultiValueMap<String, String>();
postParameters.add("owner", "11");
postParameters.add("subdomain", "aoa");
postParameters.add("comment", "");

HttpEntity<MultiValueMap<String, String>> requestEntity  = new HttpEntity<MultiValueMap<String, String>>(postParameters, headers);

ParseResultVo exchange = null;
try {
    exchange = restTemplate.postForObject("http://l-dnsutil1.ops.beta.cn6.qunar.com:10085/v1/cnames/tts.piao",  requestEntity, ParseResultVo.class);
    logger.info(exchange.toString());
} catch (RestClientException e) {
    logger.info("。。。。");
}


package com.winner.rest;

import com.alibaba.fastjson.JSON;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;

import javax.annotation.Resource;
import java.io.UnsupportedEncodingException;


@Service
public class TestGet {

    @Resource
    private RestTemplate restTemplate;

    /**
     * 要请求的url，一般放在配置文件中
     */
    @Value(value = "@{remote.url}")
    private String remoteUrl;

    public String postRemoteData(ParameterRo ro) throws UnsupportedEncodingException {
        /**
         * 设置请求头
         */
        HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.parseMediaType("application/json;charset=UTF-8"));
        headers.add("Accept", MediaType.APPLICATION_JSON.toString());

        /**
         * POST请求参数，根据需要进行封装
         */
        String bodyData = new String(Base64Util.encodeData(JSON.toJSONString(ro)).getBytes("UTF-8"), "UTF-8");

        /**
         * 查看HttpEntity的构造方法，包含只有请求头和只有请求体的情况
         */
        HttpEntity<String> httpEntity = new HttpEntity<String>(bodyData, headers);

        /**
         * 执行操作
         */
        String result = restTemplate.postForObject(remoteUrl, httpEntity, String.class);

        return result;
    }

    /**
     * 模拟请求参数
     */
    private class ParameterRo {
        
        private Integer id = 123;

        public Integer getId() {
            return id;
        }

        public void setId(Integer id) {
            this.id = id;
        }
    }
}


Spring的RestTemplate提供了许多的 rest GET 方法支持，这里仅仅列出常用的rest GET接口：

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

对于GET请求来说，常用的几种形式如下：

String result = restTemplate.getForObject("http://example.com/hotels/{hotel}/bookings/{booking}", String.class,"42", "21");

或者下面这种形式：

Map<String, String> vars = Collections.singletonMap("hotel", "42");
String result = restTemplate.getForObject("http://example.com/hotels/{hotel}/rooms/{hotel}", String.class, vars);

以及：

String message = restTemplate.getForObject("http://localhost:8080/yongbarservice/appstore/appgoods/restTemplate?name=zhaoshijie&id=80", String.class );

package com.winner.rest;

import com.alibaba.fastjson.JSON;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;

import javax.annotation.Resource;
import java.io.UnsupportedEncodingException;


@Service
public class TestGet {

    @Resource
    private RestTemplate restTemplate;

    /**
     * 要请求的url，一般放在配置文件中
     */
    @Value(value = "@{remote.url}")
    private String remoteUrl;

    public String getRemoteData(ParameterRo ro) throws UnsupportedEncodingException {

        //根据需要也可以设置请求头

        /**
         * get请求参数，根据需要进行封装(加密等)
         */
        String getData = new String(Base64Util.encodeData(JSON.toJSONString(ro)).getBytes("UTF-8"), "UTF-8");

        /**
         * 执行操作
         */
        String result = restTemplate.getForObject(remoteUrl + "?" + getData, String.class);

        return result;
    }

    /**
     * 模拟请求参数
     */
    private class ParameterRo {

        private Integer id = 123;

        public Integer getId() {
            return id;
        }

        public void setId(Integer id) {
            this.id = id;
        }
    }
}
大树叶
关注
专栏目录
spring的RestTemplate使用指南
weixin_42650954的博客
06-02 798
前言：现在restful接口越来越广泛，而如今很多接口摒弃了传统的配置复杂的webService开发模式，在java领域只需要很简单的springMvc就可以声明为一个控制器，再加上service层，就可以直接操作数据库成为一个灵活的接口。而我们请求接口的次数也会越来越多（最近我在和一个工具对接的时候，对方公司提供的接口全部由我们主动去调用），一般我们请求接口，都采用Apache Httpclient工具，这个工具稳定，既可以建立长连接，保持不错的性能，而它唯一的不足就是使用起来麻烦多变，并且要很多层判断处
使用spring restTemplate的坑
lunhuasxk的专栏
03-04 318
文章目录广告项目需求方案问题测试结果 广告项目 需求 广告点击事件转发 方案 接受请求，将结果发送kafka缓存 @GetMapping("/test") public String test(HttpServletRequest request) { final String queryString = request.getQueryString(); log.info("{}",queryString); return queryString; } 将结果转发给
Spring之RestTemplate详解
热门推荐
上善若泪
03-08 2万+
文章目录1 RestTemplate1.1 引言1.2 环境配置1.2.1 非Spring环境下使用RestTemplate1.2.2 Spring 环境下使用 RestTemplate1.3 API 实践1.3.1 GET请求1.3.1.1 不带参请求1.3.1.2 带参的get请求(使用占位符号传参)1.3.1.3 带参的get请求(restful风格)1.3.1.4 getForEntity使用示例1.3.2 POST请求1.3.2.1 模拟表单请求1.3.2.2 模拟表单请求(传递对象)1.3.2.
Spring Boot 开发RestTemplate使用
最新发布
码海浮生，一个乐于分享的全栈工程师！
07-31 996
Spring Boot 开发RestTemplate使用
spring之RestTemplate
Mr.Debug的博客
06-17 1759
文章目录一、RestTemplate 语法二、配置类的使用步骤一：编写配置类，将需要new的对象交于spring进行管理步骤二：在任意位置，通过@Resource进行注入创建 RestTemplate一些其他设置1. 拦截器配置2. ErrorHandler 配置3. HttpMessageConverter 配置4.路由配置 RestTemplate是spring的一个rest客户端，在spring-web这个包下，spring boot的依赖如下 <dependency> &lt
spring的restTemplate使用
郝老三~~~~~~~~~~~~~
03-03 1277
本文只列出了，get请求与post的请求的使用，至于其他的，put，delete请求，与get和post请求的方式都相差不多，我将这个RestTemplate的例子传到了网盘上，大家如果有兴趣可以下载研究。链接: https://pan.baidu.com/s/1yidh07u5I6MF_yLkls1ycA?pwd=gkg5 提取码: gkg5 复制这段内容后打开百度网盘手机App，操作更方便哦。
关于Spring的RestTemplate的使用
ABestRookie的博客
11-30 1266
关于Spring的RestTemplate的使用1 RestTemplate的简介2 RestTemplate的使用consumer-a服务provider-a服务测试功能使用过程中遇到的问题 现在微服务项目中, 各个服务之间的互相请求调用, 越来越频繁, 所以出现了很多Http请求工具, 而Spring提供的 RestTemplate,则是比较友好的封装集成了一些常见的Http请求工具,可以根据不同的使用场景,灵活的切换 1 RestTemplate的简介 RestTemplate是Spring3.0
如何使用Spring RestTemplate访问restful服务
08-26
"使用Spring RestTemplate访问restful服务" Spring RestTemplate是Spring框架中的一种轻量级客户端，用于访问restful服务。它提供了一种简洁的方式来访问restful接口，简化了HTTP请求和响应处理的过程。 什么是...
springRestTemplate
08-03
在 Spring Boot 中，由于其内置的自动配置特性，使用 RestTemplate 更加方便。让我们深入探讨一下 RestTemplate 的核心概念、功能以及如何在实际应用中进行设置和使用。 1. **什么是 RestTemplate?** RestTemplate...
使用Spring RestTemplate分别发送GET和POST请求
weixin_39173782的博客
10-08 371
Leader分配开发任务：展示和修改NACOS的配置参数。 展示NACOS的配置参数 这里使用RestTemplate中的GET请求中的getForObject()来完成展示NACOS中的配置参数： //rest接口定义 public class ParamsOnNacosRestService { @Autowired private ParamsOnNacosService paramsOnNacosService; @GET @Path("/nacos/{dataId}") @Ap
java使用spring RestTemplate 调用 webservice服务
chichanghei3527的博客
03-08 5909
项目基础环境是spring boot的 spring boot相关知识不做详解 webservice 基本结构如下 webservice 相关调试，获取请求参数可参考 参考 pom中不需要额外引用 配置RestTemplateConfig package com.xxxx.base.co...
spring rest mvc使用RestTemplate调用
04-13
NULL 博文链接：https://zhaoshijie.iteye.com/blog/1711170
RestTemplate使用教程
weixin_30707875的博客
12-07 164
一、概述 spring框架提供的RestTemplate类可用于在应用中调用rest服务，它简化了与http服务的通信方式，统一了RESTful的标准，封装了http链接， 我们只需要传入url及返回值类型即可。相较于之前常用的HttpClient，RestTemplate是一种更优雅的调用RESTful服务的方式。 在Spring应用程序中访问第三方REST服务与使用Spring ...
Spring中RestTemplate详解
qq_33479841的博客
11-23 9071
1.概述 RestTemplate是spring封装的restful请求的模板，它内部封装了常用的GET、POST、DELETE、PUT等请求方式，帮助开发者更快构建HTTP请求。传统的请求方式采用Apache的HttpClient，此种方式编写http请求时需要编写大量代码，比较繁琐。本文将从代码量、以及最大访问量对比HttpClient与Restemplate请求封装的工具类。 2.基于HttpClient封装的工具类 2.1 GET请求 2.2 POST请求 2.3 DELETE请求 2.4 PUT请
Spring之RestTemplate使用
诗人不写诗
10-24 1161
RestTemplate位于： org.springframework.web.client.RestTemplate spring-web 他是Spring web模块提供的一个发送http请求的工具。在使用了Spring的应用中，使用这个工具是非常普遍的，使用的细节和特性是需要了解的。 一、设计思想 1、RestTempldate作为暴露给用户的使用类 2、RestTemplate继承抽象类org.springframework.http.client.support.InterceptingHtt
Spring之RestTemplate简单使用
chp的博客
12-06 1552
什么是RestTemplate：RestTemplate是一个执行HTTP请求的同步阻塞式工具类，它仅仅只是在 HTTP 客户端库（例如 JDK HttpURLConnection，Apache HttpComponents，okHttp 等）基础上，封装了更加简单易用的模板方法 API，方便程序员利用已提供的模板方法发起网络请求和处理，能很大程度上提升我们的开发效率。
Spring RestTemplate
Sean的博客
10-24 215
RestTemplate是Spring提供的用于访问Rest服务的客户端，RestTemplate提供了多种便捷访问远程Http服务的方法，能够大大提高客户端的编写效率。调用RestTemplate的默认构造函数，RestTemplate对象在底层通过使用java.net包下的实现创建HTTP 请求，可以通过使用ClientHttpRequestFactory指定不同的HTTP请求方式。 下面是R...
Spring的RestTemplate的使用
qq_44597856的博客
05-01 385
写在前面 您好，我是码农飞哥，感谢您阅读此文。作为一名Java开发者，我们怎么都绕不开调用外部接口的场景，调用的方式要么是通过Http协议来调用，要么是通过RPC协议来调用，通过Http协议调用的话我们就需要用到Http的Api。比较常用的有Apache的HttpClient和原生的HttpURLConnection。这些Api都比较好用，但是我们今天要介绍一种更加好用API，Spring自带的RestTemplate，能力更强，使用更方便。 目录 写在前面 怎么用?
Spring框架（七）——RestTemplate
jc_hook的博客
03-31 2033
在前面SpringCloud之整合ribbon中，我通过RestTemplate实现了多个服务之前的接口调用，在实际开发业务中，我们也会遇到请求第三方接口的需求，这个时候就可以用上RestTemplate。 目录一、RestTemplate是什么二、配置方法三、常用方法3.1 GET请求3.1.1 getForEntity3.1.2 getForObject 一、RestTemplate是什么 RestTemplate是Spring从3.0版本开始提供的访问远程Http服务的工具，提供了常见的REST请求方
Spring RestTemplate使用文档
09-15
下面是Spring RestTemplate的一些基本使用方法: 1. 创建RestTemplate实例: ```java RestTemplate restTemplate = new RestTemplate(); ``` 2. 发送GET请求： ```java String url = ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值