netty学习七:集成protobuf完成单个对象序列化以及在网络上传输

原创 2017年08月07日 21:41:23

概述


本文介绍使用netty集成google的protobuf框架,完成proto JAVA对象的序列化和反序列化。


编写proto文件


protobuf使用.proto文件来描述对象结构体的信息。
Person.proto文件的位置

src/main/java/protobuf/seconddemo/Person.proto

syntax = "proto2";
package protobuf;
option optimize_for=SPEED;
option java_package="protobuf.seconddemo";
option java_outer_classname="ModelInfo";

message Person {
  required string name = 1;
  optional int32 age = 2;
  optional string address = 3;
}

使用proto编译器生成java对象


protoc –java_out=src/main/java src/main/java/protobuf/seconddemo/Person.proto


服务端代码


package protobuf.seconddemo.server;


import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.logging.LogLevel;
import io.netty.handler.logging.LoggingHandler;

public class ProtoBufServer {

    public static void main(String[] args) throws InterruptedException {
        EventLoopGroup parentGroup = new NioEventLoopGroup();
        EventLoopGroup childGroup = new NioEventLoopGroup();

        try {
            //加载Initializer
            ServerBootstrap serverBootstrap = new ServerBootstrap();
            serverBootstrap.group(parentGroup, childGroup)
                           .channel(NioServerSocketChannel.class)
                           .handler(new LoggingHandler(LogLevel.INFO))
                           .childHandler(new ProtoBufServerInitializer());

            //绑定监听端口
            ChannelFuture channelFuture = serverBootstrap.bind(8899).sync();
            channelFuture.channel().closeFuture().sync();
        }
        finally {
            parentGroup.shutdownGracefully();
            childGroup.shutdownGracefully();
        }
    }
}

package protobuf.seconddemo.server;


import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.socket.SocketChannel;
import io.netty.handler.codec.protobuf.ProtobufDecoder;
import io.netty.handler.codec.protobuf.ProtobufEncoder;
import io.netty.handler.codec.protobuf.ProtobufVarint32FrameDecoder;
import io.netty.handler.codec.protobuf.ProtobufVarint32LengthFieldPrepender;
import protobuf.seconddemo.ModelInfo;

public class ProtoBufServerInitializer extends ChannelInitializer<SocketChannel>{
    @Override
    protected void initChannel(SocketChannel ch) throws Exception {
        ChannelPipeline pipeline = ch.pipeline();
        //将字节数组转换成Person对象和将Person对象转成字节数组,一共需要四个处理器
        pipeline.addLast(new ProtobufVarint32FrameDecoder());
        pipeline.addLast(new ProtobufDecoder(ModelInfo.Person.getDefaultInstance()));
        pipeline.addLast(new ProtobufVarint32LengthFieldPrepender());
        pipeline.addLast(new ProtobufEncoder());

        //自定义处理器
        pipeline.addLast(new ProtoBufServerHandler());
    }
}

package protobuf.seconddemo.server;


import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import protobuf.seconddemo.ModelInfo;
import protobuf.seconddemo.ModelInfo.Person;

public class ProtoBufServerHandler extends SimpleChannelInboundHandler<ModelInfo.Person>{

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, Person msg) throws Exception {
        System.out.println(msg.getName());
        System.out.println(msg.getAddress());
        System.out.println(msg.getAge());
    }
}


客户端代码



package protobuf.seconddemo.client;


import io.netty.bootstrap.Bootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioSocketChannel;

public class ProtoBufClient {

    public static void main(String[] args) throws InterruptedException {
        EventLoopGroup eventLoopGroup = new NioEventLoopGroup();
        try {
            //加载Initializer
            Bootstrap bootstrap = new Bootstrap();
            bootstrap.group(eventLoopGroup)
                           .channel(NioSocketChannel.class)
                           .handler(new ProtoBufClientInitializer());

            //连接服务端
            ChannelFuture channelFuture = bootstrap.connect("localhost", 8899).sync();
            channelFuture.channel().closeFuture().sync();
        }
        finally {
            eventLoopGroup.shutdownGracefully();
        }
    }
}

package protobuf.seconddemo.client;


import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.socket.SocketChannel;
import io.netty.handler.codec.protobuf.ProtobufDecoder;
import io.netty.handler.codec.protobuf.ProtobufEncoder;
import io.netty.handler.codec.protobuf.ProtobufVarint32FrameDecoder;
import io.netty.handler.codec.protobuf.ProtobufVarint32LengthFieldPrepender;
import protobuf.seconddemo.ModelInfo;

