本文总体上可分为根本产品简介、Dubbo 对 gRPC (HTTP/2) 和 Protobuf 的支持及示例演示三部分，在简介部分先容了 Dubbo、HTTP/2、gRPC、Protobuf 的基本观点和特点；第二部分先容了 Dubbo 为何要支持 gRPC (HTTP/2) 和 Protobuf，以及这种支持为 gRPC 和 Dubbo 开拓带来的好处与不同；第三部分通过两个实例分别演示了 Dubbo gRPC 和 Dubbo Protobuf 的利用办法。
基本先容
Dubbo 协议
从协议层面展开，以下是当前 2.7 版本支持的 Dubbo 协议
众所周知，Dubbo 协议是直接定义在 TCP 传输层协议之上，由于 TCP 高可靠全双工的特点，为 Dubbo 协议的定义供应了最大的灵巧性，但同时也正是由于这样的灵巧性，RPC 协议普遍都是定制化的私有协议，Dubbo 同样也面临这个问题。在这里我们着重讲一下 Dubbo 在协议通用性方面值得改进的地方，关于协议详细解析请拜会官网博客
Dubbo 协议体 Body 中有一个可扩展的 attachments 部分，这给 RPC 方法之外额外传递附加属性供应了可能，是一个很好的设计。但是类似的 Header 部分，却短缺类似的可扩展 attachments，这点可参考 HTTP 定义的 Ascii Header 设计，将 Body Attachments 和 Header Attachments 做职责划分。Body 协议体中的一些 RPC 要求定位符如 Service Name、Method Name、Version 等，可以提到 Header 中，和详细的序列化协议解耦，以更好的被网络根本举动步伐识别或用于流量管控。扩展性不足好，欠缺协议升级方面的设计，如 Header 头中没有预留的状态标识位，或者像 HTTP 有专为协议升级或协商设计的分外 packet。在 Java 版本的代码实现上，不足精简和通用。如在链路传输中，存在一些措辞绑定的内容；体中存在冗余内容，如 Service Name 在 Body 和 Attachments 中都存在。HTTP/1
比较于直接构建与 TPC 传输层的私有 RPC 协议，构建于 HTTP 之上的远程调用办理方案会有更好的通用性，如WebServices 或 REST 架构，利用 HTTP + JSON 可以说是一个事实标准的办理方案。
之所有选择构建在 HTTP 之上，我认为有两个最大的上风：
HTTP 的语义和可扩展性能很好的知足 RPC 调用需求。通用性，HTTP 协议险些被网络上的所有设备所支持，具有很好的协议穿透性。详细来说，HTTP/1 的上风和限定是：
范例的 Request – Response 模型，一个链路上一次只能有一个等待的 Request 要求HTTP/1 支持 Keep-Alive 链接，避免了链接重复创建开销Human Readable Headers，利用更通用、更易于人类阅读的头部传输格式无直接 Server Push 支持，须要利用 Polling Long-Polling 等变通模式HTTP/2
HTTP/2 保留了 HTTP/1 的所有语义，在保持兼容的同时，在通信模型和传输效率上做了很大的改进。
支持单条链路上的 Multiplexing，比较于 Request - Response 独占链路，基于 Frame 实现更高效利用链路Request - Stream 语义，原生支持 Server Push 和 Stream 数据传输Flow Control，单条 Stream 粒度的和全体链路粒度的流量掌握头部压缩 HPACKBinary Frame原生 TLS 支持
gRPC
上面提到了在 HTTP 及 TCP 协议之上构建 RPC 协议各自的优缺陷，比较于 Dubbo 构建于 TPC 传输层之上，Google 选择将 gRPC 直接定义在 HTTP/2 协议之上，关于 gRPC 的 基本先容和 设计愿景 请参考以上两篇文章，我这里仅摘取 设计愿景 中几个能反响 gRPC 设计目的特性来做大略解释。
Coverage & Simplicity，协议设计和框架实现要足够通用和大略，能运行在任何设备之上，乃至一些资源首先的如 IoT、Mobile 等设备。Interoperability & Reach，要构建在更通用的协议之上，协议本身要能被网络上险些所有的根本举动步伐所支持。General Purpose & Performant，要在场景和性能间做好平衡，首先协议本身假如适用于各种场景的，同时也要只管即便有高的性能。Payload Agnostic，协议上传输的负载要保持措辞和平台中立。Streaming，要支持 Request - Response、Request - Stream、Bi-Steam 等通信模型。Flow Control，协议自身具备流量感知和限定的能力。Metadata Exchange，在 RPC 做事定义之外，供应额外附加数据传输的能力。总的来说，在这样的设计理念辅导下，gRPC 终极被设计为一个跨措辞、跨平台的、通用的、高性能的、基于 HTTP/2 的 RPC 协议和框架。
Protobuf
Protocol buffers (Protobuf) 是 Google 推出的一个跨平台、措辞中立的构造化数据描述和序列化的产品，它定义了一套构造化数据定义的协议，同时也供应了相应的 Compiler 工具，用来将措辞中立的描述转化为相应措辞的详细描述。
它的一些特性包括：
跨措辞 跨平台，措辞中立的数据描述格式，默认供应了天生多种措辞的 Compiler 工具。安全性，由于反序列化的范围和输出内容格式都是 Compiler 在编译时预天生的，因此绕过了类似 Java Deserialization Vulnarability 的问题。二进制 高性能强类型字段变更向后兼容message Person { required string name = 1; required int32 id = 2; optional string email = 3; enum PhoneType { MOBILE = 0; HOME = 1; WORK = 2; } message PhoneNumber { required string number = 1; optional PhoneType type = 2 [default = HOME]; } repeated PhoneNumber phone = 4; }
除了却构化数据描述之外，Protobuf 还支持定义 RPC 做事，它许可我们定义一个 .proto 的做事描述文件，进而利用 Protobuf Compiler 工具天生特定措辞和 RPC 框架的接口和 stub。后续将要详细讲到的 gRPC + Protobuf、Dubbo-gRPC + Protobuf 以及 Dubbo + Protobuf 都是通过定制 Compiler 类实现的。
service SearchService { rpc Search (SearchRequest) returns (SearchResponse);}
Dubbo 所做的支持
跨措辞的做事开拓涉及到多个方面，从做事定义、RPC 协议到序列化协议都要做到措辞中立，同时还针对每种措辞有对应的 SDK 实现。虽然得益于社区的贡献，现在 Dubbo 在多措辞 SDK 实现上逐步有了转机，已经供应了包括 Java, Go, PHP, C#, Python, NodeJs, C 等版本的客户端或全量实现版本，但在以上提到的跨措辞友好型方面，以上三点还是有很多可改进之处。
协议，上面我们已经剖析过 Dubbo 协议既有的缺陷，如果能在 HTTP/2 之上构建运用层协议，则无疑能避免这些弊端，同时最大可能的提高协议的穿透性，避免网关等协议转换组件的存在，更有利于链路上的流量管控。考虑到 gRPC 是构建在 HTTP/2 之上，并且已经是云原生领域推举的通信协议，Dubbo 在第一阶段选择了直接支持 gRPC 协议作为当前的 HTTP/2 办理方案。我们也知道 gRPC 框架自身的弊端在于易用性不敷以及做事管理能力欠缺（这也是目前绝大多数厂商不会直接裸用 gRPC 框架的缘故原由），通过将其集成进 Dubbo 框架，用户可以方便的利用 Dubbo 编程模型 + Dubbo 做事管理 + gRPC 协议通信的组合。做事定义，当前 Dubbo 的做事定义和详细的编程措辞绑定，没有供应一种措辞中立的做事描述格式，比如 Java 便是定义 Interface 接口，到了其他措辞又得重新以其余的格式定义一遍。因此 Dubbo 通过支持 Protobuf 实现了措辞中立的做事定义。序列化，Dubbo 当前支持的序列化包括 Json、Hessian2、Kryo、FST、Java 等，而这个中支持跨措辞的只有 Json、Hessian2，通用的 Json 有固有的性能问题，而 Hessian2 无论在效率还是多措辞 SDK 方面都有所欠缺。为此，Dubbo 通过支持 Protobuf 序列化来供应更高效、易用的跨措辞序列化方案。示例
示例 1，利用 Dubbo 开拓 gRPC 做事
gRPC 是 Google 开源的构建在 HTTP/2 之上的一个 PRC 通信协议。Dubbo 依赖其灵巧的协议扩展机制，增加了对 gRPC (HTTP/2) 协议的支持。
目前的支持限定在 Dubbo Java 措辞版本，后续 Go 措辞或其他措辞版本将会以类似办法供应支持。下面，通过一个大略的示例来演示如何在 Dubbo 中利用 gRPC 协议通信。
1. 定义做事 IDL
首先，通过标准的 Protobuf 协议定义做事如下：
syntax = "proto3"; option java_multiple_files = true; option java_package = "io.grpc.examples.helloworld"; option java_outer_classname = "HelloWorldProto"; option objc_class_prefix = "HLW"; package helloworld; // The greeting service definition. service Greeter { // Sends a greeting rpc SayHello (HelloRequest) returns (HelloReply) {} } // The request message containing the user's name. message HelloRequest { string name = 1; } // The response message containing the greetings message HelloReply { string message = 1; }
在此，我们定义了一个只有一个方法 sayHello 的 Greeter 做事，同时定义了方法的入参和出参，
2. Protobuf Compiler 天生 Stub
定义 Maven Protobuf Compiler 插件工具。这里我们扩展了 Protobuf 的 Compiler 工具，以用来天生 Dubbo 特有的 RPC stub，此当前以 Maven 插件的形式发布。<plugin> <groupId>org.xolstice.maven.plugins</groupId> <artifactId>protobuf-maven-plugin</artifactId> <version>0.5.1</version> <configuration> <protocArtifact>com.google.protobuf:protoc:3.7.1:exe:${os.detected.classifier} </protocArtifact> <pluginId>dubbo-grpc-java</pluginId> <pluginArtifact>org.apache.dubbo:protoc-gen-dubbo-java:1.19.0-SNAPSHOT:exe:${os.detected.classifier}</pluginArtifact> <outputDirectory>build/generated/source/proto/main/java</outputDirectory> <clearOutputDirectory>false</clearOutputDirectory> <pluginParameter>grpc</pluginParameter> </configuration> <executions> <execution> <goals> <goal>compile</goal> <goal>compile-custom</goal> </goals> </execution> </executions></plugin>
个中，
pluginArtifact 指定了 Dubbo 定制版本的 Java Protobuf Compiler 插件，通过这个插件来在编译过程中天生 Dubbo 定制版本的 gRPC stub。
<pluginArtifact>org.apache.dubbo:protoc-gen-dubbo-java:1.19.0-SNAPSHOT:exe:${os.detected.classifier}</pluginArtifact>
由于 protoc-gen-dubbo-java 支持 gRPC 和 Dubbo 两种协议，可天生的 stub 类型，默认值是 gRPC，关于 dubbo 协议的利用可拜会 利用 Protobuf 开拓 Dubbo 做事。
<pluginParameter>grpc</pluginParameter>
2. 天生 Java Bean 和 Dubbo-gRPC stub
# 运行以下 maven 命令$ mvn clean compile
天生的 Stub 和类 如下：
重点关注 GreeterGrpc ，包含了所有 gRPC 标准的 stub 类/方法，同时增加了 Dubbo 特定的接口，之后 Provider 真个做事暴露和 Consumer 真个做事调用都将依赖这个接口。
/ Code generated for Dubbo/public interface IGreeter { default public io.grpc.examples.helloworld.HelloReply sayHello(io.grpc.examples.helloworld.HelloRequest request) { throw new UnsupportedOperationException("No need to override this method, extend XxxImplBase and override all methods it allows."); } default public com.google.common.util.concurrent.ListenableFuture<io.grpc.examples.helloworld.HelloReply> sayHelloAsync( io.grpc.examples.helloworld.HelloRequest request) { throw new UnsupportedOperationException("No need to override this method, extend XxxImplBase and override all methods it allows."); } public void sayHello(io.grpc.examples.helloworld.HelloRequest request, io.grpc.stub.StreamObserver<io.grpc.examples.helloworld.HelloReply> responseObserver);}
3. 业务逻辑开拓
继续 GreeterGrpc.GreeterImplBase （来自第 2 步），编写业务逻辑，这点和原生 gRPC 是同等的。
package org.apache.dubbo.samples.basic.impl;import io.grpc.examples.helloworld.GreeterGrpc;import io.grpc.examples.helloworld.HelloReply;import io.grpc.examples.helloworld.HelloRequest;import io.grpc.stub.StreamObserver;public class GrpcGreeterImpl extends GreeterGrpc.GreeterImplBase { @Override public void sayHello(HelloRequest request, StreamObserver<HelloReply> responseObserver) { System.out.println("Received request from client."); System.out.println("Executing thread is " + Thread.currentThread().getName()); HelloReply reply = HelloReply.newBuilder() .setMessage("Hello " + request.getName()).build(); responseObserver.onNext(reply); responseObserver.onCompleted(); }}Provider 端暴露 Dubbo 做事
以 Spring XML 为例
<dubbo:application name="demo-provider"/><!-- 指定做事暴露协议为 gRPC --><dubbo:protocol id="grpc" name="grpc"/><dubbo:registry address="zookeeper://${zookeeper.address:127.0.0.1}:2181"/><bean id="greeter" class="org.apache.dubbo.samples.basic.impl.GrpcGreeterImpl"/><!-- 指定 protoc-gen-dubbo-java 天生的接口 --><dubbo:service interface="io.grpc.examples.helloworld.GreeterGrpc$IGreeter" ref="greeter" protocol="grpc"/>
public static void main(String[] args) throws Exception { ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring/dubbo-demo-provider.xml"); context.start(); System.out.println("dubbo service started"); new CountDownLatch(1).await();}引用 Dubbo 做事
<dubbo:application name="demo-consumer"/><dubbo:registry address="zookeeper://${zookeeper.address:127.0.0.1}:2181"/><!-- 指定 protoc-gen-dubbo-java 天生的接口 --><dubbo:reference id="greeter" interface="io.grpc.examples.helloworld.GreeterGrpc$IGreeter" protocol="grpc"/>
public static void main(String[] args) throws IOException { ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring/dubbo-demo-consumer.xml"); context.start(); GreeterGrpc.IGreeter greeter = (GreeterGrpc.IGreeter) context.getBean("greeter"); HelloReply reply = greeter.sayHello(HelloRequest.newBuilder().setName("world!").build()); System.out.println("Result: " + reply.getMessage()); System.in.read();}
示例1附：高等用法
一、异步调用
再来看一遍 protoc-gen-dubbo-java 天生的接口：
/ Code generated for Dubbo/public interface IGreeter { default public HelloReply sayHello(HelloRequest request) { // ...... } default public ListenableFuture<HelloReply> sayHelloAsync(HelloRequest request) { // ...... } public void sayHello(HelloRequest request, StreamObserver<HelloReply> responseObserver);}
这里为 sayHello 方法天生了三种类型的重载方法，分别用于同步调用、异步调用和流式调用，如果消费端要进行异步调用，直接调用 sayHelloAsync() 即可：
public static void main(String[] args) throws IOException { // ... GreeterGrpc.IGreeter greeter = (GreeterGrpc.IGreeter) context.getBean("greeter"); ListenableFuture<HelloReply> future = greeter.sayHAsyncello(HelloRequest.newBuilder().setName("world!").build()); // ...}
二、高等配置
由于当前实现办法是直接集成了 gRPC-java SDK，因此很多配置还没有和 Dubbo 侧对齐，或者还没有以 Dubbo 的配置形式开放，因此，为了供应最大的灵巧性，我们直接把 gRPC-java 的配置接口暴露了出来。
绝大多数场景下，你可能并不会用到以下扩展，由于它们更多的是对 gRPC 协议的拦截或者 HTTP/2 层面的配置。同时利用这些扩展点可能须要对 HTTP/2 或 gRPC 有基本的理解。
扩展点
目前支持的扩展点如下：
org.apache.dubbo.rpc.protocol.grpc.interceptors.ClientInterceptororg.apache.dubbo.rpc.protocol.grpc.interceptors.GrpcConfiguratororg.apache.dubbo.rpc.protocol.grpc.interceptors.ServerInterceptororg.apache.dubbo.rpc.protocol.grpc.interceptors.ServerTransportFilterGrpcConfigurator 是最通用的扩展点，我们以此为例来解释一下，其基本定义如下：
public interface GrpcConfigurator { // 用来定制 gRPC NettyServerBuilder default NettyServerBuilder configureServerBuilder(NettyServerBuilder builder, URL url) { return builder; } // 用来定制 gRPC NettyChannelBuilder default NettyChannelBuilder configureChannelBuilder(NettyChannelBuilder builder, URL url) { return builder; } // 用来定制 gRPC CallOptions, 定义某个做事在每次要求间通报数据 default CallOptions configureCallOptions(CallOptions options, URL url) { return options; }}
以下是一个示例扩展实现：
public class MyGrpcConfigurator implements GrpcConfigurator { private final ExecutorService executor = Executors .newFixedThreadPool(200, new NamedThreadFactory("Customized-grpc", true)); @Override public NettyServerBuilder configureServerBuilder(NettyServerBuilder builder, URL url) { return builder.executor(executor); } @Override public NettyChannelBuilder configureChannelBuilder(NettyChannelBuilder builder, URL url) { return builder.flowControlWindow(10); } @Override public CallOptions configureCallOptions(CallOptions options, URL url) { return options.withOption(CallOptions.Key.create("key"), "value"); }}
配置为 Dubbo SPI，`resources/META-INF/services 增加配置文件
default=org.apache.dubbo.samples.basic.comtomize.MyGrpcConfigurator指定 Provider 端线程池默认用的是 Dubbo 的线程池，有 fixed (默认)、cached、direct 等类型。以下演示了切换为业务自定义线程池。
private final ExecutorService executor = Executors .newFixedThreadPool(200, new NamedThreadFactory("Customized-grpc", true));public NettyServerBuilder configureServerBuilder(NettyServerBuilder builder, URL url) { return builder.executor(executor);}指定 Consumer 端限流值设置 Consumer 限流值为 10
@Overridepublic NettyChannelBuilder configureChannelBuilder(NettyChannelBuilder builder, URL url){ return builder.flowControlWindow(10);}通报附加参数DemoService 做事调用通报 key
@Overridepublic CallOptions configureCallOptions(CallOptions options, URL url) { if (url.getServiceInterface().equals("xxx.DemoService")) { return options.withOption(CallOptions.Key.create("key"), "value"); } else { return options; }}
三、双向流式通信代码中还供应了一个支持双向流式通信的示例，同时供应了拦截流式调用的 Interceptor 扩展示例实现。
MyClientStreamInterceptor，事情在 client 端，拦截发出的要求流和吸收的相应流 MyServerStreamInterceptor，事情在 server 端，拦截收到的要求流和发出的相应流
四、TLS 配置
配置办法和 Dubbo 供应的通用的 TLS 支持同等，详细请拜会 Dubbo 官方文档
示例 2， 利用 Protobuf 开拓 Dubbo 做事
下面，我们以一个详细的示例来看一下基于 Protobuf 的 Dubbo 做事开拓流程。
1. 定义做事
通过标准 Protobuf 定义做事
syntax = "proto3"; option java_multiple_files = true; option java_package = "org.apache.dubbo.demo"; option java_outer_classname = "DemoServiceProto"; option objc_class_prefix = "DEMOSRV"; package demoservice; // The demo service definition. service DemoService { rpc SayHello (HelloRequest) returns (HelloReply) {} } // The request message containing the user's name. message HelloRequest { string name = 1; } // The response message containing the greetings message HelloReply { string message = 1; }
这里定义了一个 DemoService 做事，做事只包含一个 sayHello 方法，同时定义了方法的入参和出参。
2. Compiler 编译做事
引入 Protobuf Compiler Maven 插件，同时指定 protoc-gen-dubbo-java RPC 扩展<plugin> <groupId>org.xolstice.maven.plugins</groupId> <artifactId>protobuf-maven-plugin</artifactId> <version>0.5.1</version> <configuration> <protocArtifact>com.google.protobuf:protoc:3.7.1:exe:${os.detected.classifier} </protocArtifact> <pluginId>dubbo-grpc-java</pluginId> <pluginArtifact>org.apache.dubbo:protoc-gen-dubbo-java:1.19.0-SNAPSHOT:exe:${os.detected.classifier}</pluginArtifact> <outputDirectory>build/generated/source/proto/main/java</outputDirectory> <clearOutputDirectory>false</clearOutputDirectory> <pluginParameter>dubbo</pluginParameter> </configuration> <executions> <execution> <goals> <goal>compile</goal> <goal>compile-custom</goal> </goals> </execution> </executions></plugin>
把稳，这里与 Dubbo 对 gRPC 支持部分的差异在于： dubbo
天生 RPC stub# 运行以下 maven 命令$mvn clean compile
天生的 Java 类如下：
DemoServiceDubbo 为 Dubbo 定制的 stub
public final class DemoServiceDubbo { private static final AtomicBoolean registered = new AtomicBoolean(); private static Class<?> init() { Class<?> clazz = null; try { clazz = Class.forName(DemoServiceDubbo.class.getName()); if (registered.compareAndSet(false, true)) { org.apache.dubbo.common.serialize.protobuf.support.ProtobufUtils.marshaller( org.apache.dubbo.demo.HelloRequest.getDefaultInstance()); org.apache.dubbo.common.serialize.protobuf.support.ProtobufUtils.marshaller( org.apache.dubbo.demo.HelloReply.getDefaultInstance()); } } catch (ClassNotFoundException e) { // ignore } return clazz; } private DemoServiceDubbo() {} public static final String SERVICE_NAME = "demoservice.DemoService"; / Code generated for Dubbo / public interface IDemoService { static Class<?> clazz = init(); org.apache.dubbo.demo.HelloReply sayHello(org.apache.dubbo.demo.HelloRequest request); java.util.concurrent.CompletableFuture<org.apache.dubbo.demo.HelloReply> sayHelloAsync( org.apache.dubbo.demo.HelloRequest request); }}
最值得把稳的是 IDemoService 接口，它会作为 Dubbo 做事定义根本接口。
3. 开拓业务逻辑
从这一步开始，所有开拓流程就和直接定义 Java 接口一样了。实现接口定义业务逻辑。
public class DemoServiceImpl implements DemoServiceDubbo.IDemoService { private static final Logger logger = LoggerFactory.getLogger(DemoServiceImpl.class); @Override public HelloReply sayHello(HelloRequest request) { logger.info("Hello " + request.getName() + ", request from consumer: " + RpcContext.getContext().getRemoteAddress()); return HelloReply.newBuilder() .setMessage("Hello " + request.getName() + ", response from provider: " + RpcContext.getContext().getLocalAddress()) .build(); } @Override public CompletableFuture<HelloReply> sayHelloAsync(HelloRequest request) { return CompletableFuture.completedFuture(sayHello(request)); }}
4. 配置 Provider
暴露 Dubbo 做事
<dubbo:application name="demo-provider"/><dubbo:registry address="zookeeper://127.0.0.1:2181"/><dubbo:protocol name="dubbo"/><bean id="demoService" class="org.apache.dubbo.demo.provider.DemoServiceImpl"/><dubbo:service interface="org.apache.dubbo.demo.DemoServiceDubbo$IDemoService" ref="demoService"/>
public static void main(String[] args) throws Exception { ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring/dubbo-provider.xml"); context.start(); System.in.read();}
5. 配置 Consumer
引用 Dubbo 做事
<dubbo:application name="demo-consumer"/><dubbo:registry address="zookeeper://127.0.0.1:2181"/><dubbo:reference id="demoService" check="false" interface="org.apache.dubbo.demo.DemoServiceDubbo$IDemoService"/>
public static void main(String[] args) throws Exception { ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring/dubbo-consumer.xml"); context.start(); IDemoService demoService = context.getBean("demoService", IDemoService.class); HelloRequest request = HelloRequest.newBuilder().setName("Hello").build(); HelloReply reply = demoService.sayHello(request); System.out.println("result: " + reply.getMessage()); System.in.read();}
展望
RPC 协议是实现微做事体系互通的核心组件，常日采取不同的微做事通信框架则意味着绑定某一个特定的协议，如 Spring Cloud 基于 HTTP、gRPC 供应 gRPC over HTTP/2、Thrift Hessian 等都是自定义私有协议。
Dubbo 自身同样供应了私有的 Dubbo 协议，这样你也能基于 Dubbo 协议构建微做事。但除了单一协议之外，和以上所有框架不同的，Dubbo 最大的上风在于它能同时支持多协议的暴露和消费，再合营 Dubbo 多注册订阅的模型，可以让 Dubbo 成为桥接多种不同协议的微做事体系的开拓框架，轻松的实现不同微做事体系的互调互通或技能栈迁移。
这篇文章详细讲解了 Dubbo 对 gRPC 协议的支持，再加上 Dubbo 之前已具备的对 REST、Hessian、Thrift 等的支持，使 Dubbo 在协议互调上具备了根本。我们只须要在做事创造模型上也能实现和这些不同体系的打通，就能办理不同技能栈互调和迁移的问题。关于这部分的详细运用处景以及事情模式，我们将在接下来的文章中来详细剖析。
作者信息：刘军，Github账号Chickenlj，Apache Dubbo PMC，项目核心掩护者，见证了Dubbo从重启开源到Apache毕业的全体流程。现任职阿里巴巴中间件团队，参与做事框架、微做事干系事情，目前紧张在推动Dubbo开源的云原生化。
本文为云栖社区内容，未经许可不得转载。
