在Spring Boot中实现反向代理通常用于将请求从一个服务器转发到另一个服务器。常见的场景包括负载均衡、安全控制、缓存等。Spring Boot本身不直接提供反向代理功能，但可以通过集成其他库（如Spring Cloud Gateway、Zuul）或使用Servlet过滤器来实现。

以下是几种常见的实现方式：

1. 使用 Spring Cloud Gateway
Spring Cloud Gateway 是 Spring Cloud 生态中的一个 API 网关，支持反向代理、路由、负载均衡等功能。

实现步骤：
添加依赖：

xml

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-gateway</artifactId>

运行 HTML

配置路由规则：

在 application.yml 中配置反向代理的路由规则：
yaml
spring:
  cloud:
    gateway:
      routes:
        - id: my_route
          uri: http://backend-server.com  # 目标服务器地址
          predicates:
            - Path=/api/**  # 匹配的路径

启动应用：

启动 Spring Boot 应用后，所有匹配 /api/** 的请求都会被转发到 http://backend-server.com。
2. 使用 Zuul

Zuul 是 Netflix 提供的一个 API 网关，也可以用于实现反向代理。
实现步骤：

添加依赖：
xml
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-zuul</artifactId>
</dependency>

运行 HTML

启用 Zuul 代理：

在主应用类上添加 @EnableZuulProxy 注解：
java
@SpringBootApplication
@EnableZuulProxy
public class MyApp {
    public static void main(String[] args) {
        SpringApplication.run(MyApp.class, args);
    }
}

配置路由规则：

在 application.yml 中配置反向代理的路由规则：
yaml
zuul:
  routes:
    my_service:
      path: /api/**
      url: http://backend-server.com  # 目标服务器地址

启动应用：

启动应用后，所有匹配 /api/** 的请求都会被转发到 http://backend-server.com。
3. 使用 Servlet 过滤器

如果你不需要复杂的功能，可以通过自定义 Servlet 过滤器实现简单的反向代理。
实现步骤：

创建一个过滤器类：
java
import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class ReverseProxyFilter implements Filter {

    private static final String TARGET_SERVER = "http://backend-server.com";

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        HttpServletRequest httpRequest = (HttpServletRequest) request;
        HttpServletResponse httpResponse = (HttpServletResponse) response;

        // 构建目标 URL
        String targetUrl = TARGET_SERVER + httpRequest.getRequestURI();

        // 使用 HttpClient 转发请求
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest proxyRequest = HttpRequest.newBuilder()
                .uri(URI.create(targetUrl))
                .method(httpRequest.getMethod(), HttpRequest.BodyPublishers.noBody())
                .build();

        HttpResponse proxyResponse = client.send(proxyRequest, HttpResponse.BodyHandlers.ofString());

        // 将响应写回客户端
        httpResponse.setStatus(proxyResponse.statusCode());
        httpResponse.getWriter().write(proxyResponse.body());
    }

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {}

    @Override
    public void destroy() {}
}

注册过滤器：

在 Spring Boot 中注册过滤器：
java
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class FilterConfig {

    @Bean
    public FilterRegistrationBean reverseProxyFilter() {
        FilterRegistrationBean registrationBean = new FilterRegistrationBean<>();
        registrationBean.setFilter(new ReverseProxyFilter());
        registrationBean.addUrlPatterns("/api/*");  // 匹配的路径
        return registrationBean;
    }
}

启动应用：

启动应用后，所有匹配 /api/* 的请求都会被转发到 http://backend-server.com。
4. 使用 Nginx

如果你不想在 Spring Boot 中实现反向代理，可以使用 Nginx 作为反向代理服务器。
实现步骤：

安装 Nginx。
配置 Nginx：

在 Nginx 配置文件中添加反向代理规则：
nginx
server {
    listen 80;
    server_name localhost;

    location /api/ {
        proxy_pass http://backend-server.com;  # 目标服务器地址
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    }
}

启动 Nginx：

启动 Nginx 后，所有匹配 /api/ 的请求都会被转发到 http://backend-server.com。
总结

如果需要完整的 API 网关功能，推荐使用 Spring Cloud Gateway 或 Zuul。
如果需要简单的反向代理，可以使用 Servlet 过滤器。
如果不想在 Spring Boot 中实现，可以使用 Nginx 作为反向代理服务器。
根据你的需求选择合适的方式即可！