Netty集成Google的ProtoBuf序列化

我就是我 2022-06-08 10:15 188阅读 0赞

protobuf是由Google开发的一套对数据结构进行序列化的方法，可用做通信协议，数据存储格式，等等。其特点是不限语言、不限平台、扩展性强

Netty也提供了对Protobuf的天然支持，我们今天就写一个简单的示例，简单地了解一下Netty对Google的protoBuf的支持

我们的示例场景很简单的：客户端发送一个信息，这个信息用Protobuf来做序列化，然后服务器端接收这个信息，解码，读取信息

protobuf与xml，json这样的数据格式一样，都有自己的一套语法，且语法很简单，很容易掌握，xml文件的后缀名是xml，json的后缀名是json，以此类推，那么protobuf的后缀名就是proto

关于proto的基本语法与java的bean很像，详细可以参考官网，可以看下这篇博客：

http://blog.sina.com.cn/s/blog\_9b0604b40101qm35.html

现在我们定义一个类似java bean的proto文件，我们定义一个“富人”类，他有多辆车，我们先按照语法，写一个RichMan.proto,如下面的代码清单所示：

**\[plain\]** [view plain][] [copy][view plain]

1.  package netty;  
2.    
3.  option java\_package = "com.lyncc.netty.codec.protobuf.demo";  
4.  option java\_outer\_classname = "RichManProto";  
5.    
6.  message RichMan \{  
7.    
8.     required int32 id = 1;  
9.     required string name = 2;  
10.    optional string email = 3;  
11.      
12.    enum CarType \{  
13.      AUDI = 0;  
14.      BENZ = 1;  
15.      LAMBORGHINI = 2;  
16.      DASAUTO = 3;  
17.    \}  
18.      
19.    message Car \{  
20.       required string name = 1;  
21.       optional CarType type = 2 \[default = BENZ\];  
22.    \}  
23.      
24.    repeated Car cars = 4;  
25.      
26. \}

给出上面代码的一些基本解释：

1）java\_package值得是该文件生成的java文件的包路径

2）java\_outer\_classname值的是生成的class的名称

3）message和enum是它的基本类型，很类似于java的class和枚举

4）required表名这个字段是必须的，option表明这个字段可选，default表明这个字段有默认值

5）repeat表明这个字段可以重复，类似于java中的List，该例子中Car的声明中，就相当于java中的List<Car>

6）每个声明的后面的数字，例如1，2，3, 4等等，同级的声明不能重复

总而言之，这个“类”定义了一个富人，该富人有id，名称，邮箱，而且该富人有多个名车，这些名车的类型有奥迪，奔驰，兰博基尼，大众

好了，到目前为止，proto我们已经定义好了，Google提供了一个类似脚本的工具，可以使我们将proto文件转化成java文件

该文件叫做protoc-2.6.1-win32.zip，可以在很多地方下载到,下载地址：

http://download.csdn.net/detail/linuu/9515171

下载好，新建文件夹，且将加载的exe复制到该文件夹，且将我们刚才写的RichMan.proto复制到该文件夹下：

![Center][]

进入命令行，键入：

![Center 1][]

没有报错的情况下，会在同样的文件夹下生成如下的文件：

![Center 2][]

进入com的文件夹，你会发现生成的目录是与你proto中定义的java\_package一样：

![Center 3][]

好了，到目前为止，我们已经生成了RichManProto文件了，将其复制到eclipse对应的目录下，整个项目代码的缩略图如下图所示：

![Center 4][]

添加maven的依赖：

**\[html\]** [view plain][] [copy][view plain]

