spring之RestTemplate

最新推荐文章于 2024-09-19 22:03:51 发布
最新推荐文章于 2024-09-19 22:03:51 发布
阅读量1.7k 收藏 8
点赞数
文章标签： spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34614236/article/details/118002606
版权

文章目录

RestTemplate是spring的一个rest客户端，在spring-web这个包下，spring boot的依赖如下

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

点进去可以看到spring-web

<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-web</artifactId>
  <version>5.0.4.RELEASE</version>
  <scope>compile</scope>
</dependency>

所以如果在非spring的框架下直接引入spring-web这个包即可

RestTemplate只是对其它Rest客户端的一个封装，本身并没有自己的实现。
很多人都说Spring Boot 2.0之前RestTestTemplate的默认实现是HttpClient，2.+为OKHttp3，其实这种说法并不完全正确，如果没有引入这些客户端的jar包，其默认实现是HttpURLConnection（集成了URLConnection），这是JDK自带的REST客户端实现。

RestTemplate有三个实现

  1. RestTemplate()
  2. RestTemplate(List<HttpMessageConverter<?>> messageConverters)
  3. RestTemplate(ClientHttpRequestFactory requestFactory)。

RestTemplate(ClientHttpRequestFactory requestFactory)是要说的重点，跟踪ClientHttpRequestFactory查看其实现，如下图
这里写图片描述
先看默认实现的测试代码

RestConfig

package com.pk.client.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;

/**
 * Created by pangkunkun on 2018/8/25.
 */
@Configuration
public class RestConfig {
    @Bean
    public RestTemplate restTemplate(){
        RestTemplate restTemplate = new RestTemplate();
        return restTemplate;
    }
}

MyRestController

package com.pk.client.controller;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

/**
 * Created by pangkunkun on 2018/8/25.
 */
@RestController
public class MyRestController {

    private static final Logger logger = LoggerFactory.getLogger(MyRestController.class);

    @Autowired
    private RestTemplate restTemplate;

    private static final String URL = "http://localhost:8081/server";

    @GetMapping("/default")
    public void defaultRestClient(){
        String result = restTemplate.getForObject(URL,String.class);
        logger.info("result = {}",result);
    }

}

Server端代码

package com.pk.server;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * Created by pangkunkun on 2018/8/25.
 */
@SpringBootApplication
@RestController
public class RestServerApplication {

    public static void main(String[] args) {
        SpringApplication.run(RestServerApplication.class,args);
    }

    @GetMapping("/server")
    public String restServer(){
        System.out.println("This is rest server");
        return "success";
    }
}

在浏览器调用client之后会追踪到下面这里
在这里插入图片描述
在这里就可以看到其实现方式是HttpURLConnection（URLConnection）。
所以，在没有第三方依赖的情况下其默认实现是URLConnection。

现在来看下其它几种客户端的引入。在ClientHttpRequestFactory的实现那张图中列出了RestTemplate的几种REST Client的封装。其中最常用的有以下三种：

  • SimpleClientHttpRequestFactory（封装URLConnection）
  • HttpComponentsClientHttpRequestFactory（封装HttpClient）
  • OkHttp3ClientHttpRequestFactory(封装OKHttp)

其实Netty4ClientHttpRequestFactory这个为在测试的时候也测试过，不过spring boot 2.0之后就不推荐使用了，而且我测试的时候性能上明显不如其它几个，所以这里没加上

其切换与使用也很简单，在pom中引入相应依赖

<dependencies>
    <dependency>
        <groupId>org.apache.httpcomponents</groupId>
        <artifactId>httpclient</artifactId>
        <version>4.5.6</version>
    </dependency>
    <dependency>
        <groupId>com.squareup.okhttp3</groupId>
        <artifactId>okhttp</artifactId>
        <version>3.11.0</version>
    </dependency>
</dependencies>

在Config中的配置

package com.pk.client.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.client.HttpComponentsClientHttpRequestFactory;
import org.springframework.http.client.OkHttp3ClientHttpRequestFactory;
import org.springframework.http.client.SimpleClientHttpRequestFactory;
import org.springframework.web.client.RestTemplate;

/**
 * Created by pangkunkun on 2018/8/25.
 */
@Configuration
public class RestConfig {

