Dubbo3应用开发—协议（Dubbo协议、REST协议 、gRPC协议、Triple协议）

最新推荐文章于 2025-03-22 01:20:33 发布
最新推荐文章于 2025-03-22 01:20:33 发布
阅读量798 收藏 2
点赞数 1
分类专栏： Dubbo3应用开发 文章标签： dubbo java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41243472/article/details/133580474
版权

协议

协议简介

什么是协议

Client(Consumer端)与Server（Provider端）在传输数据时双方的约定。

协议简介

Dubbo3中常见的协议

1.dubbo协议[前面文章中使用的都是dubbo协议]
2.rest协议
3.triple协议
4.grpc协议
5.thirft协议
6.webservice协议
7.rocketmq协议
8.redis协议
9.memacached协议
...等等

不同协议的通信效率对比

dubbo官方提供的不同协议之间通信效率的对比如下：

不同协议的通信效率对比

Dubbo协议

1.Dubbo的默认协议，自己定义的私有协议，基于TCP层，默认的通信方式是Netty4;
2.Dubbo采用单一长连接和NIO异步通讯，适合于小数据量大并发的服务调用，反之，Dubbo缺省协议不适合传送大数据量的服务，比如传文件、传视频等。

官方提供的Dubbo协议结构图：

Dubbo协议结构图

官方提供的Dubbo协议的帧组成图：

Dubbo协议的帧组成

协议构成详见Dubbo2 协议规范 | Apache Dubbo

Dubbo协议的使用

准备——zookeeper的安装
https://archive.apache.org/dist/zookeeper/

下载zk

如果使用windows，可以7z解压缩软件解压缩tar包的形式

https://sparanoid.com/lab/7z/

修改conf/zoo.cfg配置⽂件

dataDir=D:\\zookeeper\\apache-zookeeper-3.6.1\\data

启动服务端

启动服务端

启动客户端

客户端

https://github.com/vran-dev/PrettyZoo/releases
图形化zk的客户端
创建项目

父项目maven文件中对依赖版本进行管理

<properties>
    <maven.compiler.source>8</maven.compiler.source>
    <maven.compiler.target>8</maven.compiler.target>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <dubbo.version>3.2.0</dubbo.version>
    <spring-boot.version>2.7.12</spring-boot.version>
    <spring.version>5.3.25</spring.version>
</properties>
<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.apache.dubbo</groupId>
            <artifactId>dubbo-bom</artifactId>
            <version>${dubbo.version}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-dependencies</artifactId>
            <version>${spring-boot.version}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

zk版本和dubbo版本的关系

引入相关依赖

<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>

    <!--zk注册中心 需要的依赖-->
    <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>3.8.1</version>
    </dependency>

    <!--lombok-->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.22</version>
    </dependency>


    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aop</artifactId>
        <version>${spring.version}</version>
    </dependency>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-beans</artifactId>
        <version>${spring.version}</version>
    </dependency>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>${spring.version}</version>
    </dependency>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-core</artifactId>
        <version>${spring.version}</version>
    </dependency>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-expression</artifactId>
        <version>${spring.version}</version>
    </dependency>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jcl</artifactId>
        <version>${spring.version}</version>
    </dependency>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-test</artifactId>
        <version>${spring.version}</version>
    </dependency>



    <!--<dependency>
            <groupId>org.apache.dubbo</groupId>
            <artifactId>dubbo-rpc-rest</artifactId>
            <version>${dubbo.version}</version>
            <exclusions>
                <exclusion>
                    <artifactId>jackson-core-asl</artifactId>
                    <groupId>org.codehaus.jackson</groupId>
                </exclusion>
                <exclusion>
                    <artifactId>jackson-jaxrs</artifactId>
                    <groupId>org.codehaus.jackson</groupId>
                </exclusion>
                <exclusion>
                    <artifactId>jackson-mapper-asl</artifactId>
                    <groupId>org.codehaus.jackson</groupId>
                </exclusion>
                <exclusion>
                    <artifactId>jackson-xc</artifactId>
                    <groupId>org.codehaus.jackson</groupId>
                </exclusion>
            </exclusions>
        </dependency>

        <dependency>
            <groupId>org.jboss.resteasy</groupId>
            <artifactId>resteasy-jackson-provider</artifactId>
            <version>${resteasy-version}</version>
            <exclusions>
                <exclusion>
                    <artifactId>jackson-core-asl</artifactId>
                    <groupId>org.codehaus.jackson</groupId>
                </exclusion>
                <exclusion>
                    <artifactId>jackson-jaxrs</artifactId>
                    <groupId>org.codehaus.jackson</groupId>
                </exclusion>
                <exclusion>
                    <artifactId>jackson-mapper-asl</artifactId>
                    <groupId>org.codehaus.jackson</groupId>
                </exclusion>
                <exclusion>
                    <artifactId>jackson-xc</artifactId>
                    <groupId>org.codehaus.jackson</groupId>
                </exclusion>
            </exclusions>
        </dependency>

        <dependency>
            <artifactId>jackson-core-asl</artifactId>
            <groupId>org.codehaus.jackson</groupId>
            <version>${jackson-version}</version>
        </dependency>

        <dependency>
            <artifactId>jackson-jaxrs</artifactId>
            <groupId>org.codehaus.jackson</groupId>
            <version>${jackson-version}</version>
        </dependency>

        <dependency>
            <artifactId>jackson-mapper-asl</artifactId>
            <groupId>org.codehaus.jackson</groupId>
            <version>${jackson-version}</version>
        </dependency>

        <dependency>
            <artifactId>jackson-xc</artifactId>
            <groupId>org.codehaus.jackson</groupId>
            <version>${jackson-version}</version>
        </dependency>-->

