【RestTemplate、spring】RestTemplate—Spring中用于执行同步HTTP请求的客户端模板工具类

Sinvon
2,405 阅读25分钟

1.RestTemplate是什么？

RestTemplate 是Spring框架提供的一个强大的用于执行RESTful服务调用的客户端模板类。它封装了HTTP请求的复杂性，使得与RESTful API的交互变得更加简单和直接。开发者不需要关心底层的HTTP连接管理、请求构造、响应解析等细节，只需关注业务逻辑。

2.RestTemplate 主要用途：

  1. 发送HTTP请求：RestTemplate支持GET、POST、PUT、DELETE等多种HTTP方法，可以用来发送JSON、XML等各种格式的数据请求。
  2. 自动序列化与反序列化：它能够自动将Java对象转换为HTTP请求的Payload（请求体），并将HTTP响应的Payload转换回Java对象，极大地简化了JSON或XML数据的处理过程。
  3. 多种响应内容处理：可以轻松处理各种响应类型，如字符串、JSON对象、自定义Java对象等。
  4. 模板化操作：提供了丰富的模板方法来处理HTTP请求和响应，如设置请求头、处理重定向、异常处理等。
  5. 异步请求支持：除了同步请求外，RestTemplate也支持执行异步HTTP请求，通过返回Future或使用AsyncRestTemplate（在较新的Spring版本中，推荐使用WebClient进行异步操作）。

使用示例1：

假设我们要使用RestTemplate发送一个GET请求获取用户信息：

RestTemplate restTemplate = new RestTemplate();
String url = "https://api.example.com/users/{userId}";
ResponseEntity<User> response = restTemplate.getForEntity(url, User.class, "1");
User user = response.getBody();

在这个例子中，RestTemplate会发送一个GET请求到https://api.example.com/users/1，并将响应体自动转换为User对象。

使用示例2

定义一个简单的restful接口

@RestController
public class TestController
{
    @RequestMapping(value = "testPost", method = RequestMethod.POST)
    public ResponseBean testPost(@RequestBody RequestBean requestBean)
    {
        ResponseBean responseBean = new ResponseBean();
        responseBean.setRetCode("0000");
        responseBean.setRetMsg("succ");
    }
}

使用RestTemplate访问该服务

//请求地址
String url = "http://localhost:8080/testPost";
//入参
RequestBean requestBean = new RequestBean();
requestBean.setTest1("1");
requestBean.setTest2("2");
requestBean.setTest3("3");
ResponseBean responseBean = restTemplate.postForObject(url, requestBean, ResponseBean.class);

从这个例子可以看出，使用restTemplate访问restful接口非常的简单粗暴无脑。 (url, requestMap, ResponseBean.class) 这三个参数分别代表 请求地址、请求参数、HTTP响应转换被转换成的对象类型。

RestTemplate方法的名称遵循命名约定，第一部分指出正在调用什么HTTP方法，第二部分指示返回的内容。本例中调用了restTemplate.postForObject方法，post指调用了HTTP的post方法，Object指将HTTP响应转换为您选择的对象类型。还有其他很多类似的方法，有兴趣的同学可以参考官方api。

总之，RestTemplate是进行HTTP通信的一个强大工具，特别是当你需要与RESTful服务交互时，它可以帮助你以更简洁、高效的方式完成任务。不过，随着Spring生态的发展，对于新的项目，官方推荐使用更现代、非阻塞的 WebClient 来替代 RestTemplate 进行网络请求。

使用RestTemplate的原因主要包括以下几点：

  1. 简化HTTP通信：RestTemplate封装了复杂的HTTP请求和响应处理逻辑，使得开发者可以以一种更加简洁、面向对象的方式来与RESTful服务进行交互，而无需直接处理底层的HTTP协议细节。
  2. 自动数据转换：它能够自动将Java对象转换为HTTP请求的正文（如JSON或XML），并能将HTTP响应正文转换为Java对象，这极大简化了数据交换过程，尤其是处理JSON和XML等常见数据格式时。
  3. 广泛的支持：RestTemplate支持多种HTTP方法（GET, POST, PUT, DELETE等）和内容类型，适应了大多数RESTful服务的交互需求。
  4. 集成Spring生态系统：作为Spring框架的一部分，RestTemplate与Spring的其他组件（如Spring MVC、Spring Security、Spring Data等）无缝集成，便于在Spring应用中使用。
  5. 模板方法模式：它遵循模板方法设计模式，提供了一系列模板方法来执行不同的HTTP操作，开发者只需关注具体的请求参数和响应处理逻辑。
  6. 配置灵活性：允许配置连接池、超时时间、错误处理策略等，以适应不同的网络环境和性能要求。
  7. 易于使用：提供了直观的API，使得即使是初学者也能快速上手，进行HTTP请求的发送和响应处理。

