Spring Boot 中 RestTemplate 的实践详解

源话编程 2024-11-18

278

👋 热爱编程的小伙伴们，欢迎来到我的编程技术分享公众号！在这里，我会分享编程技巧、实战经验、技术干货，还有各种有趣的编程话题！

❝
在 Spring Boot 应用中，RestTemplate 是进行 HTTP 请求的主要工具之一。本文将深入探讨 RestTemplate 的最佳实践，包括配置、使用技巧、错误处理、性能优化等方面，帮助开发者更好地在 Spring Boot 项目中使用 RestTemplate。

RestTemplate 简介

RestTemplate 是 Spring 框架提供的用于发送 HTTP 请求的同步客户端。它简化了与 RESTful 服务的通信过程，支持多种 HTTP 方法，并能自动处理对象序列化和反序列化。

配置 RestTemplate

基本配置

在 Spring Boot 中，我们可以通过 @Bean
注解来配置 RestTemplate：

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

@Configuration
public class RestTemplateConfig {

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

复制

自定义配置

为了更好地控制 RestTemplate 的行为，我们可以添加自定义配置：

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

import java.time.Duration;

@Configuration
public class RestTemplateConfig {

    @Bean
    public RestTemplate restTemplate(RestTemplateBuilder builder) {
        return builder
                .setConnectTimeout(Duration.ofSeconds(5))
                .setReadTimeout(Duration.ofSeconds(5))
                .build();
    }
}

复制

基本使用方法

RestTemplate 提供了多种方法来执行 HTTP 请求。以下是一些常见用法：

GET 请求

@Autowired
private RestTemplate restTemplate;

public User getUser(Long id) {
    String url = "http://api.example.com/users/{id}";
    return restTemplate.getForObject(url, User.class, id);
}

复制

POST 请求

public User createUser(User user) {
    String url = "http://api.example.com/users";
    return restTemplate.postForObject(url, user, User.class);
}

复制

PUT 请求

public void updateUser(Long id, User user) {
    String url = "http://api.example.com/users/{id}";
    restTemplate.put(url, user, id);
}

复制

DELETE 请求

public void deleteUser(Long id) {
    String url = "http://api.example.com/users/{id}";
    restTemplate.delete(url, id);
}

复制

使用异步 RestTemplate

在需要非阻塞 I/O 的场景下，Spring 提供了 AsyncRestTemplate
来处理异步请求。不过，从 Spring 5 开始推荐使用 WebClient
，它提供了更丰富的功能和更好的性能。若需要使用 RestTemplate
，可参考以下示例：

import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;
import java.util.concurrent.CompletableFuture;

@Service
public class AsyncRestTemplateService {

    private final RestTemplate restTemplate;

    public AsyncRestTemplateService(RestTemplate restTemplate) {
        this.restTemplate = restTemplate;
    }

    @Async
    public CompletableFuture<User> getUserAsync(Long id) {
        String url = "http://api.example.com/users/{id}";
        User user = restTemplate.getForObject(url, User.class, id);
        return CompletableFuture.completedFuture(user);
    }
}

复制

错误处理

默认情况下，RestTemplate 在遇到 4xx 或 5xx 错误时会抛出异常。我们可以通过自定义 ResponseErrorHandler
来处理这些错误：

import org.springframework.http.HttpStatus;
import org.springframework.http.client.ClientHttpResponse;
import org.springframework.web.client.ResponseErrorHandler;

import java.io.IOException;

public class CustomResponseErrorHandler implements ResponseErrorHandler {

    @Override
    public boolean hasError(ClientHttpResponse response) throws IOException {
        return response.getStatusCode().series() == HttpStatus.Series.CLIENT_ERROR
                || response.getStatusCode().series() == HttpStatus.Series.SERVER_ERROR;
    }

    @Override
    public void handleError(ClientHttpResponse response) throws IOException {
        if (response.getStatusCode().series() == HttpStatus.Series.CLIENT_ERROR) {
            // 处理 4xx 错误
            if (response.getStatusCode() == HttpStatus.NOT_FOUND) {
                throw new CustomException("资源未找到");
            }
        } else if (response.getStatusCode().series() == HttpStatus.Series.SERVER_ERROR) {
            // 处理 5xx 错误
            throw new CustomException("服务器内部错误");
        }
    }
}

复制

然后，将这个错误处理器设置到 RestTemplate 中：

@Bean
public RestTemplate restTemplate(RestTemplateBuilder builder) {
    return builder
            .errorHandler(new CustomResponseErrorHandler())
            .build();
}

复制

请求/响应拦截

通过实现 ClientHttpRequestInterceptor
接口，我们可以拦截请求和响应，用于添加认证信息、日志记录等：

import org.springframework.http.HttpRequest;
import org.springframework.http.client.ClientHttpRequestExecution;
import org.springframework.http.client.ClientHttpRequestInterceptor;
import org.springframework.http.client.ClientHttpResponse;

import java.io.IOException;

public class LoggingInterceptor implements ClientHttpRequestInterceptor {

