响应式编程

使用 Reactive API 操作 Triple 流式调用

过时风险提醒

请注意，本文档描述的 Reactive 响应式使用方法可能存在过时的情况，请随时参考 apache/dubbo-samples 中的最新 reactive 示例了解用法。

特性说明

此特性基于 Triple 协议和 Project Reactor 实现，3.1.0 版本以上支持。用户仅需编写 IDL 文件，并指定 protobuf 插件的相应 Generator，即可生成并使用支持响应式API的 Stub 代码。

有四种调用模式，分别是 OneToOne、OneToMany、ManyToOne、ManyToMany，分别对应 Unary调用、服务端流、客户端流、双向流。在 Reactor 的实现中，One 对应 Mono，Many 对应 Flux。

Reactive Stream 提供了一套标准的异步流处理 API， 在能够让应用写出事件驱动的程序的同时，也通过 BackPressure 的方式保证了节点的稳定。Triple 协议在通信协议层面为 Dubbo 框架增加了流式场景的支持，在此基础上能够实现上层包括大文件传输和推送机制的业务需求。

Dubbo + Reactive Stream Stub 的组合模式可以给用户带来最方便的流式使用方式以及全链路异步性能提升。

参考用例 https://github.com/apache/dubbo-samples/tree/master/dubbo-samples-triple-reactor

使用场景

系统需要处理大量并发请求而不会使任何服务器过载。大量用户提供实时数据的系统，希望确保系统能够处理负载而不会崩溃或变慢。

使用方式

Triple 使用及配置可参考 IDL 方式使用 Triple，并确保 Dubbo 版本 >= 3.1.0。

添加必要的依赖

若要使用 Reactor Triple，需要额外添加如下依赖。

  1. <dependency>
  2.     <groupId>org.reactivestreams</groupId>
  3.     <artifactId>reactive-streams</artifactId>
  4. </dependency>
  5. <dependency>
  6.     <groupId>io.projectreactor</groupId>
  7.     <artifactId>reactor-core</artifactId>
  8. </dependency>

设置 protobuf Maven 插件

仅需将 mainClass 修改为 org.apache.dubbo.gen.tri.reactive.ReactorDubbo3TripleGenerator，并确保 ${compiler.version} >= 3.1.0

  1. <build>
  2.     <plugins>
  3.         <plugin>
  4.             <groupId>org.xolstice.maven.plugins</groupId>
  5.             <artifactId>protobuf-maven-plugin</artifactId>
  6.             <version>0.6.1</version>
  7.             <configuration>
  8.                 <protocArtifact>com.google.protobuf:protoc:${protoc.version}:exe:${os.detected.classifier}
  9.                 </protocArtifact>
  10.                 <pluginId>grpc-java</pluginId>
  11.                 <pluginArtifact>io.grpc:protoc-gen-grpc-java:${grpc.version}:exe:${os.detected.classifier}
  12.                 </pluginArtifact>
  13.                 <protocPlugins>
  14.                     <protocPlugin>
  15.                         <id>dubbo</id>
  16.                         <groupId>org.apache.dubbo</groupId>
  17.                         <artifactId>dubbo-compiler</artifactId>
  18.                         <version>${compiler.version}</version>
  19.                         <mainClass>org.apache.dubbo.gen.tri.reactive.ReactorDubbo3TripleGenerator</mainClass>
  20.                     </protocPlugin>
  21.                 </protocPlugins>
  22.             </configuration>
  23.             <executions>
  24.                 <execution>
  25.                     <goals>
  26.                         <goal>compile</goal>
  27.                     </goals>
  28.                 </execution>
  29.             </executions>
  30.         </plugin>
  31.     </plugins>
  32. </build>

编写并编译 IDL 文件

IDL 文件编写与原生的 Triple 协议完全一致，编译后默认会在 target/generated-sources/protobuf/java 目录下看到相应代码。

  1. syntax = "proto3";
  3. option java_multiple_files = true;
  5. package org.apache.dubbo.samples.triple.reactor;
  7. // The request message containing the user's name.
  8. message GreeterRequest {
  9.   string name = 1;
  10. }
  12. // The response message containing the greetings
  13. message GreeterReply {
  14.   string message = 1;
  15. }
  17. service GreeterService {
  19.   rpc greetOneToOne(GreeterRequest) returns (GreeterReply);
  21.   rpc greetOneToMany(GreeterRequest) returns (stream GreeterReply);
  23.   rpc greetManyToOne(stream GreeterRequest) returns (GreeterReply);
  25.   rpc greetManyToMany(stream GreeterRequest) returns (stream GreeterReply);
  26. }