尽管RestTemplate在过去是Spring应用中进行HTTP调用的首选工具，但随着技术的发展，Spring Framework 5引入了更现代化的非阻塞客户端WebClient，它更适合高性能、响应式编程场景。对于新项目，官方推荐使用WebClient。然而，在维护旧代码或有特定需求的情况下，RestTemplate依然是一个可靠的选择。

RestTemplate的优势尽管随着Spring生态的发展，更现代的解决方案如WebClient（针对响应式编程模型）被推荐用于新的项目，但RestTemplate在历史项目和某些特定场景下依然具有其独特优势：

  1. 成熟稳定：作为Spring框架的一部分，RestTemplate已经历了长时间的使用和测试，其稳定性和可靠性得到了广泛验证。对于维护老项目或在对稳定性要求极高的环境中，使用RestTemplate是一个低风险的选择。
  2. 易用性：RestTemplate的设计非常直观，提供了一系列简洁的模板方法，如getForObject、postForObject等，使得调用REST服务变得非常直接，即使是初学者也能快速上手。
  3. 广泛集成：由于其在Spring生态系统中的中心地位，RestTemplate与Spring的其他组件（如Spring MVC、Spring Security、Spring Cloud等）有着良好的集成，可以轻松处理认证、服务发现、负载均衡等复杂场景。
  4. 灵活性：RestTemplate允许开发者对请求进行细粒度控制，包括设置请求头、使用自定义的HTTP客户端库、添加拦截器等，提供了高度的灵活性和可定制性。
  5. 丰富的转换支持：通过集成Spring的消息转换器（MessageConverter），RestTemplate能够自动处理多种格式的数据（如JSON、XML），并将它们转换为Java对象，大大简化了数据绑定过程。
  6. 同步阻塞模型：虽然对于高并发场景可能不是最优选，但在一些简单的请求响应模式中，同步阻塞模型易于理解和实现，减少了开发复杂度。

尽管如此，对于新项目或需要高性能、异步非阻塞处理的场景，探索使用WebClient或其他现代HTTP客户端会更加合适。技术选择应基于项目的具体需求、团队熟悉度及未来的技术发展趋势。

RestTemplate的整体架构

使用RestTemplate的整体架构涉及客户端应用如何通过它与远程RESTful服务进行交互。以下是其核心组成部分和工作流程的概述：

核心组件

  1. RestTemplate: RestTemplate是Spring框架提供的一个核心类，它是模板设计模式的一种实现，用于简化与REST服务的交互。它封装了HTTP请求的细节，如创建请求、发送请求、接收响应并处理结果。
  2. ClientHttpRequestFactory: 这是一个工厂接口，用于创建ClientHttpRequest实例，它代表一个HTTP请求。RestTemplate使用它来实际执行HTTP请求。默认情况下，Spring Boot会使用SimpleClientHttpRequestFactory，但你也可以配置使用HttpComponentsClientHttpRequestFactory来利用Apache HttpClient的功能，比如连接池管理。
  3. 消息转换器(Message Converters) : RestTemplate使用一系列的消息转换器来处理请求和响应的主体，如将Java对象序列化为JSON或XML，或将接收到的响应体反序列化为Java对象。Spring提供了多种开箱即用的消息转换器，如MappingJackson2HttpMessageConverter用于JSON处理。
  4. 拦截器(Interceptors) : 可以添加到RestTemplate中的组件，用于在请求发送前或响应接收后执行一些额外的逻辑，比如日志记录、请求鉴权或响应校验等。

工作流程

  1. 初始化: 应用程序通过构造函数或配置类中的@Bean方法创建一个RestTemplate实例。在此过程中，可以根据需要配置HTTP客户端工厂、消息转换器和拦截器。
  2. 构建请求: 开发者使用RestTemplate提供的各种方法（如getForObject, postForObject, exchange等）来构建HTTP请求。这些方法允许你指定URL、HTTP方法、请求体、请求头等信息。
  3. 执行请求: RestTemplate通过内部的ClientHttpRequestFactory创建并执行HTTP请求。请求的发送、连接管理和超时等行为由ClientHttpRequestFactory所使用的HTTP客户端库（如Java自带的URLConnection、Apache HttpClient等）控制。
  4. 处理响应: 接收到HTTP响应后，RestTemplate根据配置的消息转换器将响应体转换成Java对象。例如，如果响应体是JSON且配置了Jackson转换器，则会自动将其转换为相应的Java对象。
  5. 错误处理: 如果请求过程中发生错误（如网络问题、服务不可达、HTTP错误状态码等），RestTemplate会抛出异常。开发者需要捕获这些异常并进行相应的错误处理。
  6. 资源管理: 虽然早期的HTTP客户端库（如Apache HttpClient）需要手动管理连接和资源，但使用RestTemplate时，大部分资源管理是由其内部使用的HTTP客户端库自动处理的，减轻了开发者的工作负担。

