RestTemplate.exchange各种用法（包括泛型等 --全）
文章目录
- 前言
- 1. Get请求
-
- 1.1 返回基本类型
- 1.2 返回自定义对象类型
- 1.3 返回List\
类型 - 1.4 返回Map\
- 1.5 返回自定义泛型类型
- 2.Post请求
-
- 2.1 传header+body返回对象类型
- 2.2 传header+body返回自定义泛型类型
- 3. 异常情况处理
- 4. RestTemplate配置@Bean
- 相关博文
- 最后
前言
在我们日常开发中，无论是内部服务之间的调用，还是调用第三方服务，都免不了发起Http请求，在Java中发起Http请求常见的方式大致有原生HttpURLConnection、Apache的HttpClient、Spring的RestTemplate等，如果您基于Spring框架，那么强烈推荐使用RestTemplate，理由很简单：非常符合我们发起http请求的习惯，就像使用postman，只需要关心具体的url、header、body等即可，对于繁琐的细节RestTemplate都帮我们安排(封装)的明明白白，无关的细节我们统统不用操心！ 尤其是RestTemplate.exchange方法，可以称的上是单靠一招就可以吊打其它方式。。。 所以本文就来详细介绍一下RestTemplate.exchange各种用法，力求覆盖日常开发中的各种场景，Let’s start~~
1. Get请求
这里准备了5个常见场景：
1.1 返回基本类型
1.2 返回自定义对象类型
1.3 返回List
1.4 返回Map
1.5 返回自定义泛型类型
1.1 返回基本类型
我们先模拟一个最基础的API：根据用户id获取name
调用代码：
// 1.1 get请求返回基本类型
@GetMapping("/name")
public String getName(@RequestParam("id") Integer id) {
String url = "http://localhost:8080/demo/name/mock?id=" + id;
return restTemplate.exchange(url, HttpMethod.GET, null, String.class).getBody();
}
被调用的mock代码：
@GetMapping("/name/mock")
public String mockName(@RequestParam("id") Integer id) {
return "天罡" + id;
}
验证一下： 如期望一样，不得不说就应该这么简洁，good~~
请求 http://localhost:8080/demo/name?id=123
返回 天罡123
关于exchange的方法参数说明：
直接看源码的注释吧，非常清晰，再说就属于画蛇添足了哈
1.2 返回自定义对象类型
其实自定义的对象和String调用是一样的，只需要将返回类型String.class改成DTO.class即可，比如：根据用户id获取用户信息
新建一个UserDto对象：
@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
public class UserDto implements Serializable {
private Integer id;
private String name;
private Integer age;
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date birthday;
}
调用代码：
// 1.2 get请求返回对象类型
@GetMapping("/user")
public UserDto getUser(@RequestParam("id") Integer id) {
String url = "http://localhost:8080/demo/user/mock?id=" + id;
return restTemplate.exchange(url, HttpMethod.GET, null, UserDto.class).getBody();
}
被调用的mock代码：
@GetMapping("/user/mock")
public UserDto mockUser(@RequestParam("id") Integer id) {
return UserDto.builder().id(id)
.name("天罡" + id)
.age(id + 18)
.birthday(new Date()).build();
}
验证一下： ok~~
请求 http://localhost:8080/demo/user?id=1
返回
{
“id”: 1,
“name”: “天罡”,
“age”: 19,
“birthday”: “2022-11-06 05:35:43”
}
1.3 返回List 类型
对于泛型类型，我们需要使用exchange的另一个针对泛型的重载方法，即将responseType换成ParameterizedTypeReference，还是建议看源码注释：
接下来，我们继续模拟一个常见场景：根据用户name模糊检索所有匹配的用户，返回结果是多条，我们使用List类型。
调用代码：
通过ParameterizedTypeReference指定返回的List
// 1.3 get请求返回List类型
@GetMapping("/user/list")
public List<UserDto> getUserList(@RequestParam("name") String name) {
String url = "http://localhost:8080/demo/user/list/mock?name=" + name;
ParameterizedTypeReference<List<UserDto>> responseBodyType = new ParameterizedTypeReference<List<UserDto>>() {};
return restTemplate.exchange(url, HttpMethod.GET, null, responseBodyType).getBody();
}
被调用的mock代码：
@GetMapping("/user/list/mock")
public List<UserDto> mockUserList(@RequestParam("name") String name) {
List<UserDto> list = new ArrayList<>();
for (int i = 1; i < 3; i++) {
list.add(UserDto.builder().id(i)
.name(name + i)
.age(i + 10)
.birthday(new Date()).build());
}
return list;
}
验证一下： ok~~
请求 http://localhost:8080/demo/user/list?name=天罡
返回
[
{
“id”: 1,
“name”: “天罡1”,
“age”: 11,
“birthday”: “2022-11-06 21:44:24”
},
{
“id”: 2,
“name”: “天罡2”,
“age”: 12,
“birthday”: “2022-11-06 21:44:24”
}
]
1.4 返回Map 类型
Map也属于泛型类型，并且是有K，V两个类型，我们继续模拟一个常见场景：根据关键字查找，不同类型返回不同字段，因为返回结果字段不固定，所以我们返回Map类型。
调用代码：
依然通过ParameterizedTypeReference指定返回的Map
// 1.4 get请求返回Map类型
@GetMapping("/user/map")
public Map<String, Object> getUserMap(@RequestParam(value = "type", required = true) Integer type, @RequestParam("key") String key) {
String url = "http://localhost:8080/demo/user/map/mock?type=" + type + "&key=" + key;
ParameterizedTypeReference<Map<String, Object>> responseBodyType = new ParameterizedTypeReference<Map<String, Object>>() {};
return restTemplate.exchange(url, HttpMethod.GET, null, responseBodyType).getBody();
}
被调用的mock代码：
@GetMapping("/user/map/mock")
public Map<String, Object> mockUserMap(@RequestParam(value = "type", required = true) Integer type, @RequestParam("key") String key) {
Map<String, Object> map = new HashMap<>();
if (type.equals(1)) {
map.put("id", 1);
map.put("name" + type, "hello" + key);
} else {
map.put("id", 2);
map.put("name" + type, "hello" + key);
}
return map;
}
验证一下： 根据不同类型返回不同字段了，漂亮~~
请求 http://localhost:8080/demo/user/map?type=1&key=123
返回
{
“id”: 1,
“name1”: “hello123”
}
请求 http://localhost:8080/demo/user/map?type=2&key=456
返回
{
“id”: 2,
“name2”: “hello456”
}
1.5 返回自定义泛型类型
我们在1.2 返回自定义对象类型模拟过根据用户id获取用户信息的场景，但未处理非法请求、异常等情况，所以接下来我们自定一个通用的自定义Code的泛型返回结果，对1.2做一下增强：根据用户id获取用户信息，根据不同情况返回不同编码。
我们新建一个Result
@Data
public class Result<T extends Serializable> implements Serializable {
private boolean success;
private String code;
private String message;
private T data;
public static <T extends Serializable> Result<T> success(String code, String message, T data) {
Result<T> result = new Result<>();
result.setCode(code);
result.setMessage(message);
result.setData(data);
result.setSuccess(true);
return result;
}
public static <T extends Serializable> Result<T> success(T data) {
return success("200", "成功", data);
}
public static <T extends Serializable> Result<T> fail(String code, String message) {
Result<T> result = new Result<>();
result.setCode(code);
result.setMessage(message);
result.setSuccess(false);
return result;
}
}
调用代码：
依然通过ParameterizedTypeReference指定返回的Result
// 1.5 get请求返回自定义泛型类型
@GetMapping("/user/result")
public Result<UserDto> getUserResult(@RequestParam("id") Integer id) {
String url = "http://localhost:8080/demo/user/result/mock?id=" + id;
ParameterizedTypeReference<Result<UserDto>> responseBodyType = new ParameterizedTypeReference<Result<UserDto>>() {};
return restTemplate.exchange(url, HttpMethod.GET, null, responseBodyType).getBody();
}
被调用的mock代码：
@GetMapping("/user/result/mock")
public Result<UserDto> mockUserResult(@RequestParam("id") Integer id) {
if (id == null || id <= 0) {
return Result.fail("400", "id不合法!");
}
if (id % 2 == 0) {
// 这里只是模拟异常情况
return Result.fail("500", "操作失败,访问量太大了!");
}
UserDto userDto = UserDto.builder().id(id)
.name("天罡" + id)
.age(id + 18)
.birthday(new Date()).build();
return Result.success("200", "成功", userDto);
}
验证一下： 正是我们想要的，完全符合预期！
请求 http://localhost:8080/demo/user/result?id=0
返回
{
“success”: false,
“code”: “400”,
“message”: “id不合法!”,
“data”: null
}
请求 http://localhost:8080/demo/user/result?id=1
返回
{
“success”: true,
“code”: “200”,
“message”: “成功”,
“data”: {
“id”: 1,
“name”: “天罡1”,
“age”: 19,
“birthday”: “2022-11-07 04:03:09”
}
}
请求 http://localhost:8080/demo/user/result?id=2
返回
{
“success”: false,
“code”: “500”,
“message”: “操作失败,访问量太大了!”,
“data”: null
}
2.Post请求
实际上对于exchange来说，POST与GET的使用方式非常类似，所以这里只准备2个demo主要演示如何传header和body。
2.1 传header+body返回对象类型
2.2 传header+body返回自定义泛型类型
2.1 传header+body返回对象类型
调用代码：
@GetMapping("/user/body")
public UserDto postUser(@RequestParam("id") Integer id) {
String url = "http://localhost:8080/demo/user/body/mock";
UserDto body = UserDto.builder().id(id)
.name("body" + id)
.age(id + 18)
.birthday(new Date()).build();
// header根据实际情况设置，没有就空着
HttpHeaders headers = new HttpHeaders();
headers.add("AccessKey", "自定义的API访问key");
headers.add("Content-Type", "application/json");
HttpEntity<?> requestEntity = new HttpEntity<>(body, headers);
return restTemplate.exchange(url, HttpMethod.POST, requestEntity, UserDto.class).getBody();
}
被调用的mock代码：
@PostMapping("/user/body/mock")
public UserDto mockPostUser(@RequestBody UserDto userParam) {
return userParam;
}
验证一下： ok~~
请求 http://localhost:8080/demo/user/body?id=1
返回
{
“id”: 1,
“name”: “body1”,
“age”: 19,
“birthday”: “2022-11-06 21:20:41”
}
2.2 传header+body返回自定义泛型类型
和返回普通类型的区别还是将responseType换成ParameterizedTypeReference
调用代码：
@GetMapping("/user/result/body")
public Result<UserDto> postUserResult(@RequestParam("id") Integer id) {
String url = "http://localhost:8080/demo/user/result/body/mock";
UserDto body = UserDto.builder().id(id)
.name("body" + id)
.age(id + 10)
.birthday(new Date()).build();
// header根据实际情况设置，没有就空着
HttpHeaders headers = new HttpHeaders();
headers.add("AccessKey", "自定义的API访问key");
headers.add("Content-Type", "application/json");
HttpEntity<?> requestEntity = new HttpEntity<>(body, headers);
ParameterizedTypeReference<Result<UserDto>> responseBodyType = new ParameterizedTypeReference<Result<UserDto>>(){};
return restTemplate.exchange(url, HttpMethod.POST, requestEntity, responseBodyType).getBody();
}
被调用的mock代码：
@PostMapping("/user/result/body/mock")
public Result<UserDto> mockPostUserResult(@RequestBody UserDto userParam) {
return Result.success("200", "成功", userParam);
}
验证一下： ok~~
请求 http://localhost:8080/demo/user/body?id=1
返回
{
“success”: true,
“code”: “200”,
“message”: “成功”,
“data”: {
“id”: 1,
“name”: “body1”,
“age”: 11,
“birthday”: “2022-11-06 21:25:25”
}
}
3. 异常情况处理
上面写的均未处理异常情况，我们通常会处理两种异常情况：
- 本身抛出的 throws RestClientException
- 返回的ResponseEntity的Code不等于200
普通类型：
public <T> T restForEntity(HttpMethod httpMethod, String url, HttpHeaders headers, Object body
, Class<T> responseType) {
HttpEntity<?> requestEntity = null;
if (headers != null || body != null) {
requestEntity = new HttpEntity<>(body, headers);
}
try {
ResponseEntity<T> responseEntity = restTemplate.exchange(url, httpMethod, requestEntity, responseType);
if (responseEntity.getStatusCode().equals(HttpStatus.OK)) {
return responseEntity.getBody();
} else {
// 处理Code不等于200的情况
System.out.println("返回结果不等于200：code=" + responseEntity.getStatusCode().value()
+ " reason=" + responseEntity.getStatusCode().getReasonPhrase());
}
} catch (RestClientException e) {
// 处理RestClientException
e.printStackTrace();
}
return null;
}
泛型类型：
只需要将普通类型的入参Class
public <T> T restForWarpEntity(HttpMethod httpMethod, String url, HttpHeaders headers, Object body
, ParameterizedTypeReference<T> responseBodyType) {
HttpEntity<?> requestEntity = null;
if (headers != null || body != null) {
requestEntity = new HttpEntity<>(body, headers);
}
try {
ResponseEntity<T> responseEntity = restTemplate.exchange(url, httpMethod, requestEntity, responseBodyType);
if (responseEntity.getStatusCode().equals(HttpStatus.OK)) {
return responseEntity.getBody();
} else {
// 处理Code不等于200的情况, 这里只简单打印
System.out.println("返回结果不等于200：code=" + responseEntity.getStatusCode().value()
+ " reason=" + responseEntity.getStatusCode().getReasonPhrase());
}
} catch (RestClientException e) {
// 处理RestClientException, 这里只简单打印
e.printStackTrace();
}
return null;
}
4. RestTemplate配置@Bean
@Configuration
public class RestTemplateConfig {
@Bean
public RestTemplate restTemplate(ClientHttpRequestFactory clientHttpRequestFactory) {
RestTemplate restTemplate = new RestTemplate(clientHttpRequestFactory);
restTemplate.getMessageConverters()
.stream()
.filter(MappingJackson2HttpMessageConverter.class::isInstance)
.map(MappingJackson2HttpMessageConverter.class::cast)
.findFirst()
.map(MappingJackson2HttpMessageConverter::getObjectMapper)
.ifPresent(objectMapper -> {
// 去掉默认的时间戳格式
objectMapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
// 设置为东八区
objectMapper.setTimeZone(TimeZone.getTimeZone("GMT+8"));
// 序列化时，日期的统一格式
objectMapper.setDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
// 忽略大小写
objectMapper.configure(MapperFeature.ACCEPT_CASE_INSENSITIVE_PROPERTIES, true);
});
return restTemplate;
}
@Bean
public ClientHttpRequestFactory clientHttpRequestFactory(){
// 如果使用okHttpClient需要引入jar包：okhttp
// OkHttp3ClientHttpRequestFactory factory = new OkHttp3ClientHttpRequestFactory();
SimpleClientHttpRequestFactory factory = new SimpleClientHttpRequestFactory();
factory.setConnectTimeout(15000);
factory.setReadTimeout(30000);
return factory;
}
}
相关博文
在实际开发中，如果想自定义RestTemplate序列化，或者对于结果有相关处理，我们也可以取出来结果，然后再自己做序列化或验证，可以参考这位大佬的优质文章：RestTemplate使用实战-exchange方法讲解
对于更多原理性分析，可以参考这位大佬的优质文章：RestTemplate总结
最后
除了Get和Post，我们常用的还有Put和Delete，由于Delete可以参考Get的用法，Put可以参考Post的用法，所以就不做赘述，如果您觉得还有哪些场景是没有覆盖到的，欢迎留言或私信~~
最好的关系是互相成就，大家的「三连」就是我创作的最大动力！
注：如果本篇博客有任何错误和建议，欢迎大佬们留言！