    @Override
    public ClientHttpResponse intercept(HttpRequest request, byte[] body, ClientHttpRequestExecution execution) throws IOException {
        // 记录请求日志
        System.out.println("Request: " + request.getMethod() + " " + request.getURI());
        
        ClientHttpResponse response = execution.execute(request, body);
        
        // 记录响应日志
        System.out.println("Response: " + response.getStatusCode());
        
        return response;
    }
}

复制

将拦截器添加到 RestTemplate：

@Bean
public RestTemplate restTemplate(RestTemplateBuilder builder) {
    return builder
            .interceptors(new LoggingInterceptor())
            .build();
}

复制

连接池管理

为了提高性能，我们可以使用连接池来管理 HTTP 连接。Apache HttpClient 是一个常用的选择：

import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.client.HttpComponentsClientHttpRequestFactory;
import org.springframework.web.client.RestTemplate;

@Configuration
public class RestTemplateConfig {

    @Bean
    public RestTemplate restTemplate() {
        PoolingHttpClientConnectionManager connectionManager = new PoolingHttpClientConnectionManager();
        connectionManager.setMaxTotal(100);
        connectionManager.setDefaultMaxPerRoute(20);

        CloseableHttpClient httpClient = HttpClients.custom()
                .setConnectionManager(connectionManager)
                .build();

        HttpComponentsClientHttpRequestFactory requestFactory = new HttpComponentsClientHttpRequestFactory();
        requestFactory.setHttpClient(httpClient);

        return new RestTemplate(requestFactory);
    }
}

复制

超时设置

设置合适的超时时间可以防止请求长时间阻塞：

@Bean
public RestTemplate restTemplate(RestTemplateBuilder builder) {
    return builder
            .setConnectTimeout(Duration.ofSeconds(5))
            .setReadTimeout(Duration.ofSeconds(5))
            .build();
}

复制

重试机制

对于不稳定的网络环境，我们可以添加重试机制：

import org.springframework.retry.annotation.Backoff;
import org.springframework.retry.annotation.Retryable;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestClientException;

@Service
public class UserService {

    @Autowired
    private RestTemplate restTemplate;

    @Retryable(value = RestClientException.class, maxAttempts = 3, backoff = @Backoff(delay = 1000))
    public User getUser(Long id) {
        String url = "http://api.example.com/users/{id}";
        return restTemplate.getForObject(url, User.class, id);
    }
}

复制

注意：要启用重试功能，需要在主类上添加 @EnableRetry
注解。

安全性考虑

在处理敏感数据时，应该使用 HTTPS。此外，可以配置 RestTemplate 以验证服务器证书：

import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.ssl.SSLContextBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.client.HttpComponentsClientHttpRequestFactory;
import org.springframework.web.client.RestTemplate;

import javax.net.ssl.SSLContext;
import java.security.KeyStore;

@Configuration
public class RestTemplateConfig {

    @Bean
    public RestTemplate restTemplate() throws Exception {
        KeyStore keyStore = KeyStore.getInstance("JKS");
        keyStore.load(getClass().getResourceAsStream("/keystore.jks"), "password".toCharArray());

        SSLContext sslContext = new SSLContextBuilder()
                .loadTrustMaterial(keyStore, null)
                .build();

        SSLConnectionSocketFactory socketFactory = new SSLConnectionSocketFactory(sslContext);

        CloseableHttpClient httpClient = HttpClients.custom()
                .setSSLSocketFactory(socketFactory)
                .build();

        HttpComponentsClientHttpRequestFactory requestFactory = new HttpComponentsClientHttpRequestFactory();
        requestFactory.setHttpClient(httpClient);

        return new RestTemplate(requestFactory);
    }
}

复制

测试策略

测试使用 RestTemplate 的代码时，我们可以使用 MockRestServiceServer 来模拟 HTTP 请求：

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.http.MediaType;
import org.springframework.test.web.client.MockRestServiceServer;
import org.springframework.web.client.RestTemplate;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.springframework.test.web.client.match.MockRestRequestMatchers.requestTo;
import static org.springframework.test.web.client.response.MockRestResponseCreators.withSuccess;

@SpringBootTest
public class UserServiceTest {

    @Autowired
    private UserService userService;

    @Autowired
    private RestTemplate restTemplate;

    private MockRestServiceServer mockServer;

    @BeforeEach
    public void setUp() {
        mockServer = MockRestServiceServer.createServer(restTemplate);
    }

    @Test
    public void testGetUser() {
        mockServer.expect(requestTo("http://api.example.com/users/1"))
                .andRespond(withSuccess("{\"id\":1,\"name\":\"John\"}", MediaType.APPLICATION_JSON));

        User user = userService.getUser(1L);

        assertEquals(1L, user.getId());
        assertEquals("John", user.getName());
    }
}

复制