    @Bean
    public RestTemplate restTemplate(){
        RestTemplate restTemplate = new RestTemplate();
        return restTemplate;
    }

    @Bean("urlConnection")
    public RestTemplate urlConnectionRestTemplate(){
        RestTemplate restTemplate = new RestTemplate(new SimpleClientHttpRequestFactory());
        return restTemplate;
    }

    @Bean("httpClient")
    public RestTemplate httpClientRestTemplate(){
        RestTemplate restTemplate = new RestTemplate(new HttpComponentsClientHttpRequestFactory());
        return restTemplate;
    }

    @Bean("OKHttp3")
    public RestTemplate OKHttp3RestTemplate(){
        RestTemplate restTemplate = new RestTemplate(new OkHttp3ClientHttpRequestFactory());
        return restTemplate;
    }
}

一、RestTemplate 语法

//1 创建核心类
RestTemplate restTemplate = new RestTemplate();

//get请求
ResponseEntity<返回值类型> entity =
restTemplate.getForEntity(‘请求路径’, 返回值类型.class );

//post请求
ResponseEntity<返回值类型> entity =
restTemplate.postForEntity(‘请求路径’,请求参数对象,返回值类型.class);

//put请求
restTemplate.put(‘请求路径’, 请求参数);

//delete请求
restTemplate.delete(‘请求路径’)

二、配置类的使用

步骤一：编写配置类，将需要new的对象交于spring进行管理

@Configuration    //配置类，spring boot会自动扫描
public class 类{
	@Bean		//spring将管理此方法创建的对象
	public RestTemplate restTemplate(){
		return new RestTemplate();
	}
}

步骤二：在任意位置，通过@Resource进行注入

public class AdminClient{
    @Resource			//因为配置类已经构建对象，此处自动注入
    public RestTemplate restTemplate;
    //..使用即可
}

创建 RestTemplate

@Bean
public RestTemplate restTemplate(ClientHttpRequestFactory factory) {
    RestTemplate restTemplate = new RestTemplate(factory);
    return restTemplate;
}

@Bean
public ClientHttpRequestFactory simpleClientHttpRequestFactory() {
    HttpComponentsClientHttpRequestFactory httpRequestFactory = new HttpComponentsClientHttpRequestFactory();
        httpRequestFactory.setConnectionRequestTimeout(connectionRequestTimeout); //连接请求超时时间
        httpRequestFactory.setConnectTimeout(connectionTimeout);//连接超时时间
        httpRequestFactory.setReadTimeout(readTimeout);//读取超时时间
	  // 设置代理
    //factory.setProxy(null);
    return factory;
}

创建 RestTemplate 时需要一个 ClientHttpRequestFactory，通过这个请求工厂，我们可以统一设置请求的超时时间，设置代理以及一些其他细节。通过上面代码配置后，我们直接在代码中注入 RestTemplate 就可以使用了。
有时候我们还需要通过 ClientHttpRequestFactory 配置最大链接数，忽略SSL证书等，大家需要的时候可以自己查看代码设置

一些其他设置

1. 拦截器配置

RestTemplate 也可以设置拦截器做一些统一处理。这个功能感觉和 Spring MVC 的拦截器类似。配置也很简单：

class MyInterceptor implements ClientHttpRequestInterceptor{

        @Override
        public ClientHttpResponse intercept(HttpRequest request, byte[] body, ClientHttpRequestExecution execution) throws IOException {
            logger.info("enter interceptor...");
            return execution.execute(request,body);
        }
    }

 @Bean
public RestTemplate restTemplate(ClientHttpRequestFactory factory) {
    RestTemplate restTemplate = new RestTemplate(factory);
    MyInterceptor myInterceptor = new MyInterceptor();
    List<ClientHttpRequestInterceptor> list = new ArrayList<>();
    list.add(myInterceptor);
    restTemplate.setInterceptors(list);
    return restTemplate;
}

2. ErrorHandler 配置

ErrorHandler 用来对调用错误对统一处理。

public class MyResponseErrorHandler extends DefaultResponseErrorHandler {

        @Override
        public boolean hasError(ClientHttpResponse response) throws IOException {
            return super.hasError(response);
        }

