小工具知识网

当前位置: 首页 > 行业知识 > 自定义Dubbo RPC通信协议

行业知识

自定义Dubbo RPC通信协议

2026-11-19 02:40:57 来源:互联网转载

前言

Dubbo 协议层的核心SPI接口是org.apache.dubbo.rpc.Protocol,通过扩展该接口和围绕的相关接口,就可以让 Dubbo 使用我们自定义的协议来通信。默认的协议是 dubbo,本文提供一个 Grpc 协议的实现。

()

设计思路

Google 提供了 Java 的 Grpc 实现,所以我们站在巨人的肩膀上即可,就不用重复造轮子了。

首先,我们要实现 Protocol 接口,服务暴露时开启我们的 GrpcServer,绑定本地端口,用于后续处理连接和请求。

()

服务端如何处理grpc请求呢???

方案一,是把暴露的所有服务 Invoker 都封装成grpc的 Service,全部统一让 GrpcServer 处理,但是这么做太麻烦了。方案二,是提供一个 DispatcherService,统一处理客户端发来的grpc请求,再根据参数查找要调用的服务,执行本地调用返回结果。本文采用方案二。

客户端引用服务时,我们创建 GrpcInvoker 对象,和服务端建立连接并生成 DispatcherService 的本地存根 Stub 对象,发起 RPC 调用时只需把 RpcInvocation 转换成 Protobuf 消息发出去即可。

实现GrpcProtocol

项目结构

首先,我们新建一个dubbo-extension-protocol-grpc模块,引入必要的依赖。

            org.apache.dubbo        dubbo-rpc-api        ${dubbo.version}                io.grpc        grpc-all        1.56.1    

项目结构:

main--java----dubbo.extension.rpc.grpc------message--------RequestData.java--------ResponseData.java------Codec.java------DispatcherService.java------DispatcherServiceGrpc.java------GrpcExporter.java------GrpcInvoker.java------GrpcProtocol.java------GrpcProtocolServer.java--resources----META-INF/dubbo------org.apache.dubbo.rpc.Protocol

服务&消息定义

然后是定义grpc的 Service 和消息格式

DispatcherService.proto 请求分发服务的定义

syntax = "proto3";option java_multiple_files = true;option java_package = "dubbo.extension.rpc.grpc";option java_outer_classname = "DispatcherServiceProto";option objc_class_prefix = "HLW";import "RequestData.proto";import "ResponseData.proto";service DispatcherService {  rpc dispatch (RequestData) returns (ResponseData) {}}

RequestData.proto 请求消息的定义,主要是对 Invocation 的描述

syntax = "proto3";option java_multiple_files = true;option java_package = "dubbo.extension.rpc.grpc.message";option java_outer_classname = "RequestDataProto";option objc_class_prefix = "HLW";message RequestData {  string targetServiceUniqueName = 1;  string methodName = 2;  string serviceName = 3;  repeated bytes parameterTypes = 4;  string parameterTypesDesc = 5;  repeated bytes arguments = 6;  bytes attachments = 7;}

ResponseData.proto 响应消息的定义,主要是对 AppResponse 的描述

syntax = "proto3";option java_multiple_files = true;option java_package = "dubbo.extension.rpc.grpc.message";option java_outer_classname = "ResponseataProto";option objc_class_prefix = "HLW";message ResponseData {  int32 status = 1;  string errorMessage = 2;  bytes result = 3;  bytes attachments = 4;}

使用protobuf-maven-plugin插件把 proto 文件生成对应的 Java 类。

协议实现

新建 GrpcProtocol 类,继承 AbstractProtocol,实现 Protocol 协议细节。

核心是:服务暴露时开启 Grpc 服务,引用服务时生成对应的 Invoker。

public class GrpcProtocol extends AbstractProtocol {    @Override    protected  Invoker protocolBindingRefer(Class type, URL url) throws RpcException {        return new GrpcInvoker(type, url);    }    @Override    public int getDefaultPort() {        return 18080;    }    @Override    public  Exporter export(Invoker invoker) throws RpcException {        GrpcExporter exporter = new GrpcExporter(invoker);        exporterMap.put(invoker.getInterface().getName(), exporter);        openServer(invoker.getUrl());        return exporter;    }    private void openServer(URL url) {        String key = serviceKey(url);        ProtocolServer protocolServer = serverMap.get(key);        if (protocolServer == null) {            synchronized (serverMap) {                protocolServer = serverMap.get(key);                if (protocolServer == null) {                    serverMap.put(key, createServer(url));                }            }        }    }    private ProtocolServer createServer(URL url) {        return new GrpcProtocolServer(url, exporterMap);    }}

新建 GrpcProtocolServer 类实现 ProtocolServer 接口,核心是启动 GrpcServer,并添加 DispatcherService 处理请求。