通过这一系列步骤，RestTemplate为开发者提供了一种简便的方式来与REST服务进行交互，隐藏了底层HTTP通信的复杂性。

RestTemplate的整体架构的加载顺序

RestTemplate的整体架构加载顺序主要涉及其初始化、配置以及执行HTTP请求的过程。以下是其加载和执行的简要步骤：

  1. 初始化与配置:
    • 创建实例: 应用程序通常通过new RestTemplate()或在Spring配置类中使用@Bean注解来创建RestTemplate的实例。这一步骤是RestTemplate加载过程的开始。
    • 配置ClientHttpRequestFactory: 可以选择配置ClientHttpRequestFactory来定制HTTP客户端的行为，比如设置连接超时、读取超时或使用连接池等。默认情况下，如果没有特别配置，RestTemplate使用SimpleClientHttpRequestFactory。
    • 添加消息转换器: RestTemplate支持多种消息转换器，例如MappingJackson2HttpMessageConverter用于JSON数据的序列化与反序列化。开发者可以根据需要添加或替换消息转换器来处理特定格式的数据。
    • 配置拦截器: 为了实现请求或响应的日志记录、鉴权或其他定制逻辑，可以向RestTemplate添加拦截器(ClientHttpRequestInterceptor)。
  1. 请求构建:
    • 当应用需要发起HTTP请求时，开发者调用RestTemplate的各种请求方法（如getForObject, postForObject, exchange等），并传入目标URL、请求参数、请求体等信息。
  1. 执行请求:
    • 请求准备: RestTemplate根据请求方法和配置准备HTTP请求，包括设置HTTP头、正文、URL参数等。
    • 发送请求: 使用之前配置的ClientHttpRequestFactory创建并发送HTTP请求。这可能涉及到打开网络连接、写入请求数据、发送到服务器等操作。
    • 接收响应: 一旦服务器响应，ClientHttpRequestFactory负责读取响应数据，包括状态码、响应头和响应体。
  1. 响应处理:
    • 消息转换: 根据响应的内容类型和已配置的消息转换器，RestTemplate将响应体转换为Java对象。例如，如果响应是JSON并且配置了Jackson转换器，那么它会自动将JSON转换为对应的Java对象。
    • 结果返回: 处理完毕后，转换后的对象或原始响应数据（如果未指定转换规则）会被返回给调用者。

整个加载和执行过程是高度可配置和灵活的，允许开发者根据应用场景的具体需求来调整RestTemplate的行为。不过，随着Spring 5及后续版本对WebClient的推广，对于新项目，官方推荐使用更现代且功能强大的WebClient作为替代品。

箭头说明RestTemplate的整体架构的加载顺序

以下是使用箭头（=>）来表示RestTemplate整体架构加载顺序的文字说明：

  1. 实例创建与初始化
    • 应用启动 => 创建RestTemplate实例 (new RestTemplate() 或 Spring 配置类中的 @Bean)
  1. 配置阶段
    • 实例创建后 => 配置 ClientHttpRequestFactory (默认 SimpleClientHttpRequestFactory 或 自定义如 HttpComponentsClientHttpRequestFactory 用于更高级的配置)
    • => 添加消息转换器 (MappingJackson2HttpMessageConverter 等，用于处理JSON等数据格式)
    • => 注册拦截器 (如有需要，添加 ClientHttpRequestInterceptor 用于日志、鉴权等)
  1. 请求准备与发送
    • 发起请求前 => 构建请求信息 (URL, 参数, 请求体等)
    • => 使用 ClientHttpRequestFactory 准备请求细节 (建立连接、设置请求头、写入请求体)
    • => 发送HTTP请求到服务器
  1. 响应接收与处理
    • 服务器响应 => 读取响应信息 (状态码、响应头、响应体)
    • => 消息转换器介入 => 将响应体转换为Java对象 (如JSON转为Java Bean)
    • => 处理完成 => 返回结果给调用者

整个流程概括为：
实例创建 => 配置环节 => 请求构建 => 请求执行与响应处理 => 结果返回给调用者

这个过程体现了从创建RestTemplate实例到最终处理完HTTP响应并返回结果的完整链路。

