SpringBoot利用RestTemplate實現(xiàn)反向代理

更新時間：2025年07月02日 08:22:57 作者：風象南

反向代理是指以代理服務器接收客戶端請求,然后將請求轉發(fā)給內部服務器,并將內部服務器的響應返回給客戶端,下面我們就來看看SpringBoot如何利用RestTemplate實現(xiàn)反向代理吧

什么是反向代理

反向代理是指以代理服務器接收客戶端請求，然后將請求轉發(fā)給內部服務器，并將內部服務器的響應返回給客戶端。

客戶端只與反向代理服務器通信，不直接訪問內部服務器。

為什么選擇RestTemplate實現(xiàn)反向代理

集成便捷：RestTemplate是Spring框架的核心組件，在SpringBoot項目中使用非常方便 功能豐富：支持各種HTTP方法、請求頭處理、響應類型轉換等 可定制性強：可以通過配置ClientHttpRequestFactory來自定義連接池、超時等參數(shù) 便于擴展：可以結合攔截器實現(xiàn)更復雜的代理邏輯

實現(xiàn)步驟

1. 添加依賴

首先在pom.xml中添加必要的依賴：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
    <groupId>org.apache.httpcomponents</groupId>
    <artifactId>httpclient</artifactId>
    <version>4.5.14</version>
</dependency>

2. 配置RestTemplate

@Configuration
public class RestTemplateConfig {

    @Bean
    public RestTemplate restTemplate() {
        HttpComponentsClientHttpRequestFactory factory = new HttpComponentsClientHttpRequestFactory();
        factory.setConnectTimeout(5000);
        factory.setReadTimeout(5000);
        
        return new RestTemplate(factory);
    }
}

3. 實現(xiàn)代理控制器

@RestController
@RequestMapping("/proxy")
public class ProxyController {

    @Autowired
    private RestTemplate restTemplate;
    
    // 目標服務器基礎URL
    private static final String TARGET_SERVER = "http://target-service.com";
    
    @RequestMapping("/**")
    public ResponseEntity<String> proxyRequest(HttpServletRequest request,
                                              @RequestBody(required = false) String body) {
        try {
            // 構建目標URL
            String requestUri = request.getRequestURI();
            String proxyPath = requestUri.substring("/proxy".length());
            String queryString = request.getQueryString();
            
            StringBuilder targetUrl = new StringBuilder(TARGET_SERVER);
            targetUrl.append(proxyPath);
            if (queryString != null) {
                targetUrl.append("?").append(queryString);
            }
            
            // 復制請求頭
            HttpHeaders headers = new HttpHeaders();
            Enumeration<String> headerNames = request.getHeaderNames();
            while (headerNames.hasMoreElements()) {
                String headerName = headerNames.nextElement();
                // 排除一些不需要轉發(fā)的頭部
                if (!headerName.equalsIgnoreCase("host")) {
                    headers.set(headerName, request.getHeader(headerName));
                }
            }
            
            // 創(chuàng)建請求實體
            HttpEntity<String> httpEntity = new HttpEntity<>(body, headers);
            
            // 確定HTTP方法
            HttpMethod httpMethod = HttpMethod.valueOf(request.getMethod());
            
            // 發(fā)送請求并獲取響應
            ResponseEntity<String> responseEntity = 
                restTemplate.exchange(targetUrl.toString(), httpMethod, httpEntity, String.class);
            
            return responseEntity;
            
        } catch (Exception e) {
            return ResponseEntity
                .status(HttpStatus.INTERNAL_SERVER_ERROR)
                .body("代理請求失敗: " + e.getMessage());
        }
    }
}

4. 處理文件上傳和下載

對于需要處理文件上傳和下載的情況，可以這樣實現(xiàn)：