public class GrpcProtocolServer implements ProtocolServer {    private final Server server;    public GrpcProtocolServer(URL url, Map> exporterMap) {        this.exporterMap = exporterMap;    }    @Override    public void dispatch(RequestData request, StreamObserver responseObserver) {        RpcInvocation invocation = Codec.decodeInvocation(request);        ResponseData responseData;        try {            Invoker invoker = exporterMap.get(invocation.getServiceName()).getInvoker();            Object returnValue = invoker.invoke(invocation).get().getValue();            responseData = Codec.encodeResponse(returnValue, null);        } catch (Exception e) {            responseData = Codec.encodeResponse(null, e);        }        responseObserver.onNext(responseData);        responseObserver.onCompleted();    }}

新建 GrpcInvoker 类实现 Invoker 接口,服务引用时会创建它,目的是发起 RPC 调用时通过 Stub 发一个请求到 DispatcherService,实现grpc协议的 RPC 调用。

public class GrpcInvoker extends AbstractInvoker {    private static final Map STUB_MAP = new ConcurrentHashMap();    public GrpcInvoker(Class type, URL url) {        super(type, url);    }    private DispatcherServiceGrpc.DispatcherServiceFutureStub getStub() {        String key = getUrl().getAddress();        DispatcherServiceGrpc.DispatcherServiceFutureStub stub = STUB_MAP.get(key);        if (stub == null) {            synchronized (STUB_MAP) {                stub = STUB_MAP.get(key);                if (stub == null) {                    STUB_MAP.put(key, stub = createClient(getUrl()));                }            }        }        return stub;    }    private DispatcherServiceGrpc.DispatcherServiceFutureStub createClient(URL url) {        ManagedChannel channel = ManagedChannelBuilder.forAddress(url.getHost(), url.getPort()).usePlaintext().build();        return DispatcherServiceGrpc.newFutureStub(channel);    }    @Override    protected Result doInvoke(Invocation invocation) throws Throwable {        RequestData requestData = Codec.encodeInvocation((RpcInvocation) invocation);        ResponseData responseData = getStub().dispatch(requestData).get();        return Codec.decodeResponse(responseData, invocation);    }}

最后是编解码器 Codec,它的作用是对 RequestData、ResponseData 对象的编解码。对于请求来说,要编解码的是 RpcInvocation;对于响应来说,要编解码的是返回值和异常信息。

方法实参是 Object[] 类型,附带参数是 Map 类型,本身不能直接通过 Protobuf 传输,我们会先利用 Serialization 序列化成字节数组后再传输。

public class Codec {    private static final Serialization serialization = ExtensionLoader.getExtensionLoader(Serialization.class).getDefaultExtension();    public static RequestData encodeInvocation(RpcInvocation invocation) {        RequestData.Builder builder = RequestData.newBuilder()                .setTargetServiceUniqueName(invocation.getTargetServiceUniqueName())                .setMethodName(invocation.getMethodName())                .setServiceName(invocation.getServiceName());        for (Class parameterType : invocation.getParameterTypes()) {            builder.addParameterTypes(serialize(parameterType));        }        builder.setParameterTypesDesc(invocation.getParameterTypesDesc());        for (Object argument : invocation.getArguments()) {            builder.addArguments(serialize(argument));        }        builder.setAttachments(serialize(invocation.getAttachments()));        return builder.build();    }    public static RpcInvocation decodeInvocation(RequestData requestData) {        RpcInvocation invocation = new RpcInvocation();        invocation.setTargetServiceUniqueName(requestData.getTargetServiceUniqueName());        invocation.setMethodName(requestData.getMethodName());        invocation.setServiceName(requestData.getServiceName());        List parameterTypesList = requestData.getParameterTypesList();        Class[] parameterTypes = new Class[parameterTypesList.size()];        for (int i = 0; i  

实现完毕,最后是让 Dubbo 可以加载到我们自定义的 GrpcProtocol,可以通过 SPI 的方式。新建META-INF/dubbo/org.apache.dubbo.rpc.Protocol文件,内容:

grpc=dubbo.extension.rpc.grpc.GrpcProtocol

服务提供方使用自定义协议:

ProtocolConfig protocolConfig = new ProtocolConfig("grpc", 10880);

消费方使用自定义协议:

ReferenceConfig#setUrl("grpc://127.0.0.1:10880");

尾巴

Protocol 层关心的是如何暴露服务和引用服务,以及如何让双方使用某个具体的协议来通信,以完成 RPC 调用。如果你觉得官方提供的 dubbo 协议无法满足你的业务,就可以通过扩展 Protocol 接口来实现你自己的私有协议。

上一篇:$modal定义详解与实战使用指南

下一篇:如何新装硬盘?