文末可以领取所有系列高清 pdf。
大家好，我是路人，这是 SpringMVC 系列第 21 篇。
本文介绍 Spring web 中特别牛逼的一个类 RestTemplate。
目录
RestTemplate 概述
案例代码
1、git 地址
2、关键代码位置
3、如何运行测试用例？
发送 Get 请求
1、普通请求
2、url 中含有动态参数
3、接口返回值为泛型
4、下载小文件
5、下载大文件
6、传递头
7、综合案例：含头、url 动态参数
POST 请求
1、post 请求常见的 3 种类型
2、普通表单请求
3、上传本地文件
4、通过流或字节数组的方式上传文件
5、复杂表单：多个普通元素+多文件上传
6、发送 json 格式数据：传递 java 对象
7、发送 json 格式数据：传递 java 对象，返回值为泛型
8、发送 json 字符串格式数据
DELETE、PUT、OPTION 请求
1、DELETE 请求
2、PUT 请求
3、OPTIONS 请求
集成 HttpClient
集成 okhttp
总结
SpringMVC 系列目录
更多好文章
【路人甲 Java】所有系列高清 PDF
1、RestTemplate 概述
发送 http 请求，估计很多人用过 httpclient 和 okhttp，确实挺好用的，而 Spring web 中的 RestTemplate 和这俩的功能类似，也是用来发送 http 请求的，不过用法上面比前面的 2 位要容易很多。
spring 框架提供的 RestTemplate 类可用于在应用中调用 rest 服务，它简化了与 http 服务的通信方式，统一了 RESTful 的标准，封装了 http 链接， 我们只需要传入 url 及返回值类型即可。相较于之前常用的 HttpClient，RestTemplate 是一种更优雅的调用 RESTful 服务的方式。
在 Spring 应用程序中访问第三方 REST 服务与使用 Spring RestTemplate 类有关。RestTemplate 类的设计原则与许多其他 Spring 模板类(例如 JdbcTemplate、JmsTemplate)相同，为执行复杂任务提供了一种具有默认行为的简化方法。
RestTemplate 默认依赖 JDK 提供 http 连接的能力（HttpURLConnection），如果有需要的话也可以通过 setRequestFactory 方法替换为例如 Apache HttpComponents、Netty 或 OkHttp 等其它 HTTP library。
考虑到 RestTemplate 类是为调用 REST 服务而设计的，因此它的主要方法与 REST 的基础紧密相连就不足为奇了，后者是 HTTP 协议的方法:HEAD、GET、POST、PUT、DELETE 和 OPTIONS。例如，RestTemplate 类具有 headForHeaders()、getForObject()、postForObject()、put()和 delete()等方法。
下面给大家上案例，案例是重点，通过案例，把我知道的用法都给盘出来。
2、案例代码
2.1、git 地址
https://gitee.com/javacode2018/springmvc-series
2.2、关键代码位置
文中的所有 controller 代码，在RestTemplateTestController类中。
所有@Test 用例的代码，在RestTemplateTest。
2.3、如何运行测试用例？
拉取项目
将 chat16-RestTemplate 模块发布到 tomcat9 中
运行 RestTemplateTest 中对应的用例即可
下面咱们来看 RestTemplate 常见的用法汇总。
3、发送 Get 请求
3.1、普通请求
接口代码
@GetMapping("/test/get")@ResponseBodypublic BookDto get() { return new BookDto(1, "SpringMVC系列");}使用 RestTemplate 调用上面这个接口，通常有 2 种写法，如下
@Testpublic void test1() { RestTemplate restTemplate = new RestTemplate(); String url = "http://localhost:8080/chat16/test/get"; //getForObject方法，获取响应体，将其转换为第二个参数指定的类型 BookDto bookDto = restTemplate.getForObject(url, BookDto.class); System.out.println(bookDto);}@Testpublic void test2() { RestTemplate restTemplate = new RestTemplate(); String url = "http://localhost:8080/chat16/test/get"; //getForEntity方法，返回值为ResponseEntity类型 // ResponseEntity中包含了响应结果中的所有信息，比如头、状态、body ResponseEntity responseEntity = restTemplate.getForEntity(url, BookDto.class); //状态码 System.out.println(responseEntity.getStatusCode()); //获取头 System.out.println("头：" + responseEntity.getHeaders()); //获取body BookDto bookDto = responseEntity.getBody(); System.out.println(bookDto);} test1 输出
BookDto{id=1, name='SpringMVC系列'}test2 输出
200 OK头：[Content-Type:"application/json;charset=UTF-8", Transfer-Encoding:"chunked", Date:"Sat, 02 Oct 2021 07:05:15 GMT", Keep-Alive:"timeout=20", Connection:"keep-alive"]BookDto{id=1, name='SpringMVC系列'}3.2、url 中含有动态参数
接口代码
@GetMapping("/test/get/{id}/{name}")@ResponseBodypublic BookDto get(@PathVariable("id") Integer id, @PathVariable("name") String name) { return new BookDto(id, name);}使用 RestTemplate 调用上面这个接口，通常有 2 种写法，如下
@Testpublic void test3() { RestTemplate restTemplate = new RestTemplate(); //url中有动态参数 String url = "http://localhost:8080/chat16/test/get/{id}/{name}"; Map uriVariables = new HashMap<>(); uriVariables.put("id", "1"); uriVariables.put("name", "SpringMVC系列"); //使用getForObject或者getForEntity方法 BookDto bookDto = restTemplate.getForObject(url, BookDto.class, uriVariables); System.out.println(bookDto);}@Testpublic void test4() { RestTemplate restTemplate = new RestTemplate(); //url中有动态参数 String url = "http://localhost:8080/chat16/test/get/{id}/{name}"; Map uriVariables = new HashMap<>(); uriVariables.put("id", "1"); uriVariables.put("name", "SpringMVC系列"); //getForEntity方法 ResponseEntity responseEntity = restTemplate.getForEntity(url, BookDto.class, uriVariables); BookDto bookDto = responseEntity.getBody(); System.out.println(bookDto);} test3 输出
BookDto{id=1, name='SpringMVC系列'}test4 输出
BookDto{id=1, name='SpringMVC系列'}3.3、接口返回值为泛型
接口代码
@GetMapping("/test/getList")@ResponseBodypublic List getList() { return Arrays.asList( new BookDto(1, "Spring高手系列"), new BookDto(2, "SpringMVC系列") );} 当接口的返回值为泛型的时候，这种情况比较特殊，使用 RestTemplate 调用上面这个接口，代码如下，需要用到restTemplate.exchange的方法，这个方法中有个参数是ParameterizedTypeReference类型，通过这个参数类指定泛型类型
@Testpublic void test5() { RestTemplate restTemplate = new RestTemplate(); //返回值为泛型 String url = "http://localhost:8080/chat16/test/getList"; //若返回结果是泛型类型的，需要使用到exchange方法， //这个方法中有个参数是ParameterizedTypeReference类型，通过这个参数类指定泛型类型 ResponseEntity> responseEntity = restTemplate.exchange(url, HttpMethod.GET, null, new ParameterizedTypeReference>() { }); List bookDtoList = responseEntity.getBody(); System.out.println(bookDtoList);} 输出
[BookDto{id=1, name='Spring高手系列'}, BookDto{id=2, name='SpringMVC系列'}]3.4、下载小文件
接口代码如下，这个接口会下载服务器端的 1.txt 文件。
@GetMapping("/test/downFile")@ResponseBodypublic HttpEntity downFile() { //将文件流封装为InputStreamResource对象 InputStream inputStream = this.getClass().getResourceAsStream("/1.txt"); InputStreamResource inputStreamResource = new InputStreamResource(inputStream); //设置header MultiValueMap headers = new HttpHeaders(); headers.add(HttpHeaders.CONTENT_DISPOSITION, "attachment;filename=1.txt"); HttpEntity httpEntity = new HttpEntity<>(inputStreamResource); return httpEntity;} 使用 RestTemplate 调用这个接口，代码如下，目前这个文件的内容比较少，可以直接得到一个数组。
@Testpublic void test6() { RestTemplate restTemplate = new RestTemplate(); String url = "http://localhost:8080/chat16/test/downFile"; //文件比较小的情况，直接返回字节数组 ResponseEntity responseEntity = restTemplate.getForEntity(url, byte[].class); //获取文件的内容 byte[] body = responseEntity.getBody(); String content = new String(body); System.out.println(content);} 注意：如果文件大的时候，这种方式就有问题了，会导致 oom，要用下面的方式了。
3.5、下载大文件
接口代码，继续使用上面下载 1.txt 的代码
@GetMapping("/test/downFile")@ResponseBodypublic HttpEntity downFile() { //将文件流封装为InputStreamResource对象 InputStream inputStream = this.getClass().getResourceAsStream("/1.txt"); InputStreamResource inputStreamResource = new InputStreamResource(inputStream); //设置header MultiValueMap headers = new HttpHeaders(); headers.add(HttpHeaders.CONTENT_DISPOSITION, "attachment;filename=1.txt"); HttpEntity httpEntity = new HttpEntity<>(inputStreamResource); return httpEntity;} 此时使用 RestTemplate 调用这个接口，代码如下
文件比较大的时候，比如好几个 G，就不能返回字节数组了，会把内存撑爆，导致 OOM，需要使用 execute 方法了，这个方法中有个 ResponseExtractor 类型的参数，restTemplate 拿到结果之后，会回调{@link ResponseExtractor#extractData}这个方法，在这个方法中可以拿到响应流，然后进行处理，这个过程就是变读边处理，不会导致内存溢出
@Testpublic void test7() { RestTemplate restTemplate = new RestTemplate(); String url = "http://localhost:8080/chat16/test/downFile"; String result = restTemplate.execute(url, HttpMethod.GET, null, new ResponseExtractor() { @Override public String extractData(ClientHttpResponse response) throws IOException { System.out.println("状态："+response.getStatusCode()); System.out.println("头："+response.getHeaders()); //获取响应体流 InputStream body = response.getBody(); //处理响应体流 String content = IOUtils.toString(body, "UTF-8"); return content; } }, new HashMap<>()); System.out.println(result);} 3.6、传递头
接口代码
@GetMapping("/test/header")@ResponseBodypublic Map> header(HttpServletRequest request) { Map> header = new LinkedHashMap<>(); Enumeration headerNames = request.getHeaderNames(); while (headerNames.hasMoreElements()) { String name = headerNames.nextElement(); Enumeration values = request.getHeaders(name); List list = new ArrayList<>(); while (values.hasMoreElements()) { list.add(values.nextElement()); } header.put(name, list); } return header;} 使用 RestTemplate 调用接口，请求头中传递数据，代码如下，注意代码①和②，这两处是关键，用到了HttpHeaders和RequestEntity
请求头放在 HttpHeaders 对象中
RequestEntity：请求实体，请求的所有信息都可以放在 RequestEntity 中，比如 body 部分、头、请求方式、url 等信息
@Testpublic void test8() { RestTemplate restTemplate = new RestTemplate(); String url = "http://localhost:8080/chat16/test/header"; //①：请求头放在HttpHeaders对象中 MultiValueMap headers = new HttpHeaders(); headers.add("header-1", "V1"); headers.add("header-2", "Spring"); headers.add("header-2", "SpringBoot"); //②：RequestEntity：请求实体，请求的所有信息都可以放在RequestEntity中，比如body部分、头、请求方式、url等信息 RequestEntity requestEntity = new RequestEntity( null, //body部分数据 headers, //头 HttpMethod.GET,//请求方法 URI.create(url) //地址 ); ResponseEntity>> responseEntity = restTemplate.exchange(requestEntity, new ParameterizedTypeReference>>() { }); Map> result = responseEntity.getBody(); System.out.println(result);} 输出
{accept=[application/json, application InputStream inputStream = RestTemplateTest.class.getResourceAsStream("/1.txt"); InputStreamResource inputStreamResource = new InputStreamResource(inputStream) { @Override public String getFilename() { return "1.txt"; } @Override public long contentLength() throws IOException { return inputStream.available(); } }; body.add("file1", inputStreamResource); //③：头 HttpHeaders headers = new HttpHeaders(); headers.add("header1", "v1"); headers.add("header2", "v2"); //④：请求实体 RequestEntity> requestEntity = new RequestEntity<>(body, headers, HttpMethod.POST, URI.create(url)); //⑤：发送请求(请求实体，返回值需要转换的类型) ResponseEntity> responseEntity = restTemplate.exchange( requestEntity, new ParameterizedTypeReference>() { }); Map result = responseEntity.getBody(); System.out.println(result);} 4.5、复杂表单：多个普通元素+多文件上传
接口
@PostMapping("/test/form3")@ResponseBodypublic Map form3(UserDto userDto) { Map result = new LinkedHashMap<>(); result.put("name", userDto.getName()); result.put("headImg", userDto.getHeadImg().getOriginalFilename()); result.put("idImgList", Arrays.toString(userDto.getIdImgList().stream(). map(MultipartFile::getOriginalFilename).toArray())); return result;} UserDto：包含了多个元素（姓名、头像、多张证件照），这种可以模拟复杂的表单
public class UserDto { //姓名 private String name; //头像 private MultipartFile headImg; //多张证件照 private List idImgList; //get set 省略了...} 用 RestTemplate 调用这个接口，代码如下
@Testpublic void test14() { RestTemplate restTemplate = new RestTemplate(); String url = "http://localhost:8080/chat16/test/form3"; //①：表单信息，需要放在MultiValueMap中，MultiValueMap相当于Map> MultiValueMap body = new LinkedMultiValueMap<>(); body.add("name", "路人"); body.add("headImg", new FileSystemResource(".\\src\\main\\resources\\1.jpg")); //来2张证件照，元素名称一样 body.add("idImgList", new FileSystemResource(".\\src\\main\\resources\\2.jpg")); body.add("idImgList", new FileSystemResource(".\\src\\main\\resources\\3.jpg")); //③：头 HttpHeaders headers = new HttpHeaders(); headers.add("header1", "v1"); headers.add("header2", "v2"); //④：请求实体 RequestEntity> requestEntity = new RequestEntity<>(body, headers, HttpMethod.POST, URI.create(url)); //⑤：发送请求(请求实体，返回值需要转换的类型) ResponseEntity> responseEntity = restTemplate.exchange( requestEntity, new ParameterizedTypeReference>() { }); Map result = responseEntity.getBody(); System.out.println(result);} 输出
{name=路人, headImg=1.jpg, idImgList=[2.jpg, 3.jpg]}4.6、发送 json 格式数据：传递 java 对象
接口
@PostMapping("/test/form4")@ResponseBodypublic BookDto form4(@RequestBody BookDto bookDto) { return bookDto;}RestTemplate 调用接口
@Testpublic void test15() { RestTemplate restTemplate = new RestTemplate(); String url = "http://localhost:8080/chat16/test/form4"; BookDto body = new BookDto(1, "SpringMVC系列"); BookDto result = restTemplate.postForObject(url, body, BookDto.class); System.out.println(result);}输出
BookDto{id=1, name='SpringMVC系列'}4.7、发送 json 格式数据：传递 java 对象，返回值为泛型
接口
@PostMapping("/test/form5")@ResponseBodypublic List form5(@RequestBody List bookDtoList) { return bookDtoList;} 用 RestTemplate 调用这个接口，代码如下
@Testpublic void test16() { RestTemplate restTemplate = new RestTemplate(); String url = "http://localhost:8080/chat16/test/form5"; //①：请求体，发送的时候会被转换为json格式数据 List body = Arrays.asList( new BookDto(1, "SpringMVC系列"), new BookDto(2, "MySQL系列")); //②：头 HttpHeaders headers = new HttpHeaders(); headers.add("header1", "v1"); headers.add("header2", "v2"); //③：请求实体 RequestEntity requestEntity = new RequestEntity(body, headers, HttpMethod.POST, URI.create(url)); //④：发送请求(请求实体，返回值需要转换的类型) ResponseEntity> responseEntity = restTemplate.exchange( requestEntity, new ParameterizedTypeReference>() { }); //⑤：获取结果 List result = responseEntity.getBody(); System.out.println(result);} 输出
[BookDto{id=1, name='SpringMVC系列'}, BookDto{id=2, name='MySQL系列'}]4.8、发送 json 字符串格式数据
上面 2 个 json 案例 body 都是 java 对象，RestTemplate 默认自动配上 Content-Type=application/json
但是如果 body 的值是 json 格式字符串的时候，调用的时候需要在头中明确指定 Content-Type=application/json，写法如下：
@Testpublic void test17() { RestTemplate restTemplate = new RestTemplate(); String url = "http://localhost:8080/chat16/test/form5"; //①：请求体为一个json格式的字符串 String body = "[{\"id\":1,\"name\":\"SpringMVC系列\"},{\"id\":2,\"name\":\"MySQL系列\"}]"; HttpHeaders headers = new HttpHeaders(); headers.setContentType(MediaType.APPLICATION_JSON); //③：请求实体（body，头、请求方式，uri） RequestEntity requestEntity = new RequestEntity(body, headers, HttpMethod.POST, URI.create(url)); //④：发送请求(请求实体，返回值需要转换的类型) ResponseEntity> responseEntity = restTemplate.exchange( requestEntity, new ParameterizedTypeReference>() { }); //⑤：获取结果 List result = responseEntity.getBody(); System.out.println(result);} 输出
[BookDto{id=1, name='SpringMVC系列'}, BookDto{id=2, name='MySQL系列'}]5、DELETE、PUT、OPTION 请求
5.1、DELETE 请求
public void delete(String url, Object... uriVariables);public void delete(String url, Map uriVariables);public void delete(URI url); 5.2、PUT 请求
PUT 请求和 POST 请求类似，将类型改为 PUT 就可以了。
5.3、OPTIONS 请求
OPTIONS 请求用来探测接口支持哪些 http 方法
public Set optionsForAllow(String url, Object... uriVariables);public Set optionsForAllow(String url, Map uriVariables);public Set optionsForAllow(URI url); 6、集成 HttpClient
RestTemplate 内部默认用的是 jdk 自带的 HttpURLConnection 发送请求的，性能上面并不是太突出。
可以将其替换为 httpclient 或者 okhttp。
先来看下如何替换为 HttpClient。
引入 maven 配置
org.apache.httpcomponents httpclient 4.5.7 创建 RestTemplate 时指定 HttpClient 配置，代码如下
public HttpClient httpClient() { HttpClientBuilder httpClientBuilder = HttpClientBuilder.create(); try { //设置信任ssl访问 SSLContext sslContext = new SSLContextBuilder().loadTrustMaterial(null, (arg0, arg1) -> true).build(); httpClientBuilder.setSSLContext(sslContext); HostnameVerifier hostnameVerifier = NoopHostnameVerifier.INSTANCE; SSLConnectionSocketFactory sslConnectionSocketFactory = new SSLConnectionSocketFactory(sslContext, hostnameVerifier); Registry socketFactoryRegistry = RegistryBuilder.create() // 注册http和https请求 .register("http", PlainConnectionSocketFactory.getSocketFactory()) .register("https", sslConnectionSocketFactory).build(); //使用Httpclient连接池的方式配置(推荐)，同时支持netty，okHttp以及其他http框架 PoolingHttpClientConnectionManager poolingHttpClientConnectionManager = new PoolingHttpClientConnectionManager(socketFactoryRegistry); // 最大连接数 poolingHttpClientConnectionManager.setMaxTotal(1000); // 同路由并发数 poolingHttpClientConnectionManager.setDefaultMaxPerRoute(100); //配置连接池 httpClientBuilder.setConnectionManager(poolingHttpClientConnectionManager); // 重试次数 httpClientBuilder.setRetryHandler(new DefaultHttpRequestRetryHandler(0, true)); //设置默认请求头 List headers = new ArrayList<>(); httpClientBuilder.setDefaultHeaders(headers); return httpClientBuilder.build(); } catch (Exception e) { throw new RuntimeException(e); }}public ClientHttpRequestFactory clientHttpRequestFactory() { HttpComponentsClientHttpRequestFactory clientHttpRequestFactory = new HttpComponentsClientHttpRequestFactory(httpClient()); // 连接超时(毫秒)，这里设置10秒 clientHttpRequestFactory.setConnectTimeout(10 * 1000); // 数据读取超时时间(毫秒)，这里设置60秒 clientHttpRequestFactory.setReadTimeout(60 * 1000); // 从连接池获取请求连接的超时时间(毫秒)，不宜过长，必须设置，比如连接不够用时，时间过长将是灾难性的 clientHttpRequestFactory.setConnectionRequestTimeout(10 * 1000); return clientHttpRequestFactory;}public RestTemplate restTemplate(){ //创建RestTemplate的时候，指定ClientHttpRequestFactory return new RestTemplate(this.clientHttpRequestFactory());}@Testpublic void test18() { RestTemplate restTemplate = this.restTemplate(); String url = "http://localhost:8080/chat16/test/get"; //getForObject方法，获取响应体，将其转换为第二个参数指定的类型 BookDto bookDto = restTemplate.getForObject(url, BookDto.class); System.out.println(bookDto);} 7、集成 okhttp
引入 maven 配置
com.squareup.okhttp3 okhttp 4.3.1 创建 RestTemplate
new RestTemplate(new OkHttp3ClientHttpRequestFactory());8、总结
RestTemplate 使用确实非常容易，建议大家去看一下 RestTemplate 的源码，debug 跟踪一下过程，这样用起来就非常顺手了。
9、SpringMVC 系列目录
10、更多好文章
11、【路人甲 Java】所有系列高清 PDF
领取方式，扫码发送：yyds
来源地址：https://blog.csdn.net/likun557/article/details/121072832