使用示例

  1. 添加服务端接口实现
  1. package org.apache.dubbo.samples.triple.reactor.impl;
  3. import org.apache.dubbo.samples.triple.reactor.DubboGreeterServiceTriple;
  4. import org.apache.dubbo.samples.triple.reactor.GreeterReply;
  5. import org.apache.dubbo.samples.triple.reactor.GreeterRequest;
  6. import org.slf4j.Logger;
  7. import org.slf4j.LoggerFactory;
  8. import reactor.core.publisher.Flux;
  10. public class GreeterServiceImpl extends DubboGreeterServiceTriple.GreeterServiceImplBase {
  12.     private static final Logger LOGGER = LoggerFactory.getLogger(GreeterServiceImpl.class);
  14.     @Override
  15.     public Flux<GreeterReply> greetManyToMany(Flux<GreeterRequest> request) {
  16.         return request.doOnNext(req -> LOGGER.info("greetManyToMany get data: {}", req))
  17.                 .map(req -> GreeterReply.newBuilder().setMessage(req.getName() + " -> server get").build())
  18.                 .doOnNext(res -> LOGGER.info("greetManyToMany response data: {}", res));
  19.     }
  20. }
  1. 添加服务端接口启动类
  1. package org.apache.dubbo.samples.triple.reactor;
  3. import org.apache.dubbo.common.constants.CommonConstants;
  4. import org.apache.dubbo.config.ApplicationConfig;
  5. import org.apache.dubbo.config.ProtocolConfig;
  6. import org.apache.dubbo.config.RegistryConfig;
  7. import org.apache.dubbo.config.ServiceConfig;
  8. import org.apache.dubbo.config.bootstrap.DubboBootstrap;
  9. import org.apache.dubbo.samples.triple.reactor.impl.GreeterServiceImpl;
  11. public class ReactorServer {
  13.     private static final int PORT = 50052;
  15.     public static void main(String[] args) {
  16.         ServiceConfig<GreeterService> reactorService = new ServiceConfig<>();
  17.         reactorService.setInterface(GreeterService.class);
  18.         reactorService.setRef(new GreeterServiceImpl());
  20.         DubboBootstrap bootstrap = DubboBootstrap.getInstance();
  21.         bootstrap.application(new ApplicationConfig("tri-reactor-stub-server"))
  22.                 .registry(new RegistryConfig("zookeeper://127.0.0.1:2181"))
  23.                 .protocol(new ProtocolConfig(CommonConstants.TRIPLE, PORT))
  24.                 .service(reactorService)
  25.                 .start();
  26.     }
  27. }
  1. 添加客户端启动类和消费程序
  1. package org.apache.dubbo.samples.triple.reactor;
  3. import org.apache.dubbo.common.constants.CommonConstants;
  4. import org.apache.dubbo.config.ApplicationConfig;
  5. import org.apache.dubbo.config.ReferenceConfig;
  6. import org.apache.dubbo.config.RegistryConfig;
  7. import org.apache.dubbo.config.bootstrap.DubboBootstrap;
  8. import org.slf4j.Logger;
  9. import org.slf4j.LoggerFactory;
  10. import reactor.core.publisher.Flux;
  11. import reactor.core.publisher.Mono;
  13. import java.io.IOException;
  15. public class ReactorConsumer {
  17.     private static final Logger LOGGER = LoggerFactory.getLogger(ReactorConsumer.class);
  19.     private final GreeterService greeterService;
  21.     public ReactorConsumer() {
  22.         ReferenceConfig<GreeterService> referenceConfig = new ReferenceConfig<>();
  23.         referenceConfig.setInterface(GreeterService.class);
  24.         referenceConfig.setProtocol(CommonConstants.TRIPLE);
  25.         referenceConfig.setProxy(CommonConstants.NATIVE_STUB);
  26.         referenceConfig.setTimeout(10000);
  28.         DubboBootstrap bootstrap = DubboBootstrap.getInstance();
  29.         bootstrap.application(new ApplicationConfig("tri-reactor-stub-server"))
  30.                 .registry(new RegistryConfig("zookeeper://127.0.0.1:2181"))
  31.                 .reference(referenceConfig)
  32.                 .start();
  33.         GreeterService greeterService = referenceConfig.get();
  34.     }
  36.     public static void main(String[] args) throws IOException {
  37.         ReactorConsumer reactorConsumer = new ReactorConsumer();
  38.         reactorConsumer.consumeManyToMany();
  39.         System.in.read();
  40.     }
  42.     private void consumeManyToMany() {
  43.         greeterService.greetManyToMany(Flux.range(1, 10)
  44.                     .map(num ->
  45.                         GreeterRequest.newBuilder().setName(String.valueOf(num)).build())
  46.                     .doOnNext(req -> LOGGER.info("consumeManyToMany request data: {}", req)))
  47.                 .subscribe(res -> LOGGER.info("consumeManyToMany get response: {}", res));
  48.     }
  49. }

  1. 启动服务端

  2. 启动消费者端

最后修改 September 13, 2024: Refactor website structure (#2860) (1a4b998f54b)