基于Spring Boot：通过中间REST API实现跨客户端方法调用可行性咨询

先直接给你明确答案：REST服务端完全可以调用REST客户端的方法！角色是相对的——当A调用C时，C是服务端；当C调用B时，C就变成了客户端，Spring Boot提供了多种工具来实现这个逻辑，完全适配你的需求。

结合你的场景（A→C→B发邮件，A、B无直接通信），下面给你两种最实用的实现方案：

方案1：把B改成REST服务，C作为客户端调用它 #

这是最符合REST架构规范的方式，把B的sendEmail方法封装成REST接口，C通过Spring的客户端工具调用B，再把接口暴露给A。

步骤1：改造B，暴露邮件发送接口 #

在B的Spring Boot项目里加一个Controller，把原来的sendEmail方法暴露成POST接口：

@RestController
@RequestMapping("/email")
public class EmailController {
    // 假设B里原本的邮件服务类是EmailService
    private final EmailService emailService;

    public EmailController(EmailService emailService) {
        this.emailService = emailService;
    }

    @PostMapping("/send")
    public ResponseEntity<String> sendEmail(@RequestParam String email) {
        emailService.sendEmail(email);
        return ResponseEntity.ok("邮件发送成功");
    }
}

步骤2：在C中配置客户端调用B的接口 #

Spring Boot里有三种常用方式，选你顺手的就行：

方式A：用RestTemplate（传统同步方式）

先在C的配置类里注册RestTemplate：

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

然后在C的业务类里注入并调用：

@Service
public class EmailProxyService {
    private final RestTemplate restTemplate;
    // B的地址可以放到application.yml里配置，这里直接写死示例
    private final String bServiceUrl = "http://localhost:8081";

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

    public void sendEmailViaB(String email) {
        String requestUrl = bServiceUrl + "/email/send?email=" + email;
        restTemplate.postForObject(requestUrl, null, String.class);
    }
}

方式B：用WebClient（推荐非阻塞方式）

WebClient是Spring 5+主推的非阻塞客户端，配置和调用如下：

@Configuration
public class RestClientConfig {
    @Bean
    public WebClient webClient() {
        return WebClient.builder().build();
    }
}

业务类调用：

@Service
public class EmailProxyService {
    private final WebClient webClient;
    private final String bServiceUrl = "http://localhost:8081";

    public EmailProxyService(WebClient webClient) {
        this.webClient = webClient;
    }

    public Mono<String> sendEmailViaB(String email) {
        return webClient.post()
                .uri(bServiceUrl + "/email/send?email={email}", email)
                .retrieve()
                .bodyToMono(String.class);
    }
}

方式C：用OpenFeign（声明式，最简洁）

先给C加Feign依赖（如果是Spring Cloud项目更方便）：

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

在C的启动类加@EnableFeignClients注解，然后定义Feign客户端接口：

@FeignClient(name = "email-service", url = "${b.service.url}")
public interface EmailFeignClient {
    @PostMapping("/email/send")
    String sendEmail(@RequestParam String email);
}

在application.yml里配置B的地址：

b:
  service:
    url: http://localhost:8081

最后在业务类里注入调用：

@Service
public class EmailProxyService {
    private final EmailFeignClient emailFeignClient;

    public EmailProxyService(EmailFeignClient emailFeignClient) {
        this.emailFeignClient = emailFeignClient;
    }

    public void sendEmailViaB(String email) {
        emailFeignClient.sendEmail(email);
    }
}

步骤3：C给A暴露调用接口 #

在C里加一个Controller，接收A的请求，再调用上面的EmailProxyService：

@RestController
@RequestMapping("/api")
public class ApiController {
    private final EmailProxyService emailProxyService;

    public ApiController(EmailProxyService emailProxyService) {
        this.emailProxyService = emailProxyService;
    }

    @PostMapping("/send-email")
    public ResponseEntity<String> sendEmail(@RequestParam String email) {
        emailProxyService.sendEmailViaB(email);
        return ResponseEntity.ok("已通过B发送邮件");
    }
}

这样A只需要调用C的/api/send-email接口，就能间接让B发邮件，完全符合A、B无直接通信的要求。

方案2：C直接依赖B的Jar包（如果B是可复用组件） #

如果B不是独立运行的应用，而是一个可以被依赖的邮件组件Jar包，那更简单——直接在C的pom.xml里引入B的依赖，然后在C中注入B的EmailService实例，直接调用sendEmail方法：

<!-- C的pom.xml里加B的依赖 -->
<dependency>
    <groupId>com.example</groupId>
    <artifactId>email-service-b</artifactId>
    <version>1.0.0</version>
</dependency>

@Service
public class EmailProxyService {
    // 直接注入B里的EmailService
    private final EmailService emailService;

    public EmailProxyService(EmailService emailService) {
        this.emailService = emailService;
    }

    public void sendEmail(String email) {
        emailService.sendEmail(email);
    }
}

这种方式省去了REST接口的开发，但前提是B可以被打包成可依赖的Jar。

额外场景：如果B不能改造成REST服务怎么办？ #

如果B是老旧系统，没法加REST接口，可以用消息队列（比如RabbitMQ、Kafka）做异步调用：C发送邮件请求到队列，B监听队列并执行sendEmail方法，同样能实现A→C→B的流程，且A、B无直接通信。

内容的提问来源于stack exchange，提问作者Hasindu Dahanayake