RestTemplate的实现原理主要基于以下几个核心组件和技术：

  1. 模板方法模式：RestTemplate遵循了模板方法设计模式，它定义了一系列模板方法（如getForObject, postForObject, exchange等），这些方法封装了HTTP请求的通用过程（如建立连接、发送请求、接收响应、处理响应等），而具体的操作逻辑（如URL、请求参数、响应类型等）则由调用者通过方法参数来提供。这种设计使得开发者能够以声明式的方式调用REST服务，而无需关心底层的网络通信细节。
  2. HTTP客户端库的抽象：RestTemplate并未直接实现HTTP通信逻辑，而是通过委托给具体的HTTP客户端库来完成。它可以在运行时选择不同的HTTP客户端实现，如JDK的HttpURLConnection、Apache HttpClient、OkHttp等，这得益于Spring的ClientHttpRequestFactory接口。通过这种方式，RestTemplate能够灵活地利用不同库的优势，同时也便于更换底层实现以满足特定性能或兼容性需求。
  3. 请求与响应转换：为了实现请求体和响应体的自动序列化与反序列化，RestTemplate利用了Spring的转换器体系（MessageConverter）。这些转换器负责将Java对象转换为HTTP请求的内容（如JSON、XML），同时也将HTTP响应内容转换回Java对象。这意味着开发者可以自然地使用Java对象进行操作，而无需手动构造或解析HTTP消息。
  4. 拦截器与装饰者模式：RestTemplate继承自InterceptingHttpAccessor，允许通过拦截器（ClientHttpRequestInterceptor）来增强HTTP请求的处理流程，比如添加统一的认证信息、日志记录、请求与响应的修改等。这种机制基于装饰者模式，为请求处理流程提供了高度的可扩展性和灵活性。
  5. 同步阻塞操作：需要注意的是，RestTemplate执行HTTP请求的方式是同步阻塞的，即调用RestTemplate的方法会一直等待直到HTTP响应完成。对于某些需要高性能和响应式的应用场景，Spring 5之后推荐使用WebClient，它基于非阻塞IO，更适合高并发和延迟敏感的服务调用。

综上所述，RestTemplate通过模板方法模式、HTTP客户端抽象、消息转换器体系、拦截器模式以及同步阻塞的设计，提供了一套简单易用且功能强大的HTTP通信解决方案。RestTemplate提供了多种方法来处理HTTP请求，以下是几个主要方法及其简要说明：

RestTemplate的主要方法

1.RestTemplate主要HTTP方法

下面是关于RestTemplate主要HTTP方法及其对应方法的补充和格式化表格，包括每个方法的基本用途和参数解释：

HTTP 方法RestTemplate 方法用途参数解释
GETgetForObject(String url, Class<T> responseType, Object... urlVariables)发送GET请求并直接将响应体转换为指定类型的对象。url: 请求的URL； responseType: 响应体预期转换成的Java类型； urlVariables: URL中的变量值。
POSTpostForObject(String url, Object request, Class<T> responseType, Object... urlVariables)发送POST请求，其中request体将被序列化，并期待响应体转换为指定类型。url: 请求的URL； request: 要发送的请求体对象； responseType: 响应体预期转换成的Java类型； urlVariables: URL中的变量值。
PUTput(String url, Object request, Object... urlVariables)发送PUT请求，用于更新资源，请求体由request对象提供。url: 请求的URL； request: 要发送的请求体对象； urlVariables: URL中的变量值。
DELETEdelete(String url, Object... urlVariables)发送DELETE请求，用于删除资源。url: 请求的URL； urlVariables: URL中的变量值。
HEADheadForHeaders(String url, Object... urlVariables)发送HEAD请求，仅获取响应头信息。url: 请求的URL； urlVariables: URL中的变量值。
OPTIONSoptionsForAllow(String url, Object... urlVariables)发送OPTIONS请求，获取指定URL支持的HTTP方法。url: 请求的URL； urlVariables: URL中的变量值。

请注意，这些方法在实际使用时可能需要根据具体情况进行适当的错误处理和配置调整。此外，尽管这些是常用的HTTP方法，但在处理复杂请求或特定需求时，可能还需要使用更灵活的方法，如exchange或execute，它们提供了更广泛的控制选项。

2.几个主要方法及其简要说明

RestTemplate提供了多种方法来处理HTTP请求，以下是几个主要方法及其简要说明：

  1. getForEntity:
    • 用途: 发送GET请求，并返回一个ResponseEntity对象，包含了完整的HTTP响应（包括状态码、响应头和响应体）。
    • 示例:
ResponseEntity<String> response = restTemplate.getForEntity("http://example.com/api/resource", String.class);
  1. getForObject:
    • 用途: 发送GET请求，并直接将响应体转换为指定类型的对象。
    • 示例:
MyObject myObject = restTemplate.getForObject("http://example.com/api/resource", MyObject.class);
  1. postForEntity:
    • 用途: 发送POST请求，并返回一个ResponseEntity对象，常用于需要查看响应头或状态码的场景。
    • 示例:
MyRequest myRequest = new MyRequest(...);
ResponseEntity<MyResponse> response = restTemplate.postForEntity("http://example.com/api/resource", myRequest, MyResponse.class);
  1. postForObject:
    • 用途: 发送POST请求，并直接将响应体转换为指定类型的对象。
    • 示例:
MyRequest myRequest = new MyRequest(...);
MyResponse myResponse = restTemplate.postForObject("http://example.com/api/resource", myRequest, MyResponse.class);
  1. put:
    • 用途: 发送PUT请求，用于更新资源。
    • 示例:
MyRequest myRequest = new MyRequest(...);
restTemplate.put("http://example.com/api/resource/{id}", myRequest, id);
  1. delete:
    • 用途: 发送DELETE请求，用于删除资源。
    • 示例:
restTemplate.delete("http://example.com/api/resource/{id}", id);
  1. exchange:
    • 用途: 提供更广泛的控制，可以发送任何类型的HTTP请求，并且可以详细控制请求头、接受类型等，返回一个ResponseEntity对象。
    • 示例:
HttpHeaders headers = new HttpHeaders();
headers.setAccept(Arrays.asList(MediaType.APPLICATION_JSON));
HttpEntity<String> entity = new HttpEntity<>("parameters", headers);
ResponseEntity<String> response = restTemplate.exchange("http://example.com/api/resource", HttpMethod.POST, entity, String.class);
  1. execute:
    • 用途: 一个更底层的方法，提供对HTTP请求的完全控制，包括请求初始化、响应处理等，适用于需要高度定制的场景。

这些方法覆盖了大部分HTTP请求的需求，通过传入不同的参数和使用不同的HTTP方法，可以灵活地与RESTful服务交互。

RestTemplate业务开发的应用场景

应用场景RestTemplate在业务开发中的使用场景非常广泛，只要是需要与外部系统进行基于HTTP的交互，RestTemplate都是一个实用的选择。以下是一些典型的使用场景：

  1. 集成第三方API：当你的应用需要调用外部服务的API获取数据或执行操作时，如天气预报API、支付网关、社交媒体API等，RestTemplate可以方便地发起请求并处理响应。
  2. 微服务间通信：在微服务架构中，不同服务之间通常通过RESTful API进行通信。RestTemplate可以用来从一个服务调用另一个服务的接口，实现服务间的数据交换。
  3. 数据同步和导入：如果你的应用需要定期或按需从远程服务同步数据，比如商品信息、用户数据同步，RestTemplate可以用来实现数据的拉取和处理。
  4. 认证与授权：在处理OAuth2等认证协议时，RestTemplate可以用来发送认证请求，获取和刷新访问令牌，以及进行受保护资源的访问。
  5. 内容聚合：构建内容聚合应用时，如新闻聚合、价格比较工具等，需要从多个源抓取数据，RestTemplate可以用来高效地执行这些请求。
  6. 文件上传与下载：通过RestTemplate，可以实现文件的上传和下载操作，支持多部分（multipart）请求，适用于文件处理场景。
  7. 健康检查与监控：在实现服务的健康检查或监控功能时，可以使用RestTemplate定期向依赖服务发送请求，检查其可用性和响应时间。
  8. 异步处理：虽然RestTemplate本身是同步的，但在需要异步处理请求的场景中，可以通过结合Java的并发工具或Spring的异步处理机制，实现非阻塞的HTTP调用。

总的来说，任何需要通过HTTP进行数据交换的场景，都可以考虑使用RestTemplate来简化开发过程，提高代码的可读性和可维护性。

RestTemplate代码示例

当然，以下是根据上述使用场景，使用RestTemplate的示例代码片段：

1. 集成第三方API（天气预报查询）

RestTemplate restTemplate = new RestTemplate();
String url = "https://api.openweathermap.org/data/2.5/weather?q=London&appid={apiKey}";

// 假设apiKey是你的OpenWeatherMap API密钥
String apiKey = "your_api_key_here";
WeatherResponse weatherResponse = restTemplate.getForObject(url, WeatherResponse.class, apiKey);

System.out.println(weatherResponse.getDescription());

2. 微服务间通信（订单服务调用用户服务获取用户详情）

RestTemplate restTemplate = new RestTemplate();
String userUrl = "http://user-service/api/v1/users/{userId}";

ResponseEntity<UserDetails> userDetailsResponse = restTemplate.exchange(
    userUrl,
    HttpMethod.GET,
    null,
    UserDetails.class,
    123 // 假设123是用户ID
);