public class ProtoBufClientInitializer extends ChannelInitializer<SocketChannel>{
    @Override
    protected void initChannel(SocketChannel ch) throws Exception {
        ChannelPipeline pipeline = ch.pipeline();
        //将字节数组转换成Person对象和将Person对象转成字节数组,一共需要四个处理器
        pipeline.addLast(new ProtobufVarint32FrameDecoder());
        pipeline.addLast(new ProtobufDecoder(ModelInfo.Person.getDefaultInstance()));
        pipeline.addLast(new ProtobufVarint32LengthFieldPrepender());
        pipeline.addLast(new ProtobufEncoder());

        //自定义处理器
        pipeline.addLast(new ProtoBufClientHandler());
    }
}

package protobuf.seconddemo.client;



import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import protobuf.seconddemo.ModelInfo;
import protobuf.seconddemo.ModelInfo.Person;

public class ProtoBufClientHandler extends SimpleChannelInboundHandler<ModelInfo.Person>{

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, Person msg) throws Exception {

    }

    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        ModelInfo.Person person = ModelInfo.Person.newBuilder()
                                                  .setName("Sam")
                                                  .setAddress("广州")
                                                  .setAge(34)
                                                  .build();

        ctx.writeAndFlush(person);
    }

}


运行代码


使用main方法分别启动服务端和客户端,当客户端与服务端建立连接的时候,将Person对象信息传递到服务端,服务端直接打印Person对象的信息。

客户端发送Person对象的代码

public class ProtoBufClientHandler extends SimpleChannelInboundHandler<ModelInfo.Person>{
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        ModelInfo.Person person = ModelInfo.Person.newBuilder()
                                                  .setName("Sam")
                                                  .setAddress("广州")
                                                  .setAge(34)
                                                  .build();

        ctx.writeAndFlush(person);
    }
}

服务端打印Person对象的代码

public class ProtoBufServerHandler extends SimpleChannelInboundHandler<ModelInfo.Person>{

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, Person msg) throws Exception {
        System.out.println(msg.getName());
        System.out.println(msg.getAddress());
        System.out.println(msg.getAge());
    }
}

csdn code 路径


这个项目的源代码放置在csdn code上,欢迎访问。

netty_study

版权声明:本文为博主原创文章,未经博主允许不得转载。 举报

相关文章推荐

.Net网络通讯编程[利用Socket实现字串、文件、序列化对象传输]--类设计2[使用IE浏览本页]

本案例使用.Net Socket的Tcp、Udp实现字串、文件、各种序列化对象的网络传输,同时封装了Tcp的粘包、半包处理细节,定义了网络封包格式,在发送端和接收端无需考虑内部传输细节。以下是类设计:...

php对象的序列化(串行化)用作 写入文件或者网络传输

有时候需要把一个对象在网络上传输,为了方便传输,可以把整个对象转化为二进制串,等到达另一端时,再还原为原来的对象,这个过程称之为串行化(也叫序列化), 就像我们现在想把一辆汽车通过轮船运到美国去,因为...

我是如何成为一名python大咖的?

人生苦短,都说必须python,那么我分享下我是如何从小白成为Python资深开发者的吧。2014年我大学刚毕业..

.Net网络通讯编程[利用Socket实现字串、文件、序列化对象传输]--使用封装的网络服务3[聊天室][使用IE浏览本页]

本案例使用前面封装的网络服务类编写简易聊天室,采用Tcp和多线程相关技术: App.config文件: 示范代码1.0" encoding="utf-8" ?> ...

.Net网络通讯编程[利用Socket实现字串、文件、序列化对象传输]--使用封装的网络服务4[聊天室][使用IE浏览本页]

本案例使用前面封装的网络服务类编写简易聊天室,采用Tcp和异步套接字相关技术: App.config文件: 示范代码xml version="1.0" encoding="utf-8" ?...

.Net网络通讯编程[利用Socket实现字串、文件、序列化对象传输]--使用封装的网络服务1[使用IE浏览本页]

直接使用Socket做服务器端和客户端,采用Tcp协议: 客户端代码: 示范代码using System; using System.Collections.Generic; using Sy...

Netty之传输POJO(使用JBoss的Marshalling序列化方式)

1、关于JBOSS的Marshalling的简介        JBoss Marshalling 是一个Java对象的序列化API包,修正了JDK自带的序列化包的很多问题,但又保持跟 java...

Netty之传输POJO(使用Java自带的序列化方式)

1、使用Netty传输POJO对象,重点在于对象的序列化。序列化的对象通过TCP进行网络传输,结合Netty提供的对象编解码器,可以做到远程传输对象。首先Java需要序列化的对象,需要实现java.i...

网络-数据序列化之protobuf

protobuf
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)