        @Override
        public void handleError(ClientHttpResponse response) throws IOException {
            HttpStatus statusCode = HttpStatus.resolve(response.getRawStatusCode());
            if (statusCode == null) {
                throw new UnknownHttpStatusCodeException(response.getRawStatusCode(), response.getStatusText(),
                        response.getHeaders(), getResponseBody(response), getCharset(response));
            }
            handleError(response, statusCode);
        }
        @Override
        protected void handleError(ClientHttpResponse response, HttpStatus statusCode) throws IOException {
            switch (statusCode.series()) {
                case CLIENT_ERROR:
                    HttpClientErrorException exp1 = new HttpClientErrorException(statusCode, response.getStatusText(), response.getHeaders(), getResponseBody(response), getCharset(response));
                    logger.error("客户端调用异常",exp1);
                    throw  exp1;
                case SERVER_ERROR:
                    HttpServerErrorException exp2 = new HttpServerErrorException(statusCode, response.getStatusText(),
                            response.getHeaders(), getResponseBody(response), getCharset(response));
                    logger.error("服务端调用异常",exp2);
                    throw exp2;
                default:
                    UnknownHttpStatusCodeException exp3 = new UnknownHttpStatusCodeException(statusCode.value(), response.getStatusText(),
                            response.getHeaders(), getResponseBody(response), getCharset(response));
                    logger.error("网络调用未知异常");
                    throw exp3;
            }
        }

    }

@Bean
public RestTemplate restTemplate(ClientHttpRequestFactory factory) {
    RestTemplate restTemplate = new RestTemplate(factory);
    MyResponseErrorHandler errorHandler = new MyResponseErrorHandler();
    restTemplate.setErrorHandler(errorHandler);
    List<HttpMessageConverter<?>> messageConverters = restTemplate.getMessageConverters();
    // 通过下面代码可以添加新的 HttpMessageConverter
    //messageConverters.add(new );
    return restTemplate;
}

3. HttpMessageConverter 配置

RestTemplate 也可以配置 HttpMessageConverter，配置的原理和 Spring MVC 中类似。

4.路由配置

5 实例化

RestTemplate的实例化
RestTemplate实例通常需要自己进行定制，SpringBoot相关的自动配置bean。但是，SpringBoot提供了自动配置的RestTemplateBuilder，可以用它来创建RestTemplate实例。

那么，SpringBoot是如何提供RestTemplateBuilder的呢？我们先来看一下源代码。自动配置的源码位于spring-boot-autoconfigure的RestTemplateAutoConfiguration当中。看一下部分源码：

@Configuration(
    proxyBeanMethods = false
)
@AutoConfigureAfter({HttpMessageConvertersAutoConfiguration.class})
@ConditionalOnClass({RestTemplate.class})
@Conditional({RestTemplateAutoConfiguration.NotReactiveWebApplicationCondition.class})
public class RestTemplateAutoConfiguration {
    @Bean
    @Lazy
    @ConditionalOnMissingBean
    public RestTemplateBuilder restTemplateBuilder(RestTemplateBuilderConfigurer restTemplateBuilderConfigurer) {
        RestTemplateBuilder builder = new RestTemplateBuilder(new RestTemplateCustomizer[0]);
        return restTemplateBuilderConfigurer.configure(builder);
    }
    // 省略其他代码
}

通过上面代码可以看出springboot默认会自动实例化这么一个RestTemplateBuilder，并且bean的名称为restTemplateBuilder。那么，此时我们就可以直接注入来进行使用了。

RestTemplate的实例化配置，有两种方案可选，方案一：

@Configuration
public class RestTemplateConfig {
    @Autowired
    private RestTemplateBuilder restTemplateBuilder;
    @Bean
    public RestTemplate restTemplate() {
        restTemplateBuilder.setConnectTimeout(Duration.ofSeconds(5));
        restTemplateBuilder.setReadTimeout(Duration.ofSeconds(5));
        return restTemplateBuilder.build();
    }
}

此种方案很直观明白，直接注入RestTemplateBuilder，然后在实例化RestTemplate时进行使用即可。

另外一种方案，更简化一些。直接作为restTemplate方法的参数传入，SpringBoot在实例化RestTemplate时会自动匹配注入，使用示例如下：