</dependencies>

创建api、provider、consumer包，并编写代码。

provider的application.yml配置文件如下：

spring:
  application:
    name: DUBBO-PROTOCOL-PROVIDER
dubbo:
  protocol:
    name: dubbo
    port: -1
  registry:
    address: zookeeper://127.0.0.1:2181

consumer的application.yml的配置如下：

spring:
  application:
    name: DUBBO-PROTOCOL-CONSUMER
dubbo:
  registry:
    address: zookeeper://127.0.0.1:2181

  application:
    qos-enable: false

REST协议

Rest协议就是我们平时说的Restful,本质上把他称为协议不准确。因为 Restful他是基于Http1.x协议的。 使⽤Rest协议这种⽅式可以让我们的Dubbo服务直接通过url进⾏访问，同时也可以更好的与SpringCloud技术栈进⾏整合。

搭建开发环境

父项目的pom文件核心如下：

<properties>
    <maven.compiler.source>8</maven.compiler.source>
    <maven.compiler.target>8</maven.compiler.target>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <dubbo.version>3.2.0</dubbo.version>
    <spring-boot.version>2.6.11</spring-boot.version>
    <jackson-version>1.9.13</jackson-version>
    <resteasy-version>3.15.6.Final</resteasy-version>
    <tomcat.version>9.0.75</tomcat.version>
    <grpc.version>1.54.1</grpc.version>
    <spring.version>5.3.25</spring.version>
</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>

    <!--zk注册中心 需要的依赖-->
    <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>3.8.1</version>
    </dependency>

    <!--lombok-->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.22</version>
    </dependency>


    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aop</artifactId>
        <version>${spring.version}</version>
    </dependency>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-beans</artifactId>
        <version>${spring.version}</version>
    </dependency>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>${spring.version}</version>
    </dependency>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-core</artifactId>
        <version>${spring.version}</version>
    </dependency>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-expression</artifactId>
        <version>${spring.version}</version>
    </dependency>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jcl</artifactId>
        <version>${spring.version}</version>
    </dependency>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-test</artifactId>
        <version>${spring.version}</version>
    </dependency>


    <dependency>
        <groupId>org.apache.dubbo</groupId>
        <artifactId>dubbo-rpc-rest</artifactId>
        <version>${dubbo.version}</version>
        <exclusions>
            <exclusion>
                <artifactId>jackson-core-asl</artifactId>
                <groupId>org.codehaus.jackson</groupId>
            </exclusion>
            <exclusion>
                <artifactId>jackson-jaxrs</artifactId>
                <groupId>org.codehaus.jackson</groupId>
            </exclusion>
            <exclusion>
                <artifactId>jackson-mapper-asl</artifactId>
                <groupId>org.codehaus.jackson</groupId>
            </exclusion>
            <exclusion>
                <artifactId>jackson-xc</artifactId>
                <groupId>org.codehaus.jackson</groupId>
            </exclusion>
        </exclusions>
    </dependency>

    <dependency>
        <groupId>org.jboss.resteasy</groupId>
        <artifactId>resteasy-jackson-provider</artifactId>
        <version>${resteasy-version}</version>
        <exclusions>
            <exclusion>
                <artifactId>jackson-core-asl</artifactId>
                <groupId>org.codehaus.jackson</groupId>
            </exclusion>
            <exclusion>
                <artifactId>jackson-jaxrs</artifactId>
                <groupId>org.codehaus.jackson</groupId>
            </exclusion>
            <exclusion>
                <artifactId>jackson-mapper-asl</artifactId>
                <groupId>org.codehaus.jackson</groupId>
            </exclusion>
            <exclusion>
                <artifactId>jackson-xc</artifactId>
                <groupId>org.codehaus.jackson</groupId>
            </exclusion>
        </exclusions>
    </dependency>

    <dependency>
        <artifactId>jackson-core-asl</artifactId>
        <groupId>org.codehaus.jackson</groupId>
        <version>${jackson-version}</version>
    </dependency>

    <dependency>
        <artifactId>jackson-jaxrs</artifactId>
        <groupId>org.codehaus.jackson</groupId>
        <version>${jackson-version}</version>
    </dependency>

    <dependency>
        <artifactId>jackson-mapper-asl</artifactId>
        <groupId>org.codehaus.jackson</groupId>
        <version>${jackson-version}</version>
    </dependency>

    <dependency>
        <artifactId>jackson-xc</artifactId>
        <groupId>org.codehaus.jackson</groupId>
        <version>${jackson-version}</version>
    </dependency>