UserDetails userDetails = userDetailsResponse.getBody();
System.out.println(userDetails.getUsername());

3. 数据同步和导入（从远程API同步商品信息）

RestTemplate restTemplate = new RestTemplate();
String productsUrl = "https://api.example.com/products";

ProductList productList = restTemplate.getForObject(productsUrl, ProductList.class);

for (Product product : productList.getItems()) {
    // 保存或更新到本地数据库
    productRepository.save(product);
}

4. 认证与授权（OAuth2获取访问令牌）

RestTemplate restTemplate = new RestTemplate();
MultiValueMap<String, String> requestBody = new LinkedMultiValueMap<>();
requestBody.add("grant_type", "client_credentials");
requestBody.add("client_id", "your_client_id");
requestBody.add("client_secret", "your_client_secret");

HttpHeaders headers = new HttpHeaders();
headers.setContentType(MediaType.APPLICATION_FORM_URLENCODED);

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

String tokenUrl = "https://oauth2-server/token";

ResponseEntity<TokenResponse> responseEntity = restTemplate.exchange(tokenUrl, HttpMethod.POST, requestEntity, TokenResponse.class);

TokenResponse tokenResponse = responseEntity.getBody();
String accessToken = tokenResponse.getAccessToken();

5. 内容聚合（新闻标题聚合）

RestTemplate restTemplate = new RestTemplate();
String newsApiUrl = "https://newsapi.org/v2/top-headlines?country=us&category=business&apiKey={apiKey}";

String apiKey = "your_news_api_key_here";
NewsResponse newsResponse = restTemplate.getForObject(newsApiUrl, NewsResponse.class, apiKey);

for (Article article : newsResponse.getArticles()) {
    System.out.println(article.getTitle());
}

请注意，以上代码仅为示例，实际使用时需要替换占位符（如API密钥、URL路径参数）和处理异常情况。此外，考虑到安全性和最佳实践，建议使用配置管理API密钥，而非硬编码，并根据需要对RestTemplate进行适当的配置和优化。

6. 文件上传与下载

文件上传

RestTemplate restTemplate = new RestTemplate();

MultiValueMap<String, Object> body = new LinkedMultiValueMap<>();
body.add("file", new FileSystemResource(new File("/path/to/yourfile.txt"))); // 文件路径
body.add("description", "Test file upload");

HttpHeaders headers = new HttpHeaders();
headers.setContentType(MediaType.MULTIPART_FORM_DATA);

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

String uploadUrl = "http://example.com/api/upload";
ResponseEntity<String> response = restTemplate.postForEntity(uploadUrl, requestEntity, String.class);

System.out.println(response.getBody());

文件下载

RestTemplate restTemplate = new RestTemplate();

String downloadUrl = "http://example.com/api/download/file.txt";

byte[] fileBytes = restTemplate.getForObject(downloadUrl, byte[].class);

Files.write(Paths.get("/path/to/localfile.txt"), fileBytes); // 保存到本地路径

7. 健康检查与监控

RestTemplate restTemplate = new RestTemplate();

String healthCheckUrl = "http://dependency-service/health-check";

long startTime = System.currentTimeMillis();
try {
    ResponseEntity<String> response = restTemplate.getForEntity(healthCheckUrl, String.class);
    if (response.getStatusCode().is2xxSuccessful()) {
        System.out.println("Dependency service is healthy, response time: " + (System.currentTimeMillis() - startTime) + "ms");
    } else {
        System.out.println("Dependency service health check failed with status: " + response.getStatusCode());
    }
} catch (Exception e) {
    System.err.println("Error during health check: " + e.getMessage());
}

8. 异步处理

使用Spring的AsyncRestTemplate进行异步HTTP调用（注意：从Spring Framework 5.0开始，推荐使用WebFlux的WebClient替代AsyncRestTemplate，但这里仍给出AsyncRestTemplate的示例）。

@Autowired
private AsyncRestTemplate asyncRestTemplate;

public void performAsyncCall() {
    String apiUrl = "http://example.com/api/data";

    Future<ResponseEntity<String>> future = asyncRestTemplate.getForEntity(apiUrl, String.class);

    // 在这里可以继续执行其他任务，不等待响应...

    try {
        ResponseEntity<String> response = future.get(); // 获取结果（此行会阻塞直到有结果或超时）
        System.out.println(response.getBody());
    } catch (InterruptedException | ExecutionException e) {
        e.printStackTrace();
    }
}

使用Java并发工具（如ExecutorService）和原生RestTemplate进行异步调用的示例：

ExecutorService executor = Executors.newFixedThreadPool(10);

RestTemplate restTemplate = new RestTemplate();