@Component
public class RestConfig {
@Bean
public RestTemplate restTemplate(RestTemplateBuilder builder) {
builder.setConnectTimeout(Duration.ofSeconds(5));
builder.setReadTimeout(Duration.ofSeconds(5));
return builder.build();
}
}
当然，根据你的具体需要可以调用RestTemplateBuilder的其他方法，进行参数项的设置，也就是定制化你的RestTemplate，最后调用build方法进行构建。

1、以restTemplate.getForObject为例
在这里插入图片描述

2、private ClientHttpRequestFactory requestFactory = new SimpleClientHttpRequestFactory();

@Override
public ClientHttpRequest createRequest(URI uri, HttpMethod httpMethod) throws IOException {
	HttpURLConnection connection = openConnection(uri.toURL(), this.proxy);
	prepareConnection(connection, httpMethod.name());

	if (this.bufferRequestBody) {
		return new SimpleBufferingClientHttpRequest(connection, this.outputStreaming);
	}
	else {
		return new SimpleStreamingClientHttpRequest(connection, this.chunkSize, this.outputStreaming);
	}
}

默认是使用HttpURLConnection 。可以指定ClientHttpRequestFactory。可选择OkHttp3ClientHttpRequestFactory、HttpComponentsClientHttpRequestFactory

参考地址

https://www.cnblogs.com/lay2017/p/11741206.html

https://blog.csdn.net/weixin_36146358/article/details/102511685
https://ifeve.com/httpclient-2-3/