</dependencies>


<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.apache.dubbo</groupId>
            <artifactId>dubbo-bom</artifactId>
            <version>${dubbo.version}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-dependencies</artifactId>
            <version>${spring-boot.version}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

provide pom文件引入的依赖:

<dependencies>
    <dependency>
        <groupId>com.sjdwz</groupId>
        <artifactId>dubbo-protocol-api</artifactId>
        <version>1.0-SNAPSHOT</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
        <exclusions>
            <exclusion>
                <artifactId>tomcat-embed-core</artifactId>
                <groupId>org.apache.tomcat.embed</groupId>
            </exclusion>
        </exclusions>
    </dependency>

    <dependency>
        <groupId>org.apache.tomcat.embed</groupId>
        <artifactId>tomcat-embed-core</artifactId>
        <version>${tomcat.version}</version>
    </dependency>
</dependencies>

consumer只需要引入api模块即可。

api模块

java编码

@Path("orders")
@Consumes({MediaType.APPLICATION_JSON})
@Produces({ContentType.APPLICATION_JSON_UTF_8})
public interface OrderService {

    @GET
    @Path("{id}")
    Order getOrder(@PathParam("id") Long id);
}

provider模块

application.yml文件

spring:
  application:
    name: DUBBO-PROTOCOL-PROVIDER
dubbo:
  protocol:
    name: rest
    port: 9005
    server: tomcat
    contextpath: sjdwz
  registry:
    address: zookeeper://127.0.0.1:2181
server:
  port: 8090

java代码

@DubboService
public class OrderServiceImpl implements OrderService {
    @Override
    public Order getOrder(Long id) {
        System.out.println("OrderServiceImpl.getOrder id " + id);
        return new Order("1001", 100.0);
    }
}

运行起来

http://localhost:9005/sjdwz/orders/1

在浏览器输入上述url即可访问到。

consumer模块

java代码

@DubboReference(protocol = "rest")
private OrderService orderService;


@Test
public void test2(){
    orderService.getOrder(2L);
}

gRPC协议

  1. gRPC简介

    Dubbo中的gRPC协议就是应⽤gRPC来替换Dubbo的RPC调⽤。本质上把它称为协议不准确,因为gRPC他是Google开源⼀种异构语⾔通信的RPC框
架。Dubbo引⼊gRPC的⽬的是为了更好的支持云原生的开发。

  2. gRPC底层协议

    gRPC底层基于Http2.x协议。Http2.x是双工协议，可以支持流式通信（反应式编程）。所以在通信效率上更高。

  3. gRPC开发过程

    1. 通过Protobuf的IDL定义通信数据，及操作。
