Springboot整合Dubbo3,使用Triple协议+ProtoBuf序列化进行远程调用

说明准备工作

环境：windows、jdk17、zookeeper。其它系统会存在一定的问题，本教程只适用于windows系统

使用SpringBoot搭建maven父子工程，共3个工程共同配合完成

工程结构说明：

- dubbo-triple-api       // 存放整个项目的共同接口api等文件
- dubbo-triple-provider  // 服务的提供者，对dubbo-triple-api 定义的接口信息进行实现
- dubbo-triple-consumer  // 服务的消费者，进行远程调用dubbo-triple-provider中的服务

父工程dubbo-triple-demo 配置项目共同的依赖和版本管理

<?xml version="1.0" encoding="UTF-8"?>  
<project xmlns="http://maven.apache.org/POM/4.0.0"  
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">  
<modelVersion>4.0.0</modelVersion>  
  
    <groupId>com.north</groupId>  
    <artifactId>dubbo-triple-demo</artifactId>  
    <version>1.0-SNAPSHOT</version>  
    <packaging>pom</packaging>  
    
    <modules>  
        <module>dubbo-triple-api</module>  
        <module>dubbo-triple-provider</module>  
        <module>dubbo-triple-consumer</module>  
    </modules>  
  
    <properties>  
        <maven.compiler.source>17</maven.compiler.source>  
        <maven.compiler.target>17</maven.compiler.target>  
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>  
        <!--springboot版本-->  
        <springboot.version>2.7.12</springboot.version>  
        <!--dubbo版本-->  
        <dubbo.version>3.2.0</dubbo.version>  
        <!--grpc版本-->  
        <grpc.version>1.54.1</grpc.version>  
        <!--protobuf版本-->  
        <protoc.version>3.21.7</protoc.version>  
        <!--zookeeper版本-->  
        <zookeeper.version>3.8.1</zookeeper.version>  
        <!--操作系统相关，与后续拉取对应的protoc 编译器有关。如果配置不正确，则在使用maven插件根据proto文件生成java代码会出现错误-->  
        <os.detected.classifier>windows-x86_64</os.detected.classifier>  
    </properties>  
  
  
    <!--工程项目的共同依赖-->  
    <dependencies>  
        <dependency>  
            <groupId>org.springframework.boot</groupId>  
            <artifactId>spring-boot-starter</artifactId>  
        </dependency>  
        <dependency>  
            <groupId>org.springframework.boot</groupId>  
            <artifactId>spring-boot-starter-test</artifactId>  
            <scope>test</scope>  
        </dependency>  
        <dependency>  
            <groupId>org.apache.dubbo</groupId>  
            <artifactId>dubbo-spring-boot-starter</artifactId>  
        </dependency>  
        <dependency>  
            <groupId>org.apache.dubbo</groupId>  
            <artifactId>dubbo</artifactId>  
        </dependency>  
        <dependency>  
            <groupId>io.grpc</groupId>  
            <artifactId>grpc-all</artifactId>  
            <version>${grpc.version}</version>  
            <exclusions>  
                <exclusion>  
                    <groupId>grpc-netty</groupId>  
                    <artifactId>io.grpc</artifactId>  
                </exclusion>  
            </exclusions>  
        </dependency>  
        <dependency>  
            <groupId>com.google.protobuf</groupId>  
            <artifactId>protobuf-java</artifactId>  
            <version>${protoc.version}</version>  
        </dependency>  
        <dependency>  
            <groupId>org.apache.dubbo</groupId>  
            <artifactId>dubbo-dependencies-zookeeper-curator5</artifactId>  
            <version>${dubbo.version}</version>  
            <type>pom</type>  
            <exclusions>  
                <exclusion>  
                    <artifactId>zookeeper</artifactId>  
                    <groupId>org.apache.zookeeper</groupId>  
                </exclusion>  
            </exclusions>  
        </dependency>  
        <dependency>  
            <groupId>org.apache.zookeeper</groupId>  
            <artifactId>zookeeper</artifactId>  
            <version>${zookeeper.version}</version>  
        </dependency>  
        <dependency>  
            <groupId>org.projectlombok</groupId>  
            <artifactId>lombok</artifactId>  
        </dependency>  

    </dependencies>  
  
    <!--依赖管理-->  
    <dependencyManagement>  
        <dependencies>  
            <!--dubbo-->  
            <dependency>  
                <groupId>org.apache.dubbo</groupId>  
                <artifactId>dubbo-bom</artifactId>  
                <version>${dubbo.version}</version>  
                <type>pom</type>  
                <scope>import</scope>  
            </dependency>  
            <!--springboot-->  
            <dependency>  
                <groupId>org.springframework.boot</groupId>  
                <artifactId>spring-boot-dependencies</artifactId>  
                <version>${springboot.version}</version>  
                <type>pom</type>  
                <scope>import</scope>  
            </dependency>  
            <!--grpc-->  
            <dependency>  
                <groupId>io.grpc</groupId>  
                <artifactId>grpc-bom</artifactId>  
                <version>${grpc.version}</version>  
                <type>pom</type>  
                <scope>import</scope>  
            </dependency>  
        </dependencies>  
    </dependencyManagement>  
  
    <!--编译配置，使用maven相关插件根据proto文件生成java代码-->  
    <build>  
        <extensions>  
            <extension>  
                <groupId>kr.motd.maven</groupId>  
                <artifactId>os-maven-plugin</artifactId>  
                <version>1.7.1</version>  
            </extension>  
        </extensions>  
    <!--maven插件-->  
    <plugins>  
        <plugin>  
            <groupId>org.xolstice.maven.plugins</groupId>  
            <artifactId>protobuf-maven-plugin</artifactId>  
            <version>0.6.1</version>  
            <configuration>  
                <protocArtifact>com.google.protobuf:protoc:3.21.7:exe:${os.detected.classifier}</protocArtifact>  
                <pluginId>grpc-java</pluginId>  
                <pluginArtifact>io.grpc:protoc-gen-grpc-java:${grpc.version}:exe:${os.detected.classifier}</pluginArtifact>  
                <outputDirectory>${basedir}/src/main/java</outputDirectory>  
                <clearOutputDirectory>false</clearOutputDirectory>  
                <protocPlugins>  
                    <protocPlugin>  
                        <id>dubbo</id>  
                        <groupId>org.apache.dubbo</groupId>  
                        <artifactId>dubbo-compiler</artifactId>  
                        <version>${dubbo.version}</version>  
                        <mainClass>org.apache.dubbo.gen.tri.Dubbo3TripleGenerator</mainClass>  
                    </protocPlugin>  
                </protocPlugins>  
            </configuration>  
            <executions>  
                <execution>  
                    <goals>  
                        <goal>compile</goal>  
                        <goal>test-compile</goal>  
                        <goal>compile-custom</goal>  
                        <goal>test-compile-custom</goal>  
                    </goals>  
                </execution>  
            </executions>  
        </plugin>  
        </plugins>  
    </build>  
  
