springboot服务之间调用

在 Spring Boot 项目中，若不想通过 URL 调用服务（如 REST API），可以考虑以下几种替代方案：

1. 消息队列（Message Queue）

通过消息中间件（如 RabbitMQ、Kafka）实现服务间通信，C 服务发送消息，A 服务消费消息并返回结果（可通过另一个队列）。

示例代码（使用 RabbitMQ）

**A 服务（消费者）**：

package com.example.a.service.consumer;

import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Service;

@Service
public class AMQPConsumer {

    @RabbitListener(queues = a-service-queue)
    public String processMessage(String request) {
        // 处理请求并返回结果
        return A服务处理后的响应:  + request;
    }
}

**C 服务（生产者）**：

package com.example.c.service.producer;

import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class AMQPProducer {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    public String callAService(String request) {
        // 发送消息并同步等待响应（使用RPC模式）
        return (String) rabbitTemplate.convertSendAndReceive(a-service-queue, request);
    }
}

2. 共享接口 + 本地代理

若 A 和 C 服务部署在同一 JVM 中（如同一个应用的不同模块），可通过共享接口和代理模式调用。

示例代码

**定义共享接口（B 服务的包中）**：

package com.example.b.common;

public interface AServiceApi {
    String getData(String param);
}

A 服务实现该接口：

package com.example.a.service.impl;

import com.example.b.common.AServiceApi;
import org.springframework.stereotype.Service;

@Service
public class AServiceImpl implements AServiceApi {

    @Override
    public String getData(String param) {
        return A服务数据:  + param;
    }
}

C 服务通过代理调用：

package com.example.c.service.proxy;

import com.example.b.common.AServiceApi;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class AServiceProxy implements AServiceApi {

    @Autowired
    private AServiceApi aService; // 通过依赖注入获取A服务的实现

    @Override
    public String getData(String param) {
        return aService.getData(param); // 直接调用本地实例
    }
}

3. 事件驱动（Event Bus）

使用 Spring 的 ApplicationEventPublisher 或第三方事件总线（如 Guava EventBus），C 服务发布事件，A 服务监听并响应。

示例代码

定义事件：

package com.example.b.common.event;

import org.springframework.context.ApplicationEvent;

public class AServiceRequestEvent extends ApplicationEvent {

    private final String requestData;
    private String responseData;

    public AServiceRequestEvent(Object source, String requestData) {
        super(source);
        this.requestData = requestData;
    }

    public String getRequestData() {
        return requestData;
    }

    public String getResponseData() {
        return responseData;
    }

    public void setResponseData(String responseData) {
        this.responseData = responseData;
    }
}

A 服务监听事件：

package com.example.a.service.listener;

import com.example.b.common.event.AServiceRequestEvent;
import org.springframework.context.event.EventListener;
import org.springframework.stereotype.Component;

@Component
public class AServiceEventListener {

    @EventListener
    public void handleRequest(AServiceRequestEvent event) {
        // 处理请求并设置响应
        String response = A服务处理结果:  + event.getRequestData();
        event.setResponseData(response);
    }
}

C 服务发布事件：

package com.example.c.service;

import com.example.b.common.event.AServiceRequestEvent;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.stereotype.Service;

@Service
public class CService {

    @Autowired
    private ApplicationEventPublisher eventPublisher;

    public String callAService(String request) {
        AServiceRequestEvent event = new AServiceRequestEvent(this, request);
        eventPublisher.publishEvent(event);
        return event.getResponseData(); // 同步获取响应
    }
}

选择建议

• 消息队列：适合异步通信、解耦服务，支持跨 JVM 调用，但需要额外的中间件。
• 共享接口 + 代理：仅适用于同一 JVM 内的服务调用，耦合度较高。
• 事件驱动：适合单向通信或广播模式，实现简单但同步响应需要额外处理。

根据你的具体场景选择合适的方案。