Mr.Debug
关注
Spring RestTemplate介绍
Meiko记录
01-28 665
上篇文件介绍Eureka服务的文章中，我们介绍到consumer从Eureka中通过LoadBalancerClient获取到服务端地址信息后通过RestTemplate来远程调用服务的场景，本文来具体介绍下RestTemplate的使用 RestTemplate   SpringRestTemplate是Spring 提供的用于访问 Rest 服务的客端, RestTemplate提供了多种便捷访问远程Http服务的方法，能够大大提高客户端的编写效率,所以很多客户端比如Android或者第三方服务商都
Spring RestTemplate 详解
weixin_34356310的博客
12-07 2573
2019独角兽企业重金招聘Python工程师标准>>> ...
SpringBoot下使用RestTemplate实现远程服务调用
最新发布
一位Java开发工程师
09-19 613
现如今的项目，由服务端向外发起网络请求的场景，基本上处处可见。RestTemplate是一个执行HTTP请求的同步阻塞式工具类，它仅仅只是在 HTTP 客户端库（例如 JDK HttpURLConnection，Apache HttpComponents，okHttp 等）基础上，封装了更加简单易用的模板方法 API，方便程序员利用已提供的模板方法发起网络请求和处理，能很大程度上提升我们的开发效率。
Spring中RestTemplate详解
qq_33479841的博客
11-23 9109
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详解
热门推荐
上善若泪
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框架（七）——RestTemplate
jc_hook的博客
03-31 2068
在前面SpringCloud之整合ribbon中，我通过RestTemplate实现了多个服务之前的接口调用，在实际开发业务中，我们也会遇到请求第三方接口的需求，这个时候就可以用上RestTemplate。 目录一、RestTemplate是什么二、配置方法三、常用方法3.1 GET请求3.1.1 getForEntity3.1.2 getForObject 一、RestTemplate是什么 RestTemplate是Spring从3.0版本开始提供的访问远程Http服务的工具，提供了常见的REST请求方
掌握 Spring 之 RestTemplate
小姜戈的博客
11-25 359
掌握 Spring 之 RestTemplate 前言 在 Java 服务端开发领域里，Spring 是绕不开的话题，尤其是现在微服务概念盛行，Spring Boot 的出现更是给 Spring 注入了新的活力，除此之外还有 Spring Cloud，这些框架让 Spring 技术体系更加丰富。Spring 从 2014 年的 1.0.0 版本迭代到 现在的 5.2.0 M1 版本，紧随着 Jav...
Spring使用RestTemplate模拟form提交示例
08-27
Spring 使用 RestTemplate 模拟 Form 提交示例 在本文中，我们将介绍如何使用 Spring 的 RestTemplate 来模拟 Form 提交的示例。RestTemplate 是 Spring 框架中的一种模板类，用于在客户端访问 Web 服务。通过提供...
一起学 Spring 之 RestTemplate
one的博客
05-11 507
一起学 Spring 之 RestTemplate 文章目录一起学 Spring 之 RestTemplate前言认识 `RestTemplate`实战 `RestTemplate`1. 生成 Demo 项目，导入 IDE2. 编写请求控制器类 ProductController3. 编写测试类用 RestTemplate 发送 HTTP 请求GET 请求POST 请求DELETE 请求 和 PU...
spring的RestTemplate使用指南
weixin_42650954的博客
06-02 838
前言：现在restful接口越来越广泛，而如今很多接口摒弃了传统的配置复杂的webService开发模式，在java领域只需要很简单的springMvc就可以声明为一个控制器，再加上service层，就可以直接操作数据库成为一个灵活的接口。而我们请求接口的次数也会越来越多（最近我在和一个工具对接的时候，对方公司提供的接口全部由我们主动去调用），一般我们请求接口，都采用Apache Httpclient工具，这个工具稳定，既可以建立长连接，保持不错的性能，而它唯一的不足就是使用起来麻烦多变，并且要很多层判断处
spring整合restTemplate实现调用接口
qq_41643765的博客
07-28 382
spring整合restTemplate实现接口的调用 restTemplate是使用于rest风格的客户端工具，以前的写 法就是自己封装一个httpclient的工具类，里面放post get等相关构造方法，现在知道了restTemplate你还在用httpclient吗？ 它真的还挺好用的，里面有很多方法，post，get，put，delete，同样的也可以传参请求头token以及设置编码格式，说真的这些源码没事的时候翻翻写代码真的有好处，其实有好多方法已经让前辈帮我们封装好了 这是get请求，查询
springRestTemplate
08-03
spring rest template 封装,支持文件下载,超时属性设置，http rest接口调用
Spring RestTemplate
11-28
Spring 3.0 RestTemplate
Spring RestTemplate
Sean的博客
10-24 236
RestTemplate是Spring提供的用于访问Rest服务的客户端，RestTemplate提供了多种便捷访问远程Http服务的方法，能够大大提高客户端的编写效率。调用RestTemplate的默认构造函数，RestTemplate对象在底层通过使用java.net包下的实现创建HTTP 请求，可以通过使用ClientHttpRequestFactory指定不同的HTTP请求方式。 下面是R...
细品Spring之RestTemplate
宋小黑的博客
01-15 1286
RestTemplate是Spring提供的用于同步客户端HTTP请求的模板类。它简化了与HTTP服务器交互的过程，让发送请求和接收响应变得更加直接。不仅如此，它还支持将HTTP响应直接转换成你的领域模型。这意味着你不用再手动解析HTTP响应数据了，RestTemplate帮你搞定了！让我们来看一个简单的例子。假设小黑想要通过GET请求从某个API获取用户信息。
Spring（30）——RestTemplate介绍
Elim的博客
02-26 822
Spring之RestTemplate介绍 RestTemplate是Spring Web模块提供的一个基于Rest规范提供Http请求的工具。应用中如果需要访问第三方提供的Rest接口，使用RestTemplate操作将非常方便。RestTemplate中提供了一系列的getXXX、postXXX、putXXX、deleteXXX等方法，以供发起对应的Rest规范请求，以及更通用的exchang...
Spring RestTemplate详解
CHIKA2333的博客
07-26 278
简单说就是：简化了发起HTTP请求以及处理响应的过程，并且支持REST。为什么说简化了呢？来看两种实现方式（1）使用java.net包下的URLConnection建立连接try {" + param;// 打开和URL之间的连接// 设置通用的请求属性MSIE 6.0;SV1)");// 建立实际的连接// 获取所有响应头字段// 遍历所有的响应头字段// 定义 BufferedReader输入流来读取URL的响应。
关于 spring RestTemplate restful
FREEDOM
07-13 826
API 地址：http://docs.spring.io/spring/docs/current/javadoc-api/org/springframework/web/client/RestTemplate.html 客户端 spring xml 转换器配置：
spring boot resttemplate
09-04
Spring Boot RestTemplate是一个用于进行RESTful请求的Java类库。它提供了一种简单而有效的方式来发送HTTP请求，并处理响应。 使用RestTemplate，您可以执行GET、POST、PUT、DELETE等不同类型的请求。您可以指定...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值