Runnable task = () -> {
    String apiUrl = "http://example.com/api/data";
    ResponseEntity<String> response = restTemplate.getForEntity(apiUrl, String.class);
    System.out.println(response.getBody());
};

executor.submit(task); // 提交任务到线程池执行

请根据项目实际情况和Spring版本选择合适的异步处理方式。

Springboot中使用RestTemplate的一些配置

在Spring Boot中使用RestTemplate，通常情况下并不需要过多的额外配置，因为Spring Boot已经自动配置了一个RestTemplate的Bean，你可以直接通过自动注入的方式来使用它：

@Autowired
private RestTemplate restTemplate;

然而，为了更好地控制RestTemplate的行为，比如设置连接池、超时时间、重试策略等，你可能会想要自定义配置。以下是一个典型的自定义配置示例，该示例基于你之前分享的内容进行了简化和解释：

1. 添加配置文件设置

首先，在application.properties或application.yml中添加相关的配置项：

# application.properties 示例
# 最大连接数
http.maxTotal=100
# 并发数
http.defaultMaxPerRoute=20
# 连接超时时间 (毫秒)
http.connectTimeout=10000
# 从连接池获取连接超时时间 (毫秒)
http.connectionRequestTimeout=500
# 服务端响应超时时间 (毫秒)
http.socketTimeout=30000
# 是否启用空闲连接检查
http.staleConnectionCheckEnabled=true
# 空闲连接过期时间 (毫秒)，重用连接前会检查空闲时间
http.validateAfterInactivity=3000000

2. 创建配置类

接着，创建一个配置类来配置RestTemplate：

@Configuration
public class RestTemplateConfig {

    @Value("${http.maxTotal}")
    private int maxTotal;

    @Value("${http.defaultMaxPerRoute}")
    private int defaultMaxPerRoute;

    @Value("${http.connectTimeout}")
    private int connectTimeout;

    @Value("${http.connectionRequestTimeout}")
    private int connectionRequestTimeout;

    @Value("${http.socketTimeout}")
    private int socketTimeout;

    @Value("${http.staleConnectionCheckEnabled}")
    private boolean staleConnectionCheckEnabled;

    @Value("${http.validateAfterInactivity}")
    private int validateAfterInactivity;

    @Bean
    public RestTemplate restTemplate() {
        RestTemplate restTemplate = new RestTemplate(clientHttpRequestFactory());
        
        // 如果有需要，可以在这里添加更多的自定义配置，例如错误处理器、消息转换器等
        
        return restTemplate;
    }

    private ClientHttpRequestFactory clientHttpRequestFactory() {
        HttpComponentsClientHttpRequestFactory factory = new HttpComponentsClientHttpRequestFactory();
        factory.setReadTimeout(socketTimeout);
        factory.setConnectTimeout(connectTimeout);
        factory.setConnectionRequestTimeout(connectionRequestTimeout);

        HttpClient httpClient = HttpClientBuilder.create()
                .setMaxConnTotal(maxTotal)
                .setMaxConnPerRoute(defaultMaxPerRoute)
                .setConnectionTimeToLive(validateAfterInactivity, TimeUnit.MILLISECONDS)
                .disableAutomaticRetries() // 根据需要调整重试策略
                .build();

        factory.setHttpClient(httpClient);
        return factory;
    }
}

在这个配置类中，我们通过@Value注解读取配置文件中的属性值，并使用这些值来配置RestTemplate的连接工厂(ClientHttpRequestFactory)。这里使用了HttpComponentsClientHttpRequestFactory，因为它允许我们配置更详细的HTTP客户端设置，比如连接池和超时时间。我们还设置了HttpClient的属性，以利用Apache HttpClient库的强大功能。

完成这些配置后，你就可以在你的服务中注入并使用这个配置好的RestTemplate实例了。

RestTemplate配合【转换器、拦截器 】使用

此部分来源

www.cnblogs.com/scar1et/art…

二.一个简单的例子。

定义一个简单的restful接口

@RestController
public class TestController
{
    @RequestMapping(value = "testPost", method = RequestMethod.POST)
    public ResponseBean testPost(@RequestBody RequestBean requestBean)
    {
        ResponseBean responseBean = new ResponseBean();
        responseBean.setRetCode("0000");
        responseBean.setRetMsg("succ");
    }
}

使用RestTemplate访问该服务

//请求地址
String url = "http://localhost:8080/testPost";
//入参
RequestBean requestBean = new RequestBean();
requestBean.setTest1("1");
requestBean.setTest2("2");
requestBean.setTest3("3");
ResponseBean responseBean = restTemplate.postForObject(url, requestBean, ResponseBean.class);

从这个例子可以看出，使用restTemplate访问restful接口非常的简单粗暴无脑。 (url, requestMap, ResponseBean.class) 这三个参数分别代表 请求地址、请求参数、HTTP响应转换被转换成的对象类型。