1.  **<****dependency****>**  
2.      **<****groupId****>**com.google.protobuf**</****groupId****>**  
3.      **<****artifactId****>**protobuf-java**</****artifactId****>**  
4.      **<****version****>**2.6.1**</****version****>**  
5.  **</****dependency****>**

注意就是版本必须是2.6.1，因为我们用的是protoc-2.6.1的exe去编译的，所以版本必须保持一致，否则有可能会报错

接下来就是一些大家耳熟能详的server，handler，client，bootstrap，废话多不说，上代码：

ProtoBufServer.java

**\[java\]** [view plain][] [copy][view plain]

1.  **package** com.lyncc.netty.codec.protobuf.demo;  
2.    
3.  **import** io.netty.bootstrap.ServerBootstrap;  
4.  **import** io.netty.channel.ChannelFuture;  
5.  **import** io.netty.channel.ChannelInitializer;  
6.  **import** io.netty.channel.ChannelOption;  
7.  **import** io.netty.channel.EventLoopGroup;  
8.  **import** io.netty.channel.nio.NioEventLoopGroup;  
9.  **import** io.netty.channel.socket.SocketChannel;  
10. **import** io.netty.channel.socket.nio.NioServerSocketChannel;  
11. **import** io.netty.handler.codec.protobuf.ProtobufDecoder;  
12. **import** io.netty.handler.codec.protobuf.ProtobufVarint32FrameDecoder;  
13. **import** io.netty.handler.logging.LogLevel;  
14. **import** io.netty.handler.logging.LoggingHandler;  
15.   
16. **public** **class** ProtoBufServer \{  
17.       
18.     **public** **void** bind(**int** port) **throws** Exception \{  
19.         // 配置服务端的NIO线程组  
20.         EventLoopGroup bossGroup = **new** NioEventLoopGroup();  
21.         EventLoopGroup workerGroup = **new** NioEventLoopGroup();  
22.         **try** \{  
23.             ServerBootstrap b = **new** ServerBootstrap();  
24.             b.group(bossGroup, workerGroup).channel(NioServerSocketChannel.**class**).option(ChannelOption.SO\_BACKLOG, 100)  
25.                     .handler(**new** LoggingHandler(LogLevel.INFO)).childHandler(**new** ChannelInitializer<SocketChannel>() \{  
26.                         @Override  
27.                         **public** **void** initChannel(SocketChannel ch) \{  
28.                             ch.pipeline().addLast(**new** ProtobufVarint32FrameDecoder());  
29.                             ch.pipeline().addLast(**new** ProtobufDecoder(RichManProto.RichMan.getDefaultInstance()));  
30.                             ch.pipeline().addLast(**new** ProtoBufServerHandler());  
31.                         \}  
32.                     \});  
33.   
34.             // 绑定端口，同步等待成功  
35.             ChannelFuture f = b.bind(port).sync();  
36.   
37.             System.out.println("init start");  
38.             // 等待服务端监听端口关闭  
39.             f.channel().closeFuture().sync();  
40.         \} **finally** \{  
41.             // 优雅退出，释放线程池资源  
42.             bossGroup.shutdownGracefully();  
43.             workerGroup.shutdownGracefully();  
44.         \}  
45.     \}  
46.   
47.     **public** **static** **void** main(String\[\] args) **throws** Exception \{  
48.         **int** port = 8080;  
49.         **if** (args != **null** && args.length > 0) \{  
50.             **try** \{  
51.                 port = Integer.valueOf(args\[0\]);  
52.             \} **catch** (NumberFormatException e) \{  
53.                 // 采用默认值  
54.             \}  
55.         \}  
56.         **new** ProtoBufServer().bind(port);  
57.     \}  
58.   
59. \}

可以看见，这个sever的bootstrap与其他的sever很相似，只是channelPipeline中在自定义的handler之前添加了netty对protobuf支持的两个天然的decoder

![Center 5][]

我没有深究，看名字就知道第一个Decoder是将帧byte数据转化成message，第二步就是将message转化成我们自定义的Rimanproto

自定义的handler很简单，就是打印一下解析的内容：

ProtoBufServerHandler.java

**\[java\]** [view plain][] [copy][view plain]

客户端代码

ProtoBufClient.java

**\[java\]** [view plain][] [copy][view plain]

1.  **package** com.lyncc.netty.codec.protobuf.demo;  
2.    
3.  **import** io.netty.bootstrap.Bootstrap;  
4.  **import** io.netty.channel.ChannelFuture;  
5.  **import** io.netty.channel.ChannelInitializer;  
6.  **import** io.netty.channel.ChannelOption;  
7.  **import** io.netty.channel.EventLoopGroup;  
8.  **import** io.netty.channel.nio.NioEventLoopGroup;  
9.  **import** io.netty.channel.socket.SocketChannel;  
10. **import** io.netty.channel.socket.nio.NioSocketChannel;  
11. **import** io.netty.handler.codec.protobuf.ProtobufEncoder;  
12. **import** io.netty.handler.codec.protobuf.ProtobufVarint32LengthFieldPrepender;  
13.   
14. **public** **class** ProtoBufClient \{  
15.       
16.     **public** **void** connect(**int** port, String host) **throws** Exception \{  
17.         // 配置客户端NIO线程组  
18.         EventLoopGroup group = **new** NioEventLoopGroup();  
19.         **try** \{  
20.             Bootstrap b = **new** Bootstrap();  
21.             b.group(group).channel(NioSocketChannel.**class**).option(ChannelOption.TCP\_NODELAY, **true**)  
22.                     .handler(**new** ChannelInitializer<SocketChannel>() \{  
23.                         @Override  
24.                         **public** **void** initChannel(SocketChannel ch) **throws** Exception \{  
25.                             ch.pipeline().addLast(**new** ProtobufVarint32LengthFieldPrepender());  
26.                             ch.pipeline().addLast(**new** ProtobufEncoder());  
27.                             ch.pipeline().addLast(**new** ProtoBufClientHandler());  
28.                         \}  
29.                     \});  
30.   
31.             // 发起异步连接操作  
32.             ChannelFuture f = b.connect(host, port).sync();  
33.   
34.             // 当代客户端链路关闭  
35.             f.channel().closeFuture().sync();  
36.         \} **finally** \{  
37.             // 优雅退出，释放NIO线程组  
38.             group.shutdownGracefully();  
39.         \}  
40.     \}  
41.   
42.     /\*\* 
43.      \* @param args 
44.      \* @throws Exception 
45.      \*/  
46.     **public** **static** **void** main(String\[\] args) **throws** Exception \{  
47.         **int** port = 8080;  
48.         **if** (args != **null** && args.length > 0) \{  
49.             **try** \{  
50.                 port = Integer.valueOf(args\[0\]);  
51.             \} **catch** (NumberFormatException e) \{  
52.                 // 采用默认值  
53.             \}  
54.         \}  
55.         **new** ProtoBufClient().connect(port, "127.0.0.1");  
56.     \}  
57.   
58. \}