@PostMapping("/upload/**")
public ResponseEntity<byte[]> proxyUpload(HttpServletRequest request, 
                                        MultipartHttpServletRequest multipartRequest) {
    try {
        // 獲取文件部分
        MultiValueMap<String, Object> parts = new LinkedMultiValueMap<>();
        multipartRequest.getFileMap().forEach((name, file) -> {
            try {
                ByteArrayResource resource = new ByteArrayResource(file.getBytes()) {
                    @Override
                    public String getFilename() {
                        return file.getOriginalFilename();
                    }
                };
                parts.add(name, resource);
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        });
        
        // 獲取其他表單參數(shù)
        multipartRequest.getParameterMap().forEach((name, values) -> {
            for (String value : values) {
                parts.add(name, value);
            }
        });
        
        // 構建URL
        String requestUri = request.getRequestURI();
        String proxyPath = requestUri.substring("/proxy/upload".length());
        String targetUrl = TARGET_SERVER + "/upload" + proxyPath;
        
        // 設置請求頭
        HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.MULTIPART_FORM_DATA);
        
        // 發(fā)送請求
        HttpEntity<MultiValueMap<String, Object>> requestEntity = new HttpEntity<>(parts, headers);
        ResponseEntity<byte[]> response = restTemplate.exchange(
            targetUrl, HttpMethod.POST, requestEntity, byte[].class);
            
        return response;
    } catch (Exception e) {
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
    }
}

5. 增強功能：實現(xiàn)請求攔截和轉換

通過添加攔截器，我們可以在請求前后進行處理：

@Configuration
@Slf4j
public class RestTemplateConfig {

    @Bean
    public RestTemplate restTemplate() {
        HttpComponentsClientHttpRequestFactory factory = new HttpComponentsClientHttpRequestFactory();
        factory.setConnectTimeout(5000);
        factory.setReadTimeout(5000);

        RestTemplate restTemplate = new RestTemplate(factory);
        // 添加攔截器
        restTemplate.setInterceptors(
            Collections.singletonList((request, body, execution) -> {
                log.info("請求URL: {}", request.getURI());
                // 請求前處理
                HttpHeaders headers = request.getHeaders();
                headers.add("X-Forwarded-By", "Spring-Proxy");

                // 執(zhí)行請求
                ClientHttpResponse response = execution.execute(request, body);

                // 響應后處理
                // 這里可以修改響應，例如添加頭部、修改內容等

                return response;
            })
        );

        return restTemplate;
    }
}

6. 連接池配置

@Configuration
@Slf4j
public class RestTemplateConfig {

    @Bean
    public RestTemplate restTemplate() {
        /*HttpComponentsClientHttpRequestFactory factory = new HttpComponentsClientHttpRequestFactory();
        factory.setConnectTimeout(5000);
        factory.setReadTimeout(5000);*/

        PoolingHttpClientConnectionManager connectionManager =
                new PoolingHttpClientConnectionManager();
        connectionManager.setMaxTotal(100);
        connectionManager.setDefaultMaxPerRoute(20);

        RequestConfig requestConfig = RequestConfig.custom()
                .setConnectionRequestTimeout(Timeout.of(5000, TimeUnit.MILLISECONDS))
                .setResponseTimeout(Timeout.of(5000, TimeUnit.MILLISECONDS))
                .build();

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

        HttpComponentsClientHttpRequestFactory factory =
                new HttpComponentsClientHttpRequestFactory(httpClient);

        RestTemplate restTemplate = new RestTemplate(factory);
        // 添加攔截器
        restTemplate.setInterceptors(
            Collections.singletonList((request, body, execution) -> {
                log.info("請求URL: {}", request.getURI());
                // 請求前處理
                HttpHeaders headers = request.getHeaders();
                headers.add("X-Forwarded-By", "Spring-Proxy");

                // 執(zhí)行請求
                ClientHttpResponse response = execution.execute(request, body);

                // 響應后處理
                // 這里可以修改響應，例如添加頭部、修改內容等

                return response;
            })
        );

        return restTemplate;
    }
}

安全考慮

請求驗證：確保只轉發(fā)合法請求 敏感信息過濾：過濾敏感頭部或請求內容 限流措施：防止過多請求導致目標服務過載

// 示例：請求驗證
private boolean validateRequest(HttpServletRequest request) {
    // 實現(xiàn)驗證邏輯，例如檢查認證信息、IP白名單等
    String authToken = request.getHeader("Authorization");
    return authToken != null && authService.isValidToken(authToken);
}