RestTemplate方法的名称遵循命名约定，第一部分指出正在调用什么HTTP方法，第二部分指示返回的内容。本例中调用了restTemplate.postForObject方法，post指调用了HTTP的post方法，Object指将HTTP响应转换为您选择的对象类型。还有其他很多类似的方法，有兴趣的同学可以参考官方api。

三.手动指定转换器(HttpMessageConverter)

我们知道，调用reseful接口传递的数据内容是json格式的字符串，返回的响应也是json格式的字符串。然而restTemplate.postForObject方法的请求参数RequestBean和返回参数ResponseBean却都是java类。是RestTemplate通过HttpMessageConverter自动帮我们做了转换的操作。

默认情况下RestTemplate自动帮我们注册了一组HttpMessageConverter用来处理一些不同的contentType的请求。
如StringHttpMessageConverter来处理text/plain;MappingJackson2HttpMessageConverter来处理application/json;MappingJackson2XmlHttpMessageConverter来处理application/xml。
你可以在org.springframework.http.converter包下找到所有spring帮我们实现好的转换器。
如果现有的转换器不能满足你的需求，你还可以实现org.springframework.http.converter.HttpMessageConverter接口自己写一个。详情参考官方api。

选好了HttpMessageConverter后怎么把它注册到我们的RestTemplate中呢。

RestTemplate restTemplate = new RestTemplate();
//获取RestTemplate默认配置好的所有转换器
List<HttpMessageConverter<?>> messageConverters = restTemplate.getMessageConverters();
//默认的MappingJackson2HttpMessageConverter在第7个 先把它移除掉
messageConverters.remove(6);
//添加上GSON的转换器
messageConverters.add(6, new GsonHttpMessageConverter());

这个简单的例子展示了如何使用GsonHttpMessageConverter替换掉默认用来处理application/json的MappingJackson2HttpMessageConverter。

四.设置底层连接方式

要创建一个RestTemplate的实例，您可以像上述例子中简单地调用默认的无参数构造函数。这将使用java.net包中的标准Java类作为底层实现来创建HTTP请求。
但很多时候我们需要像传统的HttpClient那样设置HTTP请求的一些属性。RestTemplate使用了一种很偷懒的方式实现了这个需求，那就是直接使用一个HttpClient作为底层实现......

//生成一个设置了连接超时时间、请求超时时间、异常最大重试次数的httpClient
RequestConfig config = RequestConfig.custom().setConnectionRequestTimeout(10000).setConnectTimeout(10000).setSocketTimeout(30000).build();
HttpClientBuilder builder = HttpClientBuilder.create().setDefaultRequestConfig(config).setRetryHandler(new DefaultHttpRequestRetryHandler(5, false));
HttpClient httpClient = builder.build();
//使用httpClient创建一个ClientHttpRequestFactory的实现
ClientHttpRequestFactory requestFactory = new HttpComponentsClientHttpRequestFactory(httpClient);
//ClientHttpRequestFactory作为参数构造一个使用作为底层的RestTemplate
RestTemplate restTemplate = new RestTemplate(requestFactory);

五.设置拦截器(ClientHttpRequestInterceptor)

有时候我们需要对请求做一些通用的拦截设置，这就可以使用拦截器进行处理。拦截器需要我们实现org.springframework.http.client.ClientHttpRequestInterceptor接口自己写。

举个简单的例子，写一个在header中根据请求内容和地址添加令牌的拦截器。

public class TokenInterceptor implements ClientHttpRequestInterceptor
{
    @Override
    public ClientHttpResponse intercept(HttpRequest request, byte[] body, ClientHttpRequestExecution execution) throws IOException
    {
        //请求地址
        String checkTokenUrl = request.getURI().getPath();
        //token有效时间
        int ttTime = (int) (System.currentTimeMillis() / 1000 + 1800);
        //请求方法名 POST、GET等
        String methodName = request.getMethod().name();
        //请求内容
        String requestBody = new String(body);
        //生成令牌 此处调用一个自己写的方法，有兴趣的朋友可以自行google如何使用ak/sk生成token，此方法跟本教程无关，就不贴出来了
        String token = TokenHelper.generateToken(checkTokenUrl, ttTime, methodName, requestBody);
        //将令牌放入请求header中
        request.getHeaders().add("X-Auth-Token",token);
    }
}

创建RestTemplate实例的时候可以这样向其中添加拦截器

RestTemplate restTemplate = new RestTemplate();
//向restTemplate中添加自定义的拦截器
restTemplate.getInterceptors().add(new TokenInterceptor());
avatar
文章
阅读
粉丝