ProtobufRpcEngine目前是作为 Hadoop RPC 引擎唯一的实现方式；WritableRpcEngine在 3.2.1 版本已经标识为废弃，但依旧是默认实现的 RPC 引擎

和 WritableRpcEngine 相比，ProtobufRpcEngine 的使用要麻烦的多，主要是在接口的定义和实现的写法上有区别

定义协议

定义Proto协议

根据 Protocol 的语法，定义一个服务MetaInfo，通过该服务的getMetaInfo接口，可以获取到元数据的信息

  1. /**
  2.  * 生成java代码指令
  3.  * protoc --java_out=. CustomProtocol.proto
  4.  *
  5.  */
  7. option java_package = "org.apache.hadoop.rpc.protobuf";
  8. option java_outer_classname = "CustomProtos";
  9. option java_generic_services = true;
  10. option java_generate_equals_and_hash = true;
  12. package hadoop.common;
  14. service MetaInfo {
  15.       rpc getMetaInfo(GetMetaInfoRequestProto) returns (GetMetaInfoResponseProto);
  16. }
  18. message GetMetaInfoRequestProto {
  19.       required string path = 1;
  20. }
  22. message GetMetaInfoResponseProto {
  23.       required string info = 1;
  24. }

[

](https://blog.csdn.net/zhanglong_4444/article/details/105630023)

根据定义好的proto协议生成java类，导入项目

将定义好的协议保存成文件，命名为 CustomProtocol.proto 。在该文件的目录下执行命令

  1. MacBook-Pro:proto sysadmin$ ls -l
  2. total 8
  3. -rw-r--r--@ 1 sysadmin  staff  526  4 20 09:56 CustomProtocol.proto
  4. MacBook-Pro:proto sysadmin$
  5. MacBook-Pro:proto sysadmin$
  6. MacBook-Pro:proto sysadmin$ protoc --java_out=. CustomProtocol.proto
  7. MacBook-Pro:proto sysadmin$
  8. MacBook-Pro:proto sysadmin$
  9. MacBook-Pro:proto sysadmin$ ls -l
  10. total 8
  11. -rw-r--r--@ 1 sysadmin  staff  526  4 20 09:56 CustomProtocol.proto
  12. drwxr-xr-x  3 sysadmin  staff   96  4 20 11:53 org
  13. MacBook-Pro:proto sysadmin$
  14. MacBook-Pro:proto sysadmin$
  15. MacBook-Pro:proto sysadmin$
  16. MacBook-Pro:proto sysadmin$ cd org/apache/hadoop/rpc/protobuf
  17. MacBook-Pro:protobuf sysadmin$
  18. MacBook-Pro:protobuf sysadmin$ ls -l
  19. total 104
  20. -rw-r--r--  1 sysadmin  staff  49880  4 20 11:53 CustomProtos.java
  21. MacBook-Pro:protobuf sysadmin$
  22. MacBook-Pro:protobuf sysadmin$

这时在该目录下，会有一个文件目录生成，层级为我们定义好的org.apache.hadoop.rpc.protobuf路径，将里面生成的 java 文件 CustomProtos.java 导入到项目中，存放路径与定义好的路径一样
image.png

根据定义好的proto协议定义接口

创建一个接口，集成生成JAVA类中的CustomProtos.MetaInfo.BlockingInterface接口

  1.     // 接口信息供server和client端使用
  2.     @ProtocolInfo(
  3.         protocolName = "org.apache.hadoop.rpc.CustomProtos$MetaInfoProtocol",
  4.         protocolVersion = 1)
  5.     public interface MetaInfoProtocol
  6.         extends CustomProtos.MetaInfo.BlockingInterface {
  7.     }

实现接口协议

创建一个类，实现刚刚定义好的MetaInfoProtocol接口，并且实现里面的方法。这个需要自己去写代码逻辑。注意返回值和返回对象的写法不太一样

  1.  // 实现类
  2. public static class MetaInfoServer implements MetaInfoProtocol {
  4.     @Override
  5.     public CustomProtos.GetMetaInfoResponseProto getMetaInfo(RpcController controller,
  6.         CustomProtos.GetMetaInfoRequestProto request) throws
  7.         ServiceException {
  9.         //获取请求参数
  10.         final String path = request.getPath();
  12.         return CustomProtos.GetMetaInfoResponseProto.newBuilder().setInfo(path + ":3 - {BLOCK_1,BLOCK_2,BLOCK_3....").build();
  13.     }
  14. }

创建Server服务，注册协议，并启动RPC服务

  1. public static void main(String[] args) throws  Exception{
  4.     //1. 构建配置对象
  5.     Configuration conf = new Configuration();
  7.     //2. 协议对象的实例
  8.     MetaInfoServer serverImpl =  new MetaInfoServer();
  9.     BlockingService blockingService =
  10.         CustomProtos.MetaInfo.newReflectiveBlockingService(serverImpl);
  12.     //3. 设置协议的RpcEngine为ProtobufRpcEngine
  13.     RPC.setProtocolEngine(conf, MetaInfoProtocol.class,
  14.                           ProtobufRpcEngine.class);
  16.     //4. 构建RPC框架
  17.     RPC.Builder builder = new RPC.Builder(conf);
  18.     //5. 绑定地址
  19.     builder.setBindAddress("localhost");
  20.     //6. 绑定端口
  21.     builder.setPort(7777);
  22.     //7. 绑定协议
  23.     builder.setProtocol(MetaInfoProtocol.class);
  24.     //8. 调用协议实现类
  25.     builder.setInstance(blockingService);
  26.     //9. 创建服务
  27.     RPC.Server server = builder.build();
  28.     //10. 启动服务
  29.     server.start();
  31. }

创建Client服务，请求数据接口

  1. public static void main(String[] args) throws Exception {
  3.     //1. 构建配置对象
  4.     Configuration conf = new Configuration();
  6.     //2. 设置协议的RpcEngine为ProtobufRpcEngine
  7.     RPC.setProtocolEngine(conf, Server.MetaInfoProtocol.class,
  8.                           ProtobufRpcEngine.class);
  11.     //3. 拿到RPC协议
  12.     Server.MetaInfoProtocol proxy = RPC.getProxy(Server.MetaInfoProtocol.class, 1L,
  13.                                     new InetSocketAddress("localhost", 7777), conf);
  15.     //4. 发送请求
  16.     CustomProtos.GetMetaInfoRequestProto obj = 
  17.         CustomProtos.GetMetaInfoRequestProto.newBuilder().setPath("/meta").build();
  19.     CustomProtos.GetMetaInfoResponseProto metaData = proxy.getMetaInfo(null, obj);
  21.     //5. 打印元数据
  22.     System.out.println(metaData.getInfo());
  24. }