一:整体介绍restTemplate的使用
restTemplate底层调用的是Execute方法,而Execute底层调用的是doExecute,它是基于http协议的,底层还是httpClient 的使用
二、注意细节
1、RestTemplate 的传参
RestTemplate 的 Post 方法与 Get 方法的区别是 Post 方法传参 Map 必须是 MultiValueMap。
Post 方法的 MultiValueMap 既支持基本类型分开传参,也支持实体传参。
2、get 和 post 方法参数列表顺序不同
restTemplate.postForObject(url, paramMap, UserDTO.class);
restTemplate.getForObject(url, UserDTO.class, paramMap);
3、接口若是使用 @RequestBody 接收参数**,则请求接口时需要使用 HttpEntity 形式对包装类进行包装传参**
@GetMapping("/postForObject")
public R postForObject(){
// 申明一个请求头
HttpHeaders headers = new HttpHeaders();
// application/json
// 媒体类型需要根据接口需要进行修改
headers.setContentType(MediaType.APPLICATION_JSON);
// 远程访问的 Url
String url = "http://localhost:8080/addUser";
/**
此处使用 MultiValueMap 会报错
MultiValueMap<String, Object> paramMap = new LinkedMultiValueMap<>();
paramMap.add("userId", 1000L);
paramMap.add("userName", "zhangsan");
*/
// 此处可以使用 HashMap 代替,但是会有警告
UserDTO userDTO = new UserDTO();
userDTO.setUserId(1000L);
userDTO.setUserName("zhangsan");
// 使用 HttpEntity 形式对包装类进行包装传参
HttpEntity<UserDTO> entityParam = new HttpEntity<UserDTO>(userDTO, headers);
UserDTO result = restTemplate.postForObject(url, entityParam, UserDTO.class);
}
三、RestTemplate 使用步骤
1、创建配置类
注入 RestTemplateBuilder 类对象,使用他来生成 RestTemplate
java复制代码@Configuration
```java
```java
public class RestTemplate{
@Autowired
private RestTemplateBuilder builder;
@Bean
public RestTemplate restTemplate(){
return builder.build();
}
}
2、在 service 中注入 RestTemplate 类对象
@Autowired
private RestTemplate restTemplate;
使用 RestTemplate 对象请求第三方
java复制代码log.info(“下面请求第三方”);
ResponseEntity responseEntity = restTemplate.getForEntity(WEATHER_URL + id, String.class);
4、获取请求体 body(因为对我们来说请求体里面的数据才是我们需要的)
//获取请求 body
String responseEntityBody = responseEntity.getBody();
有时候我在调用服务提供者提供的接口时,可能需要传递参数,有两种不同的方式:
@RequestMapping("/sayhello")
public String sayHello() {
ResponseEntity<String> responseEntity = restTemplate.getForEntity("http://HELLO-SERVICE/sayhello?name={1}", String.class, "张三");
return responseEntity.getBody();
}
```java
@RequestMapping("/sayhello2")
public String sayHello2() {
Map<String, String> map = new HashMap<>();
map.put("name", "李四");
ResponseEntity<String> responseEntity = restTemplate.getForEntity("http://HELLO-SERVICE/sayhello?name={name}", String.class, map);
return responseEntity.getBody();
}
可以用一个数字做占位符,最后是一个可变长度的参数,来一 一替换前面的占位符
也可以前面使用 name={name} 这种形式,最后一个参数是一个 map,map 的 key 即为前边占位符的名字,map的 value 为参数值
第一个调用地址也可以是一个URI而不是字符串,这个时候我们构建一个URI即可,参数神马的都包含在URI中了,如下:
@RequestMapping("/sayhello3")
public String sayHello3() {
UriComponents uriComponents = UriComponentsBuilder.fromUriString("http://HELLO-SERVICE/sayhello?name={name}").build().expand("王五").encode();
URI uri = uriComponents.toUri();
ResponseEntity<String> responseEntity = restTemplate.getForEntity(uri, String.class);
return responseEntity.getBody();
}
POST 方法
在 RestTemplate 中,POST 请求可以通过如下三个方法来发起:
postForEntity
@RequestMapping("/book3")
public Book book3() {
Book book = new Book();
book.setName("红楼梦");
ResponseEntity<Book> responseEntity = restTemplate.postForEntity("http://HELLO-SERVICE/getbook2", book, Book.class);
return responseEntity.getBody();
}
如果你只关注,返回的消息体,可以直接使用postForObject。用法和getForObject一致。
PUT 方法
在 RestTemplate 中,PUT 请求可以通过 put 方法调用,put 方法的参数和前面介绍的 postForEntity 方法的参数基本一致,只是 put 方法没有返回值而已。举一个简单的例子,如下:
@RequestMapping("/put")
public void put() {
Book book = new Book();
book.setName("红楼梦");
restTemplate.put("http://HELLO-SERVICE/getbook3/{1}", book, 99);
}
delete 请求我们可以通过 delete 方法调用来实现,如下例子:
@RequestMapping("/delete")
public void delete() {
restTemplate.delete("http://HELLO-SERVICE/getbook4/{1}", 100);
}
https://gitee.com/javacode2018/springmvc-series
3.2、url 中含有动态参数
接口代码
使用 RestTemplate 调用上面这个接口,通常有 2 种写法,如下
@GetMapping("/test/get/{id}/{name}")
@ResponseBody
public BookDto get(@PathVariable("id") Integer id, @PathVariable("name") String name) {
return new BookDto(id, name);
}
``
```java
@Test
public void test3() {
RestTemplate restTemplate = new RestTemplate();
//url中有动态参数
String url = "http://localhost:8080/chat16/test/get/{id}/{name}";
Map<String, String> 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);
}
@Test
public void test4() {
RestTemplate restTemplate = new RestTemplate();
//url中有动态参数
String url = "http://localhost:8080/chat16/test/get/{id}/{name}";
Map<String, String> uriVariables = new HashMap<>();
uriVariables.put("id", "1");
uriVariables.put("name", "SpringMVC系列");
//getForEntity方法
ResponseEntity<BookDto> responseEntity = restTemplate.getForEntity(url, BookDto.class, uriVariables);
BookDto bookDto = responseEntity.getBody();
System.out.println(bookDto);
}
3.3、接口返回值为泛型
接口代码
@GetMapping("/test/getList")
@ResponseBody
public List<BookDto> getList() {
return Arrays.asList(
new BookDto(1, "Spring高手系列"),
new BookDto(2, "SpringMVC系列")
);
}
当接口的返回值为泛型的时候,这种情况比较特殊,使用 RestTemplate 调用上面这个接口,代码如下,需要用到restTemplate.exchange的方法,这个方法中有个参数是ParameterizedTypeReference类型,通过这个参数类指定泛型类型
@Test
public void test5() {
RestTemplate restTemplate = new RestTemplate();
//返回值为泛型
String url = "http://localhost:8080/chat16/test/getList";
//若返回结果是泛型类型的,需要使用到exchange方法,
//这个方法中有个参数是ParameterizedTypeReference类型,通过这个参数类指定泛型类型
ResponseEntity<List<BookDto>> responseEntity =
restTemplate.exchange(url,
HttpMethod.GET,
null,
new ParameterizedTypeReference<List<BookDto>>() {
});
List<BookDto> bookDtoList = responseEntity.getBody();
System.out.println(bookDtoList);
}
3.4、下载小文件
接口代码如下,这个接口会下载服务器端的 1.txt 文件。
/**
* 下载文件
*
* @return
*/
@GetMapping("/test/downFile")
@ResponseBody
public HttpEntity<InputStreamResource> downFile() {
//将文件流封装为InputStreamResource对象
InputStream inputStream = this.getClass().getResourceAsStream("/1.txt");
InputStreamResource inputStreamResource = new InputStreamResource(inputStream);
//设置header
MultiValueMap<String, String> headers = new HttpHeaders();
headers.add(HttpHeaders.CONTENT_DISPOSITION, "attachment;filename=1.txt");
HttpEntity<InputStreamResource> httpEntity = new HttpEntity<>(inputStreamResource);
return httpEntity;
}
```java
```@Test
public void test6() {
RestTemplate restTemplate = new RestTemplate();
String url = "http://localhost:8080/chat16/test/downFile";
//文件比较小的情况,直接返回字节数组
ResponseEntity<byte[]> responseEntity = restTemplate.getForEntity(url, byte[].class);
//获取文件的内容
byte[] body = responseEntity.getBody();
String content = new String(body);
System.out.println(content);
}
3.5、下载大文件
接口代码,继续使用上面下载 1.txt 的代码
/**
- 下载文件
- @return
*/
@GetMapping("/test/downFile")
@ResponseBody
public HttpEntity<InputStreamResource> downFile() {
//将文件流封装为InputStreamResource对象
InputStream inputStream = this.getClass().getResourceAsStream("/1.txt");
InputStreamResource inputStreamResource = new InputStreamResource(inputStream);
//设置header
MultiValueMap<String, String> headers = new HttpHeaders();
headers.add(HttpHeaders.CONTENT_DISPOSITION, "attachment;filename=1.txt");
HttpEntity<InputStreamResource> httpEntity = new HttpEntity<>(inputStreamResource);
return httpEntity;
}
此时使用 RestTemplate 调用这个接口,代码如下
文件比较大的时候,比如好几个 G,就不能返回字节数组了,会把内存撑爆,导致 OOM,需要使用 execute 方法了,这个方法中有个 ResponseExtractor 类型的参数,restTemplate 拿到结果之后,会回调{@link ResponseExtractor#extractData}这个方法,在这个方法中可以拿到响应流,然后进行处理,这个过程就是变读边处理,不会导致内存溢出
@Test
public void test7() {
RestTemplate restTemplate = new RestTemplate();
String url = “http://localhost:8080/chat16/test/downFile”;
/**
* 文件比较大的时候,比如好几个G,就不能返回字节数组了,会把内存撑爆,导致OOM
* 需要这么玩:
* 需要使用execute方法了,这个方法中有个ResponseExtractor类型的参数,
* restTemplate拿到结果之后,会回调{@link ResponseExtractor#extractData}这个方法,
* 在这个方法中可以拿到响应流,然后进行处理,这个过程就是变读边处理,不会导致内存溢出。
String result = restTemplate.execute(url,
HttpMethod.GET,
null,
new ResponseExtractor<String>() {
@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);
@Test
@GetMapping("/test/getAll/{path1}/{path2}")
@ResponseBody
```java
public Map<String, Object> getAll(@PathVariable("path1") String path1,
@PathVariable("path2") String path2,
HttpServletRequest request) {
Map<String, Object> result = new LinkedHashMap<>();
result.put("path1", path1);
result.put("path2", path2);
//头
Map<String, List<String>> header = new LinkedHashMap<>();
Enumeration<String> headerNames = request.getHeaderNames();
while (headerNames.hasMoreElements()) {
String name = headerNames.nextElement();
Enumeration<String> values = request.getHeaders(name);
List<String> list = new ArrayList<>();
while (values.hasMoreElements()) {
list.add(values.nextElement());
}
header.put(name, list);
}
result.put("header", header);
return result;
}
综合案例:含头、url 动态参数
public void test9() {
RestTemplate restTemplate = new RestTemplate();
String url = "http://localhost:8080/chat16/test/getAll/{path1}/{path2}";
//①:请求头
MultiValueMap<String, String> headers = new HttpHeaders();
headers.add("header-1", "V1");
headers.add("header-2", "Spring");
headers.add("header-2", "SpringBoot");
//②:url中的2个参数
Map<String, String> uriVariables = new HashMap<>();
uriVariables.put("path1", "v1");
uriVariables.put("path2", "v2");
//③:HttpEntity:HTTP实体,内部包含了请求头和请求体
HttpEntity requestEntity = new HttpEntity(
null,//body部分,get请求没有body,所以为null
headers //头
);
//④:使用exchange发送请求
ResponseEntity<Map<String, Object>> responseEntity = restTemplate.exchange(
url, //url
HttpMethod.GET, //请求方式
requestEntity, //请求实体(头、body)
new ParameterizedTypeReference<Map<String, Object>>() {
},//返回的结果类型
uriVariables //url中的占位符对应的值
);
Map<String, Object> result = responseEntity.getBody();
System.out.println(result);
}
## 4、POST 请求
4.1、post 请求常见的 3 种类型
http 请求头中的 Content-Type 用来指定请求的类型,常见的有 3 种
Content-Type
说明
application/x-www-form-urlencoded
页面中普通的 form 表单提交时就是这种类型,表单中的元素会按照名称和值拼接好,然后之间用&连接,格式如:p1=v1&p2=v2&p3=v3然后通过 urlencoded 编码之后丢在 body 中发送
multipart/form-data
页面中表单上传文件的时候,用到的就是这种格式
application/json
将发送的数据转换为 json 格式,丢在 http 请求的 body 中发送,后端接口通常用@RequestBody 配合对象来接收。
```java
@Test
public void test10() {
RestTemplate restTemplate = new RestTemplate();
String url = "http://localhost:8080/chat16/test/form1";
//①:表单信息,需要放在MultiValueMap中,MultiValueMap相当于Map<String,List<String>>
MultiValueMap<String, String> body = new LinkedMultiValueMap<>();
//调用add方法填充表单数据(表单名称:值)
body.add("id","1");
body.add("name","SpringMVC系列");
//②:发送请求(url,请求体,返回值需要转换的类型)
BookDto result = restTemplate.postForObject(url, body, BookDto.class);
System.out.println(result);
}
@Test
public void test11() {
RestTemplate restTemplate = new RestTemplate();
String url = "http://localhost:8080/chat16/test/form1";
//①:表单信息,需要放在MultiValueMap中,MultiValueMap相当于Map<String,List<String>>
MultiValueMap<String, String> body = new LinkedMultiValueMap<>();
//调用add方法放入表单元素(表单名称:值)
body.add("id","1");
body.add("name","SpringMVC系列");
//②:请求头
HttpHeaders headers = new HttpHeaders();
//调用set方法放入请求头
headers.set(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_FORM_URLENCODED_VALUE);
//③:请求实体:包含了请求体和请求头
HttpEntity<MultiValueMap<String, String>> httpEntity = new HttpEntity<>(body, headers);
//④:发送请求(url,请求实体,返回值需要转换的类型)
BookDto result = restTemplate.postForObject(url, httpEntity, BookDto.class);
System.out.println(result);
}
4.3、上传本地文件
上传文件 Content-Type 为 multipart/form-data 类型。
接口如下,上传上传单个文件,返回值为一个 Map 类型,是泛型类型
@PostMapping(value = "/test/form2")
@ResponseBody
public Map<String, String> form2(@RequestParam("file1") MultipartFile file1) {
Map<String, String> fileMetadata = new LinkedHashMap<>();
fileMetadata.put("文件名", file1.getOriginalFilename());
fileMetadata.put("文件类型", file1.getContentType());
fileMetadata.put("文件大小(byte)", String.valueOf(file1.getSize()));
return fileMetadata;
}
使用 RestTemplate 调用接口,主要下面代码②上传的文件需要包装为org.springframework.core.io.Resource,常用的有 3 中[FileSystemResource、InputStreamResource、ByteArrayResource],这里案例中我们用到的是 FileSystemResource 来上传本地文件,另外 2 种(InputStreamResource、ByteArrayResource)用法就比较特殊了,见下个案例。
@Test
public void test12() {
RestTemplate restTemplate = new RestTemplate();
String url = "http://localhost:8080/chat16/test/form2";
//①:表单信息,需要放在MultiValueMap中,MultiValueMap相当于Map<String,List<String>>
MultiValueMap<String, Object> body = new LinkedMultiValueMap<>();
//调用add方法放入表单元素(表单名称:值)
//②:文件对应的类型,需要是org.springframework.core.io.Resource类型的,常见的有[FileSystemResource、InputStreamResource、ByteArrayResource]
body.add("file1", new FileSystemResource(".\\src\\main\\java\\com\\javacode2018\\springmvc\\chat16\\dto\\UserDto.java"));
//③:头
HttpHeaders headers = new HttpHeaders();
headers.add("header1", "v1");
headers.add("header2", "v2");
//④:请求实体
RequestEntity<MultiValueMap<String, Object>> requestEntity = new RequestEntity<>(body, headers, HttpMethod.POST, URI.create(url));
//⑤:发送请求(请求实体,返回值需要转换的类型)
ResponseEntity<Map<String, String>> responseEntity = restTemplate.exchange(
requestEntity,
new ParameterizedTypeReference<Map<String, String>>() {
});
Map<String, String> result = responseEntity.getBody();
System.out.println(result);
}
4.4、通过流或字节数组的方式上传文件
有时候,上传的文件是通过流的方式或者字节数组的方式,那么就需要用到 InputStreamResource、ByteArrayResource 这俩了。
**注意:**使用这俩的时候,需要重写 2 个方法,否则会上传失败
getFilename:文件名称
contentLength:长度
@Test
public void test13() {
RestTemplate restTemplate = new RestTemplate();
String url = "http://localhost:8080/chat16/test/form2";
//①:表单信息,需要放在MultiValueMap中,MultiValueMap相当于Map<String,List<String>>
MultiValueMap<String, Object> body = new LinkedMultiValueMap<>();
/**
* ②:通过流的方式上传文件,流的方式需要用到InputStreamResource类,需要重写2个方法
* getFilename:文件名称
* contentLength:长度
*/
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<MultiValueMap<String, Object>> requestEntity = new RequestEntity<>(body, headers, HttpMethod.POST, URI.create(url));
//⑤:发送请求(请求实体,返回值需要转换的类型)
ResponseEntity<Map<String, String>> responseEntity = restTemplate.exchange(
requestEntity,
new ParameterizedTypeReference<Map<String, String>>() {
});
Map<String, String> result = responseEntity.getBody();
System.out.println(result);
}
@Test
public void test14() {
RestTemplate restTemplate = new RestTemplate();
String url = "http://localhost:8080/chat16/test/form3";
//①:表单信息,需要放在MultiValueMap中,MultiValueMap相当于Map<String,List<String>>
MultiValueMap<String, Object> 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<MultiValueMap<String, Object>> requestEntity = new RequestEntity<>(body, headers, HttpMethod.POST, URI.create(url));
//⑤:发送请求(请求实体,返回值需要转换的类型)
ResponseEntity<Map<String, String>> responseEntity = restTemplate.exchange(
requestEntity,
new ParameterizedTypeReference<Map<String, String>>() {
});
Map<String, String> result = responseEntity.getBody();
System.out.println(result);
}
4.6、发送 json 格式数据:传递 java 对象
@Test
public 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);
}
4.7、发送 json 格式数据:传递 java 对象,返回值为泛型
接口
/**
* body中json格式的数据,返回值为泛型
*
* @param bookDtoList
* @return
*/
@PostMapping("/test/form5")
@ResponseBody
public List<BookDto> form5(@RequestBody List<BookDto> bookDtoList) {
return bookDtoList;
}
用 RestTemplate 调用这个接口,代码如下
@Test
public void test16() {
RestTemplate restTemplate = new RestTemplate();
String url = "http://localhost:8080/chat16/test/form5";
//①:请求体,发送的时候会被转换为json格式数据
List<BookDto> 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<List<BookDto>> responseEntity = restTemplate.exchange(
requestEntity,
new ParameterizedTypeReference<List<BookDto>>() {
});
//⑤:获取结果
List<BookDto> result = responseEntity.getBody();
System.out.println(result);
}
4.8、发送 json 字符串格式数据
上面 2 个 json 案例 body 都是 java 对象,RestTemplate 默认自动配上 Content-Type=application/json
但是如果 body 的值是 json 格式字符串的时候,调用的时候需要在头中明确指定 Content-Type=application/json,写法如下:
@Test
public 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系列\"}]";
/**
* ②:若请求体为json字符串的时候,需要在头中设置Content-Type=application/json;
* 若body是普通的java类的时候,无需指定这个,RestTemplate默认自动配上Content-Type=application/json
*/
HttpHeaders headers = new HttpHeaders();
headers.setContentType(MediaType.APPLICATION_JSON);
//③:请求实体(body,头、请求方式,uri)
RequestEntity requestEntity = new RequestEntity(body, headers, HttpMethod.POST, URI.create(url));
//④:发送请求(请求实体,返回值需要转换的类型)
ResponseEntity<List<BookDto>> responseEntity = restTemplate.exchange(
requestEntity,
new ParameterizedTypeReference<List<BookDto>>() {
});
//⑤:获取结果
List<BookDto> result = responseEntity.getBody();
System.out.println(result);
}