当前位置：首页 > news >正文

讲解一下SpringBoot的RPC连接

news 来源：原创 2025/5/8 8:34:36

Spring Boot 本身并不直接提供 RPC（Remote Procedure Call，远程过程调用）功能，但可以通过集成其他框架或库来实现 RPC 通信。常见的 RPC 框架包括 Dubbo、gRPC、Thrift、Spring Cloud 等。下面我将讲解如何在 Spring Boot 中集成和使用这些 RPC 框架。

1. 使用 Dubbo 实现 RPC

Dubbo 是阿里巴巴开源的一个高性能 RPC 框架，广泛应用于分布式系统中。Spring Boot 可以通过 dubbo-spring-boot-starter 来集成 Dubbo。

1.1 添加依赖

首先，在 pom.xml 中添加 Dubbo 和 Spring Boot 的依赖：

<dependency>
    <groupId>org.apache.dubbo</groupId>
    <artifactId>dubbo-spring-boot-starter</artifactId>
    <version>2.7.8</version>
</dependency>
<dependency>
    <groupId>org.apache.dubbo</groupId>
    <artifactId>dubbo-registry-zookeeper</artifactId>
    <version>2.7.8</version>
</dependency>

1.2 配置 Dubbo

在 application.properties 或 application.yml 中配置 Dubbo：

# 应用名称
dubbo.application.name=spring-boot-dubbo-provider
# 注册中心地址
dubbo.registry.address=zookeeper://127.0.0.1:2181
# 协议和端口
dubbo.protocol.name=dubbo
dubbo.protocol.port=20880

1.3 定义服务接口

定义一个服务接口：

public interface HelloService {
    String sayHello(String name);
}

1.4 实现服务接口

实现服务接口并使用 @Service 注解暴露服务：

import org.apache.dubbo.config.annotation.Service;

@Service
public class HelloServiceImpl implements HelloService {
    @Override
    public String sayHello(String name) {
        return "Hello, " + name;
    }
}

1.5 消费服务

在消费者端，使用 @Reference 注解引用服务：

import org.apache.dubbo.config.annotation.Reference;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {

    @Reference
    private HelloService helloService;

    @GetMapping("/hello")
    public String hello(String name) {
        return helloService.sayHello(name);
    }
}

2. 使用 gRPC 实现 RPC

gRPC 是 Google 开源的一个高性能 RPC 框架，基于 HTTP/2 和 Protocol Buffers。

2.1 添加依赖

在 pom.xml 中添加 gRPC 的依赖：

<dependency>
    <groupId>net.devh</groupId>
    <artifactId>grpc-spring-boot-starter</artifactId>
    <version>2.12.0.RELEASE</version>
</dependency>

2.2 定义 Protocol Buffers

定义一个 .proto 文件：

syntax = "proto3";

package example;

service HelloService {
    rpc SayHello (HelloRequest) returns (HelloResponse);
}

message HelloRequest {
    string name = 1;
}

message HelloResponse {
    string message = 1;
}

2.3 生成 Java 代码

使用 protoc 工具生成 Java 代码：

protoc --java_out=src/main/java src/main/proto/hello.proto

2.4 实现服务

实现 gRPC 服务：

import io.grpc.stub.StreamObserver;
import net.devh.boot.grpc.server.service.GrpcService;

@GrpcService
public class HelloServiceImpl extends HelloServiceGrpc.HelloServiceImplBase {

    @Override
    public void sayHello(HelloRequest req, StreamObserver<HelloResponse> responseObserver) {
        HelloResponse reply = HelloResponse.newBuilder().setMessage("Hello " + req.getName()).build();
        responseObserver.onNext(reply);
        responseObserver.onCompleted();
    }
}

2.5 消费服务

在客户端消费 gRPC 服务：

import net.devh.boot.grpc.client.inject.GrpcClient;
import org.springframework.stereotype.Service;

@Service
public class HelloClient {

    @GrpcClient("hello-service")
    private HelloServiceGrpc.HelloServiceBlockingStub helloServiceStub;

    public String sayHello(String name) {
        HelloRequest request = HelloRequest.newBuilder().setName(name).build();
        HelloResponse response = helloServiceStub.sayHello(request);
        return response.getMessage();
    }
}

3. 使用 Spring Cloud 实现 RPC

Spring Cloud 提供了多种方式来实现服务间的通信，如 Feign、RestTemplate 等。

3.1 使用 Feign 实现 RPC

Feign 是一个声明式的 Web 服务客户端，可以简化 HTTP API 的调用。

3.1.1 添加依赖

在 pom.xml 中添加 Feign 的依赖：

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

3.1.2 启用 Feign

在启动类上添加 @EnableFeignClients 注解：

@SpringBootApplication
@EnableFeignClients
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

3.1.3 定义 Feign 客户端

定义一个 Feign 客户端接口：

import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;

@FeignClient(name = "hello-service", url = "http://localhost:8080")
public interface HelloClient {

    @GetMapping("/hello")
    String sayHello(@RequestParam String name);
}

3.1.4 使用 Feign 客户端

在服务中使用 Feign 客户端：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {

    @Autowired
    private HelloClient helloClient;

    @GetMapping("/hello")
    public String hello(String name) {
        return helloClient.sayHello(name);
    }
}