需要注意的是：

![Center 6][]

在传输之前需要将你的类进行protobuf的序列化，这是两个序列化的编码器

接着看：

ProtoBufClientHandler.java

**\[java\]** [view plain][] [copy][view plain]

1.  **package** com.lyncc.netty.codec.protobuf.demo;  
2.    
3.  **import** io.netty.channel.ChannelHandlerContext;  
4.  **import** io.netty.channel.ChannelInboundHandlerAdapter;  
5.    
6.  **import** java.util.ArrayList;  
7.  **import** java.util.List;  
8.    
9.  **import** com.lyncc.netty.codec.protobuf.demo.RichManProto.RichMan.Car;  
10. **import** com.lyncc.netty.codec.protobuf.demo.RichManProto.RichMan.CarType;  
11.   
12. **public** **class** ProtoBufClientHandler **extends** ChannelInboundHandlerAdapter \{  
13.       
14.     @Override  
15.     **public** **void** channelActive(ChannelHandlerContext ctx) \{  
16.         System.out.println("=======================================");  
17.         RichManProto.RichMan.Builder builder = RichManProto.RichMan.newBuilder();  
18.         builder.setName("王思聪");  
19.         builder.setId(1);  
20.         builder.setEmail("wsc@163.com");  
21.           
22.         List<RichManProto.RichMan.Car> cars = **new** ArrayList<RichManProto.RichMan.Car>();  
23.         Car car1 = RichManProto.RichMan.Car.newBuilder().setName("上海大众超跑").setType(CarType.DASAUTO).build();  
24.         Car car2 = RichManProto.RichMan.Car.newBuilder().setName("Aventador").setType(CarType.LAMBORGHINI).build();  
25.         Car car3 = RichManProto.RichMan.Car.newBuilder().setName("奔驰SLS级AMG").setType(CarType.BENZ).build();  
26.           
27.         cars.add(car1);  
28.         cars.add(car2);  
29.         cars.add(car3);  
30.           
31.         builder.addAllCars(cars);  
32.         ctx.writeAndFlush(builder.build());  
33.     \}  
34.   
35.   
36.     @Override  
37.     **public** **void** exceptionCaught(ChannelHandlerContext ctx, Throwable cause) \{  
38.         cause.printStackTrace();  
39.         ctx.close();  
40.     \}  
41.   
42. \}

好了，到此为止，所有的代码已经写完毕了，我们运行测试一下：

服务器端启动：

![Center 7][]

启动客户端后，再看看服务器端的控制台：

![Center 8][]

好了，到此为止，最简单的demo已经搭建完毕了~

[view plain]: http://blog.csdn.net/linuu/article/details/51360609#
[Center]: /images/20220608/6256b9c13a324459a0a9591f38df452f.png
[Center 1]: /images/20220608/04f9a812c93c4278b085fc1a3324b32c.png
[Center 2]: /images/20220608/c027ab04a0764a05b90aaf57904b1282.png
[Center 3]: /images/20220608/a0a514d5557b4c39ac02830078a45068.png
[Center 4]: /images/20220608/c458ae6ccfad43daba61254766f0a1dd.png
[Center 5]: /images/20220608/0b963ea6630f42c78a5cadf63232d565.png
[Center 6]: /images/20220608/ff36ca1a3d1b4f91a82bf53ef96df6ae.png
[Center 7]: /images/20220608/7013bfd3cf474fb7a261829766bac0d7.png
[Center 8]: /images/20220608/4b21b186016e418e8307b23f403d1c9e.png