</project>

dubbo-triple-api 开发

在main目录下创建.proto文件

syntax = "proto3";  
  
option java_multiple_files = true;  
option java_package = "com.north.tri";  
  
package com.north.tri;  
// The request message containing the user's name.  
message TripleDemonRequest {  
    string name = 1;  
}  
// The response message containing the greetings  
message TripleDemonReply {  
    string message = 1;  
}  
service TripleDemon{  
    // unary  
    rpc greet(TripleDemonRequest) returns (TripleDemonReply); 
}

因为在父工程pom文件的build标签配置了插件，所以可以通过插件根据.proto文件生成java代码。前提是idea中安装了Maven Helper插件，没有安装的话可以安装一下。windows系统中Ctrl + Alt + R 快捷键打开此插件。

dubbo-triple-api 生成的代码目录结构如下：

dubbo-triple-provider 开发

pom.xml文件依赖dubbo-triple-api模块

<dependency>  
    <groupId>com.north</groupId>  
    <artifactId>dubbo-triple-api</artifactId>  
    <version>1.0-SNAPSHOT</version>  
</dependency>

application.yml配置文件的配置信息

spring:  
  application:  
    name: dubbo-triple-provider # 注册名  
  
dubbo:  
  protocol:  
    name: tri # 通信的协议类型  
    port: -1 # 随机端口  
  registry:  
    address: zookeeper://127.0.0.1:2181 # zookeeper注册中心的地址

服务的提供者

package com.north.service;  
  
import com.north.tri.*;  
import org.apache.dubbo.config.annotation.DubboService;  
  
@DubboService  // 将此注入到注册中心并发布服务  
public class TripleServiceImpl extends DubboTripleDemonTriple.TripleDemonImplBase {  
    @Override  
    public TripleDemonReply greet(TripleDemonRequest request) {  
        System.out.println("请求的数据为：" + request.getName());  
        TripleDemonReply reponse = TripleDemonReply.newBuilder().setMessage("triple 协议调用成功后返回的结果").build();  
        return reponse;  
    }  
}

Springboot启动类上配置注解@EnableDubbo

package com.north;  
  
import org.apache.dubbo.config.spring.context.annotation.EnableDubbo;  
import org.springframework.boot.SpringApplication;  
import org.springframework.boot.autoconfigure.SpringBootApplication;  
  
@SpringBootApplication  
@EnableDubbo  
public class TripleProviderApplication {  
    public static void main(String[] args) {  
        SpringApplication.run(TripleProviderApplication.class,args);  
    }  
}

dubbo-triple-consumer 开发

同理，pom.xml文件同样依赖dubbo-triple-api

<dependency>  
    <groupId>com.north</groupId>  
    <artifactId>dubbo-triple-api</artifactId>  
    <version>1.0-SNAPSHOT</version>  
</dependency>

application.yml配置文件的配置信息

spring:  
  application:  
    name: dubbo-triple-consumer  
  
dubbo:  
  registry:  
    address: zookeeper://127.0.0.1:2181 # 注册中心的地址  
  application:  
    qos-enable: false # 关闭qos

在springboot中的test包中，编写junit测试，进行远程方法调用，查看是否成功

import org.apache.dubbo.common.stream.StreamObserver;  
import org.apache.dubbo.config.annotation.DubboReference;  
import org.junit.jupiter.api.Test;  
import org.springframework.boot.test.context.SpringBootTest;  
  
import java.io.IOException;  
  
@SpringBootTest  
public class TestConsumer {  

    // 指定以什么协议开始调用  
    @DubboReference(protocol = "tri")  
    private TripleDemon tripleDemon;  

    @Test  
    public void Test1(){  
        TripleDemonReply result = tripleDemon.greet(TripleDemonRequest.newBuilder().setName("小黑子").build());  
        System.out.println("远程dubbo triple协议调用的结果是：" + result.getMessage());  
    }
}

查看服务提供者和服务消费者的调用结果：

dubbo-triple-provider

dubbo-triple-consumer

这只是简单的protobuf的一元操作，复杂的流式操作与grpc的流式操作一致，就不再写了。Dubbo的Triple协议是完全兼容gRPC协议，如果使用的是Dubbo3其它协议，只需要换相应的依赖，在服务提供者、服务消费者工程的配置文件中指定对应的协议且服务消费者调用的@DubboReference(protocol = "具体的协议") 注解中指定具体协议即可