2. 通过Maven的插件，根据不同的编程语言生成成对应的代码
3. 服务端发布RPC服务
3.1. ⼀元调⽤
3.2. 服务端流式RPC
3.3. 客户端流式RPC
3.4. 双向流式RPC
4. 客户端进⾏RPC服务的调⽤
4.1. 通过stub代理进⾏远端RPC的调⽤

  4. Dubbo中gRPC协议的开发

    本质上Dubbo对于gRPC协议的⽀持，就是在原有gRPC客户端代码上进行了封装。

  5. 父项目依赖设置

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <dubbo.version>3.1.10</dubbo.version>
        <spring-boot.version>2.7.12</spring-boot.version>
        <grpc.version>1.54.1</grpc.version>
        <os.detected.classifier>windows-x86_64</os.detected.classifier>
        <spring.version>5.3.25</spring.version>
    </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>

        <!--zk注册中心 需要的依赖-->
        <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>3.8.1</version>
        </dependency>

        <!--lombok-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.22</version>
        </dependency>


        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-expression</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jcl</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>${spring.version}</version>
        </dependency>

    </dependencies>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.apache.dubbo</groupId>
                <artifactId>dubbo-bom</artifactId>
                <version>${dubbo.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>

            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>${spring-boot.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>

            <dependency>
                <groupId>io.grpc</groupId>
                <artifactId>grpc-bom</artifactId>
                <version>${grpc.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

api模块的开发

pom文件修改

<dependencies>
    <dependency>
        <groupId>io.grpc</groupId>
        <artifactId>grpc-netty</artifactId>
        <exclusions>
            <exclusion>
                <groupId>io.netty</groupId>
                <artifactId>netty-codec-http2</artifactId>
            </exclusion>
            <exclusion>
                <groupId>io.netty</groupId>
                <artifactId>netty-handler-proxy</artifactId>
            </exclusion>
        </exclusions>
    </dependency>
    <dependency>
        <groupId>io.grpc</groupId>
        <artifactId>grpc-netty-shaded</artifactId>
    </dependency>
    <dependency>
        <groupId>io.grpc</groupId>
        <artifactId>grpc-protobuf</artifactId>
        <exclusions>
            <exclusion>
                <groupId>com.google.protobuf</groupId>
                <artifactId>protobuf-java</artifactId>
            </exclusion>
        </exclusions>
    </dependency>
    <dependency>
        <groupId>io.grpc</groupId>
        <artifactId>grpc-stub</artifactId>
    </dependency>

    <dependency>
        <groupId>org.apache.dubbo</groupId>
        <artifactId>dubbo-common</artifactId>
    </dependency>

    <dependency>
        <groupId>com.google.protobuf</groupId>
        <artifactId>protobuf-java</artifactId>
        <version>3.21.7</version>
    </dependency>

    <dependency>
        <groupId>com.google.protobuf</groupId>
        <artifactId>protobuf-java-util</artifactId>
        <version>3.21.7</version>
        <exclusions>
            <exclusion>
                <groupId>com.google.protobuf</groupId>
                <artifactId>protobuf-java</artifactId>
            </exclusion>
        </exclusions>
    </dependency>

</dependencies>

<build>
    <plugins>
        <plugin>
            <groupId>kr.motd.maven</groupId>
            <artifactId>os-maven-plugin</artifactId>
            <version>1.7.1</version>
        </plugin>
        <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-grpc</id>
                        <groupId>org.apache.dubbo</groupId>
                        <artifactId>dubbo-compiler</artifactId>
                        <version>${dubbo.version}</version>
                        <mainClass>org.apache.dubbo.gen.grpc.DubboGrpcGenerator</mainClass>
                    </protocPlugin>
                </protocPlugins>
            </configuration>
            <executions>
                <execution>
                    <id>protobuf-maven-plugin</id>
                    <goals>
                        <goal>compile</goal>
                        <goal>compile-custom</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

maven插件

provider模块的开发

application.yml文件

spring:
  application:
    name: DUBBO-PROTOCOL-PROVIDER
dubbo:
  protocol:
    name: grpc
    port: -1
  registry:
    address: zookeeper://127.0.0.1:2181
#  port: 8081

Java类

provider的ServiceImpl

@DubboService
public class DemoServiceImpl extends DubboDemoServiceGrpc.DemoServiceImplBase {
    @Override
    public void demo(RequestData request, StreamObserver<ResponseData> responseObserver) {
        System.out.println("DemoServiceImpl.demo " + request.getName());
        responseObserver.onNext(ResponseData.newBuilder().setResult("this is result").build());
        responseObserver.onCompleted();
    }
}

consumer模块的开发

测试Java方法

@DubboReference(protocol = "grpc")
private DubboDemoServiceGrpc.IDemoService iDemoService;


@Test
void test3() {
    ResponseData ret = iDemoService.demo(RequestData.newBuilder().setName("xiaohei").build());
    System.out.println("ret.getResult() = " + ret.getResult());

}

Triple协议

  1. Triple协议是什么

    在阿里巴巴，Triple 协议广泛用于跨环境、跨语言、跨生态互通，已有数十万容器生产级使用。

Triple 协议是 Dubbo3设计的基于HTTP的RPC通信协议规范，它完全兼容 gRPC 协议，支持 Request-Response、Streaming流式等通信模型，可同时运行在HTTP/1和 HTTP/2之上。
核心:
1.Dubbo3全新设计的基于Http的RPC协议
2.完全兼容gRPC协议
3.支持Streaming流式通信【与gRPC类似】
4.同时支持HTTP1和HTTP2
5.对比内置的Dubbo协议，更好的支持异构语言通信，且更加适应云原生。

  2. Dubbo原有已经支持了gRPC协议，为什么还要做Triple协议?

    生态建设︰
1.如果只支持gRPC协议，不能够体现Dubbo的价值，毕竟gRPC是Google制定的。
Triple的优势:
1.不绑定IDL，支持Java lnterface 定义服务。(gRPC需要使用Protobuf,而Triple可以通过Java接口的方式进行服务的)
2.同时支持Http1和Http2协议，而gRPC只支持Http2协议。
3.100%兼容gRPC。从Dubbo3.2.x开始，已经废弃原有的gRPC协议使用Triple协议进行替代。

Triple协议的开发

父项目中pom文件，dubbo版本切换到3.2.0

<properties>
    <maven.compiler.source>8</maven.compiler.source>
    <maven.compiler.target>8</maven.compiler.target>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <dubbo.version>3.2.0</dubbo.version>
    <grpc.version>1.54.1</grpc.version>
    <spring-boot.version>2.7.12</spring-boot.version>
    <protoc.version>3.21.7</protoc.version>
	<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>
                <artifactId>grpc-netty</artifactId>
                <groupId>io.grpc</groupId>
            </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>3.8.1</version>
    </dependency>

    <!--lombok-->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.22</version>
    </dependency>

</dependencies>

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.apache.dubbo</groupId>
            <artifactId>dubbo-bom</artifactId>
            <version>${dubbo.version}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-dependencies</artifactId>
            <version>${spring-boot.version}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>

        <dependency>
            <groupId>io.grpc</groupId>
            <artifactId>grpc-bom</artifactId>
            <version>${grpc.version}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>
<build>
    <extensions>
        <extension>
            <groupId>kr.motd.maven</groupId>
            <artifactId>os-maven-plugin</artifactId>
            <version>1.7.1</version>
        </extension>
    </extensions>
    <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>
api模块的开发

proto文件夹

syntax = "proto3";
option java_multiple_files = true;
option java_package = "com.sjdwz.tri";
package com.sjdwz.tri;
// The request message containing the user's name.
message GreeterRequest {
  string name = 1;
}
// The response message containing the greetings
message GreeterReply {
  string message = 1;
}
service Greeter{
  // unary
  rpc greet(GreeterRequest) returns (GreeterReply);
  // serverStream
  rpc greetServerStream(GreeterRequest) returns (stream GreeterReply);
  // bi streaming
  rpc greetStream(stream GreeterRequest) returns (stream GreeterReply);
}

maven命令

在父项目执行上图maven命令。

provider模块的开发

application.yml

spring:
  application:
    name: DUBBO-TRIPLE-PROVIDER

dubbo:
  protocol:
    name: tri
    port: -1
  registry:
    address: zookeeper://127.0.0.1:2181

服务接口的开发

@DubboService
public class GreeterImpl extends DubboGreeterTriple.GreeterImplBase {
    @Override
    public GreeterReply greet(GreeterRequest request) {
        System.out.println("GreeterImpl.greet " + request.getName());
        GreeterReply greeterReply = GreeterReply.newBuilder().setMessage("this is on method").build();
        return greeterReply;
    }

    @Override
    public StreamObserver<GreeterRequest> greetStream(StreamObserver<GreeterReply> responseObserver) {
        System.out.println("GreeterImpl.greetStream");
        responseObserver.onNext(GreeterReply.newBuilder().setMessage("bi stream result").build());
        responseObserver.onCompleted();
        return new StreamObserver<GreeterRequest>() {
            @Override
            public void onNext(GreeterRequest data) {
                System.out.println(" recive request param = " + data.getName());
            }

            @Override
            public void onError(Throwable throwable) {

            }

            @Override
            public void onCompleted() {
                System.out.println("GreeterImpl.onCompleted");
            }
        };
    }

    @Override
    public void greetServerStream(GreeterRequest request, StreamObserver<GreeterReply> responseObserver) {
        System.out.println("GreeterImpl.greetServerStream name " + request.getName());

        responseObserver.onNext(GreeterReply.newBuilder().setMessage("this is result").build());

        responseObserver.onCompleted();
    }
}

consumer模块的开发

测试类的开发

@DubboReference(protocol = "tri")
private Greeter greeter;


@Test
void test2() {
    GreeterRequest request = GreeterRequest.newBuilder().setName("xiaowb").build();
    GreeterReply greeterReply = greeter.greet(request);
    System.out.println("greeterReply.getMessage() = " + greeterReply.getMessage());
}

triple协议——grpc方式的开发

api模块

在api模块的pom文件执行如下命令；

maven命令

consumer模块

gRPC adaptor类

package com.sjdwz;

import io.grpc.stub.StreamObserver;

public class GrpcStreamObserverAdapter<T> implements StreamObserver<T> {

    private final org.apache.dubbo.common.stream.StreamObserver<T> delegate;

    public GrpcStreamObserverAdapter(org.apache.dubbo.common.stream.StreamObserver<T> delegate) {
        this.delegate = delegate;
    }

    @Override
    public void onNext(T value) {
        delegate.onNext(value);
    }

    @Override
    public void onError(Throwable t) {
        delegate.onError(t);

    }

    @Override
    public void onCompleted() {
        delegate.onCompleted();

    }
}

Test类

@Test
void test4() {
    ManagedChannel managedChannel = ManagedChannelBuilder.forAddress("localhost", 50051).usePlaintext().build();
    try {
        //一元操作
        GreeterGrpc.GreeterBlockingStub greeterBlockingStub = GreeterGrpc.newBlockingStub(managedChannel);
        //流式处理
        GreeterGrpc.GreeterStub greeterStub = GreeterGrpc.newStub(managedChannel);
        GreeterRequest request = GreeterRequest.newBuilder().setName("grpc").build();
        greeterStub.greetServerStream(request, new GrpcStreamObserverAdapter<>(new StreamObserver<GreeterReply>() {
            @Override
            public void onNext(GreeterReply data) {
                System.out.println("TestTripleDemo.onNext " + data.getMessage());
            }

            @Override
            public void onError(Throwable throwable) {

            }

            @Override
            public void onCompleted() {
                System.out.println("TestTripleDemo.onCompleted");
            }
        }));

        System.in.read();
    } catch (Exception e) {
        throw new RuntimeException(e);
    } finally {
        managedChannel.shutdown();
    }
}

triple协议——Java Interface的方式

需要记住两个规律：

1. message替换成Java类型
2. StreamObserver也用StreamObserver处理
【最新Dubbo3深入理解】Dubbo3核心Triple协议详解
qq_45260619的博客
02-22 2307
因此 Dubbo 框架为了提升协议的通用性，可以和 SpringCloud 以及其他语言应用进行通信，在 Dubbo3.x 版本推出了基于 HTTP/2 的 Triple 协议，也就是说 Tripple 协议在发送数据时会根据 HTTP/2 协议的格式来发送！
Dubbo3.3之Triple协议客户端调用源码分析
10-06 888
全面支持南北向与东西向流量：Triple X 无缝支持从客户端到服务器的南北向流量及服务间通信的东西向流量，并确保灵活转换，提升通信链路的整体效率。遵循 gRPC 协议标准：Triple X 遵循了 gRPC 协议标准，支持通过 Protobuf 进行通信，与 gRPC 服务无缝交互，扩展了 Dubbo 的跨语言、跨平台通信能力。
dubbogo 3.0：牵手 gRPC 走向云原生时代
阿里巴巴云原生的博客
12-16 716
作者 | 李志信  于雨 来源|阿里巴巴云原生公众号 自从 2011 年 Dubbo 开源之后，被大量中小公司采用，一直是国内最受欢迎的 RPC 框架。2014 年，由于阿里内部组织架构调整，Dubbo 暂停维护了一段时间，之后随着 Spring Cloud 的面世，两个体系在融合中一起助推了微服务的火热。 不过这世界变化快，自从以 docker 为代表的的容器技术和以 K8s 为代表的容器编排技术登上舞台之后，云原生时代到来了。在云原生时代，不可变的基础设施给原有的中间件带来了不可变的中间件基.
Dubbo（8）Dubbo与其他RPC框架（如gRPC、Thrift）的区别？
qq_43012298的博客
03-22 908
特性DubbogRPCThrift通信协议多种协议（Dubbo、RMI、Hessian、HTTP等）HTTP/2多种协议（TCP、HTTP等）数据格式多种格式（Java序列化、Hessian等）多种格式（TBinaryProtocol、TCompactProtocol等）性能高性能高性能（HTTP/2和protobuf）高性能服务注册与发现支持（ZooKeeper等）不支持（需外部实现）不支持（需外部实现）负载均衡内置多种策略不支持（需外部实现）
Triple协议 和dubbo协议
weixin_44263023的博客
07-16 622
Dubbo协议是Dubbo框架的原始通信协议，它主要面向Java语言设计，用于在Dubbo服务提供者和服务消费者之间进行高效、可靠的通信。Dubbo协议经过精心设计和优化，旨在提供高性能、低延迟的远程调用能力，并支持多种序列化协议和负载均衡算法。Triple协议和Dubbo协议都是Dubbo框架中重要的RPC通信协议，它们各有特点和优势。在选择协议时，需要根据项目的具体需求和场景来决定。如果项目主要使用Java语言开发，且对性能要求较高，可以选择Dubbo协议；
Dubbo3 triple协议
09-22 1328
全面支持南北向与东西向流量：Triple X 无缝支持从客户端到服务器的南北向流量及服务间通信的东西向流量，并确保灵活转换，提升通信链路的整体效率。遵循 gRPC 协议标准：Triple X 遵循了 gRPC 协议标准，支持通过 Protobuf 进行通信，与 gRPC 服务无缝交互，扩展了 Dubbo 的跨语言、跨平台通信能力。基于 HTTP 协议，原生支持云原生架构。
九：Apache Dubbo 3 协议解析（一）
qq_36364521的博客
03-16 450
课程主要内容： 了解网络传输协议 了解Dubbo 3协议使用流程 掌握Dubbo 3核心协议 了解网络传输协议 传输协议有名通信协议 通信双方对数据传送控制的一种约定 优秀的协议设计是提高网络传输速度和安全的保障之一 关于拆包/粘包，可以查看链接了解 下面图简单描述下Dubbo的协议 ...
ApacheDubbo3.3：Triple协议与gRPC的互操作性实现.pdf
最新发布
04-26
内容概要：本文详细介绍了如何在 Apache Dubbo 3.3中实现 Triple协议与 gRPC的互操作性。首先，文章回顾了 Apache Dubbo 3.3和 gRPC的基础知识，包括核心特性、性能优化、协议结构等。接着，阐述了实现互操作性的...
如何用一个端口同时暴露 HTTP1/2、gRPC、Dubbo 协议?
阿里云云栖号
03-21 1045
本文我们将介绍 Apache Dubbo 灵活的多协议设计原则，基于这一设计，在 Dubbo 框架底层可灵活的选用 HTTP/2、HTTP/REST、TCP、gRPC、JsonRPC、Hessian2 等任一 RPC 通信协议，同时享用统一的 API 与对等的服务治理能力。
Dubbo3.0 新特性之 Triple
qq_43451295的博客
08-31 1645
Dubbo3.0 新特性之 Triple协议食用手册~
Dubbo3单端口发布多协议服务
程序员小潘
08-24 427
Dubbo3开始支持在单个端口上监听多个协议的不同服务。比如使用Triple协议启动端口复用后，可以在相同的端口上为服务增加 Dubbo协议支持，以及Qos协议支持。这些协议的识别都是由一个统一的端口复用服务器进行处理的，可以用于服务的协议迁移，并且可以节约端口以及相关的资源，减少运维的复杂性。
dubbo的Rest调用
m0_67402731的博客
04-01 421
概念 dubbo也支持rest的方式调用服务,比如说有个服务他没有集成dubbo,但是他也想调用你的provider,那怎么办他就可以用rest协议去调用 代码地址 https://gitee.com/zjj19941/ZJJ_Dubbo.git 下的 rest 项目 代码案例 provider配置文件 重点配置是:dubbo.protocols.p1 和 dubbo.protocols.p2 spring.application.name=dubbo-provider-demo server.port=8
Dubbo3之Triple协议Streaming通信
程序员小潘
08-24 1124
Dubbo3 推出的 Triple 协议开始支持 Streaming 流式通信，流式通信适用于大文件、大数据传输、直播流推送等场景。Stream 分为三种类型：客户端流、服务端流、双向流。由于 Java 语言的限制，客户端流和双向流实现方案是一样的。
dubbox开发rest+json指南【转】
weixin_33755847的博客
11-23 516
http://dangdangdotcom.github.io/dubbox/rest.html 目录 概述 REST的优点 应用场景 快速入门 标准Java REST API：JAX-RS简介 REST服务提供端详解 HTTP POST/GET的实现 Annotation放在接口类还是实现类 JSON、XML等多数据格式的支持 中文字符支持 XML数据格式的额外要...
dubbo rest 协议
weixin_33739541的博客
07-19 168
2019独角兽企业重金招聘Python工程师标准>>> ...
Dubbo REST协议
weixin_33918114的博客
04-09 743
为什么80%的码农都做不了架构师？>>> ...
Dubbo3主推的Triple协议
程序员小潘
08-24 1000
Dubbo3 推出了下一代RPC通信协议——Triple，译为第三代的。Triple 完全兼容 gRPC 协议，运行在 HTTP2 协议之上。Dubbo 框架提供了 Triple 协议的多种语言实现，可以帮助你构建浏览器、gRPC 兼容的 HTTP API 接口。已经有了 dubbo 协议，为啥还要推出 Triple 协议？？？Triple 协议的推出，旨在解决 Dubbo2 私有协议带来的互通性问题。Triple 协议就是要解决这些问题的。
Dubbo实战介绍3 - 通信协议
u013083284的专栏
10-23 279
Dubbo支持的协议 dubbo支持多协议    dubbo协议：为dubbo默认的协议，采用单一长连接和NIO异步通讯，适合小数据量大并发的服务调用，以及服务消费者的机器数量远大于服务提供者的机器数的情况。    Hessian协议： Hessian协议用于集成Hessian的服务，Hessian底层采用Http通讯，采用Servlet暴露服务，Dubbo缺省内嵌Jetty作为服务器实现 ...
Dubbo-Admin 实践，Dubbo3 配置多协议，同时提供Dubbo和HTTP协议
小道仙的后宫
04-27 1455
Dubbo是支持多协议的，它默认的Dubbo协议已经很好了，正常情况下，使用Dubbo是做服务之间的通信是不需要更换协议的。比如有两个服务的提供者提供相同的服务，可以给它们打上A、B标签，请求的时候可以根据标签去固定请求对应的服务。默认的协议就是 dubbo，所以在使用的时候不需要指定协议，如果使用其它协议需要指定对应的协议。Dubbo不只是作为服务间的通讯，它还涉及服务治理，今天就来一起学习下Dubbo的控制台使用。原本的dubbo协议是不需要提供路径的，现在的HTTP需要提供路径，改造如下。
**如何选择gRPC和Dubbo协议应对高并发场景？**
03-27
<think>好的，用户想比较gRPC和Dubbo在高并发场景下的适用性，需要从性能对比和用例分析入手。首先，我得回顾两者的基本架构和设计理念。 gRPC是Google开发的，基于HTTP/2和ProtoBuf，支持多语言，适合跨平台的服务调用。Dubbo是阿里巴巴的Java微服务框架，主要用Java，但后来也支持多语言。接下来，性能方面，高并发下需要考虑协议效率、序列化、负载均衡等。 HTTP/2的多路复用和头部压缩对高并发有帮助，可能减少连接数，提高吞吐量。Dubbo早期用单一长连接，现在支持HTTP/2了吗？需要确认。序列化方面，ProtoBuf比Hessian更高效，体积更小，解析更快，这对高并发下的网络传输很重要。 线程模型也很关键。gRPC基于Netty的异步IO，Dubbo的NIO框架可能不同版本有差异，比如Dubbo3使用Triple协议基于HTTP/2，可能性能接近gRPC。需要比较两者的线程管理和并发处理能力。 服务治理方面，Dubbo内置丰富的功能，如熔断、限流，适合复杂微服务场景。而gRPC需要依赖其他组件，如Istio，可能增加复杂度。但gRPC的生态系统完善，云原生支持好。 使用场景分析的话，如果系统是Java为主的微服务，Dubbo集成更顺畅；如果是多语言环境或需要云原生，gRPC更合适。高并发下，两者都能处理，但具体优化点不同，比如序列化选择、连接管理策略。 需要引用用户提供的资料，他们提到了gRPC的高性能和可靠分布式系统，Dubbo的优势场景。可能用户的应用场景是微服务架构，需要高吞吐低延迟，所以得结合实际情况给出建议。 最后，生成相关问题时要围绕性能优化、适用场景扩展、协议选择因素等，帮助用户深入思考。</think>### gRPC与Dubbo高并发场景下的性能对比与适用性分析 #### 一、协议架构对比 1. **gRPC架构特性** - 基于$HTTP/2$协议，支持多路复用（Multiplexing）和头部压缩（HPACK）[^1] - 使用$Protocol Buffers$（ProtoBuf）作为默认序列化协议，二进制编码效率优于JSON - 原生支持双向流式通信（如$gRPC Streaming$） 2. **Dubbo架构特性** - 默认采用$TCP$长连接，支持$HTTP/2$（Dubbo3的Triple协议） - 序列化可选Hessian2/JSON/ProtoBuf等 - 内置服务治理能力（熔断、限流、路由） #### 二、性能关键指标对比（高并发场景） | 维度 | gRPC | Dubbo | |-----------------|--------------------------------|--------------------------------| | **单机QPS** | 10-30万（ProtoBuf优化）[^1] | 8-25万（Hessian2序列化） | | **连接复用** | HTTP/2多路复用（1个连接/端口） | TCP长连接池（需维护多个连接） | | **线程模型** | 基于Netty的异步IO | NIO+线程池（可配置Reactor模式）| | **序列化开销** | ProtoBuf体积比Hessian2小30%-50%| Hessian2解析速度略快于JSON | #### 三、高并发优化实践 1. **gRPC优化方向** - 开启$gRPC KeepAlive$防止连接中断 - 使用$Bidirectional Streaming$减少RPC次数 ```python # gRPC流式调用示例 stub.StreamingRPC(iter(request_iterator)) ``` - 调整Netty的$EventLoopGroup$线程数（公式: $线程数=CPU核心数 \times 2$） 2. **Dubbo优化方向** - 启用Triple协议（基于HTTP/2）提升吞吐量20%+ - 配置连接池参数（如$dubbo.protocol.threads=200$） - 使用$NIO$线程分离策略避免阻塞 #### 四、典型应用场景 | 场景 | 推荐方案 | 原因分析 | |---------------------|----------------|----------------------------| | 多语言微服务集群 | gRPC | 跨语言支持完善 | | Java生态高密度服务 | Dubbo | 服务治理能力深度集成 | | 物联网设备海量连接 | gRPC | HTTP/2头部压缩节省带宽 | | 金融级低延迟交易 | Dubbo+Triple | 亚毫秒级响应+强治理能力 | #### 五、选择建议 1. **选择gRPC当** - 需要$Polyglot$（多语言）支持 - 已有云原生基础设施（如K8s+Istio） - 流式数据传输占比高（如实时日志传输） 2. **选择Dubbo当** - Java技术栈为主且需完整服务治理 - 要求与Spring生态深度整合 - 需兼容历史Dubbo协议服务（如从Dubbo2升级） ---
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

随机的未知

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值