Netty的java序列化实现

最新推荐文章于 2022-05-30 12:00:40 发布
最新推荐文章于 2022-05-30 12:00:40 发布
阅读量879 收藏
点赞数
分类专栏： Netty 文章标签： Netty的java序列化实现
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012100371/article/details/75075546
版权

Netty的java序列化实现

一.java序列化开发

1.1 服务端的开发

1.1.1 使用netty对POJO对象进行序列化

package serializable;

 

import java.io.Serializable;

/*

 * 对POJO对象进行序列化 ，订购请求POJO

 */

public class SubscribeReq implementsSerializable{

   

         privatestatic final long serialVersionUID=1L;

         privateint subReqID;

         privateString userName;

         privateString productName;

         privateString phoneNumber;

         privateString address;

         publicint getSubReqID() {

                   returnsubReqID;

         }

         publicvoid setSubReqID(int subReqID) {

                   this.subReqID= subReqID;

         }

         publicString getUserName() {

                   returnuserName;

         }

         publicvoid setUserName(String userName) {

                   this.userName= userName;

         }

         publicString getProductName() {

                   returnproductName;

         }

         publicvoid setProductName(String productName) {

                   this.productName= productName;

         }

         publicString getPhoneNumber() {

                   returnphoneNumber;

         }

         publicvoid setPhoneNumber(String phoneNumber) {

                   this.phoneNumber= phoneNumber;

         }

         publicString getAddress() {

                   returnaddress;

         }

         publicvoid setAddress(String address) {

                   this.address= address;

         }

         publicstatic long getSerialversionuid() {

                   returnserialVersionUID;

         }

        

         @Override

         publicString toString(){

                   return"Subscribereq[subReqID="+subReqID+",userName="+userName+",productName="+productName+",phoneNumber="+phoneNumber+",address="+address+"]";

         }

}

1.1.2 订购应答POJO

package serializable;

import java.io.Serializable;

/*

 * 订购应答POJO

 */

public class SubscribeResp implementsSerializable{

  private static final long serialVersionUID=1L;

  private int subReqID;

  private int respCode;

  private String desc;

  public int getSubReqID() {

         returnsubReqID;

}

public void setSubReqID(int subReqID) {

         this.subReqID= subReqID;

}

public int getRespCode() {

         returnrespCode;

}

public void setRespCode(int respCode) {

         this.respCode= respCode;

}

public String getDesc() {

         returndesc;

}

public void setDesc(String desc) {

         this.desc= desc;

}

public static long getSerialversionuid() {

         returnserialVersionUID;

}

@Override

  public String toString(){

            return "SubscribeResp [subReqID="+subReqID+",respCode="+respCode+",desc="+desc+"]";

   }

}

1.1.3 订购服务端

package serializable;

 

import io.netty.bootstrap.ServerBootstrap;

import io.netty.buffer.ByteBuf;

import io.netty.buffer.Unpooled;

import io.netty.channel.ChannelFuture;

import io.netty.channel.ChannelInitializer;

import io.netty.channel.ChannelOption;

import io.netty.channel.EventLoopGroup;

importio.netty.channel.nio.NioEventLoopGroup;

importio.netty.channel.socket.SocketChannel;

importio.netty.channel.socket.nio.NioServerSocketChannel;

importio.netty.handler.codec.DelimiterBasedFrameDecoder;

importio.netty.handler.codec.FixedLengthFrameDecoder;

importio.netty.handler.codec.LineBasedFrameDecoder;

importio.netty.handler.codec.serialization.ClassResolvers;

import io.netty.handler.codec.serialization.ObjectDecoder;

importio.netty.handler.codec.serialization.ObjectEncoder;

importio.netty.handler.codec.string.StringDecoder;

import io.netty.handler.logging.LogLevel;

importio.netty.handler.logging.LoggingHandler;

/*

 * 订购服务端

 */

public class SubReqServer {

        

         publicvoid bind(int port) throws Exception{

                   //配置服务端的NIO线程组

                   EventLoopGroupbossGroup =new NioEventLoopGroup();

                   EventLoopGroupworkerGroup =new NioEventLoopGroup();

         try{

                   //用于启动NIO服务器的辅助启动类，降低服务端的开发复杂度

                   ServerBootstrapb=new ServerBootstrap();

                   b.group(bossGroup,workerGroup).

                   channel(NioServerSocketChannel.class)

                   .option(ChannelOption.SO_BACKLOG,100)

                   .handler(newLoggingHandler(LogLevel.INFO))

                   .childHandler(newChannelInitializer<SocketChannel>() {

                            @Override

                            publicvoid initChannel(SocketChannel ch) throws Exception{

       // 使用weakCachingConcurrentResolver创建线程安全的weakreferenceMap对类加载器进行缓存

                                     //它支持多线程并发访问，当虚拟机内存不足，会释放缓存中的内存，防止内存泄漏

                                     //这里设置为1M，在例程中足够使用

                                     ch.pipeline().addLast(

                                                        newObjectDecoder(

                                                                           1024*1024,

                                                                           ClassResolvers

                                                                           .weakCachingConcurrentResolver(this.getClass().getClassLoader())));

                            //在消息发送的时候自动将实现Serializable的POJO对象进行解码，

                                     //因此用户无须亲自对对象进行手工序列化，只需要关注自己的业务逻辑处理即可，

                                     //对象序列化和反序列化都由Netty对象解编码器完成

                                     ch.pipeline().addLast(newObjectEncoder()); 

                                     //将订购处理handler SubReqServerHandler添加到ChannelPipeline的尾部用于业务逻辑处理

                                     ch.pipeline().addLast(newSubReqServerHandler());

                            }

                            });

                           

                  

                   //绑定端口，同步等待成功

                   ChannelFuturef=b.bind(port).sync();

                   //等待服务端监听端口关闭

                   f.channel().closeFuture().sync();

        

                  

         }catch (Exception e) {

                   //TODO: handle exception

         }finally{

                   //优雅退出，释放线程池资源

                   bossGroup.shutdownGracefully();

                   workerGroup.shutdownGracefully();

         }

        

         }

 

        

         publicstatic void main(String[] args) throws Exception{

                   intport=8080;

                   if(args!=null&&args.length>0){

                            try{

                                     port=Integer.valueOf(args[0]);

                            }catch (NumberFormatException e) {

                                     //TODO: handle exception

                            }

                   }

                   newSubReqServer().bind(port);

         }

 

}

1.1.4 订购服务处理类

package serializable;

 

importio.netty.channel.ChannelHandlerAdapter;

import io.netty.channel.ChannelHandlerContext;

 

/*

 * 订购服务处理

 */

public class SubReqServerHandler extendsChannelHandlerAdapter{

   @Override

   public void channelRead(ChannelHandlerContext ctx,Object msg) throwsException{

             SubscribeReq req=(SubscribeReq) msg;

             // 对订购者的用户名进行合法性校验，校验通过后打印订购请求消息，

             // 构造订购成功应答消息立即发送给客户端

             if("zhengguang".equalsIgnoreCase(req.getUserName())){

                       System.out.println("Serviceaccept client subscribe req : ["+req.toString()+"]");

                       ctx.writeAndFlush(resp(req.getSubReqID()));

             }

    }

   

   private SubscribeResp resp(int subReqID){

             SubscribeResp resp=new SubscribeResp();

             resp.setSubReqID(subReqID);

             resp.setRespCode(0);

             resp.setDesc("Netty book ordersucceed,3 days later"

                                + ",sent to thedesignated address");

             return resp;

    }

   

   @Override

   public void exceptionCaught(ChannelHandlerContext ctx,Throwable cause){

             cause.printStackTrace();

             ctx.close(); // 发生异常，关闭链路

    }

   

   

}

2.1 客户端开发

2.1.1 产品订购客户端

package serializable;

import client.TimeClient;

import io.netty.bootstrap.Bootstrap;

import io.netty.channel.ChannelFuture;

import io.netty.channel.ChannelInitializer;

import io.netty.channel.ChannelOption;

import io.netty.channel.EventLoopGroup;

importio.netty.channel.nio.NioEventLoopGroup;

importio.netty.channel.socket.SocketChannel;

importio.netty.channel.socket.nio.NioSocketChannel;

importio.netty.handler.codec.serialization.ClassResolvers;

importio.netty.handler.codec.serialization.ObjectDecoder;

importio.netty.handler.codec.serialization.ObjectEncoder;

/*

 * 产品订购服务端

 */

public class SubReqClient {

        

         publicvoid connect(int port,String host) throws Exception{

                   //配置客户端NIO线程组

                   EventLoopGroupgroup =new NioEventLoopGroup();

                   try{

                            Bootstrapb=new Bootstrap();

                            b.group(group).channel(NioSocketChannel.class)

                            .option(ChannelOption.TCP_NODELAY,true)

                            .handler(newChannelInitializer<SocketChannel>() {

                                     @Override

                                     publicvoid initChannel(SocketChannel ch) throws Exception{

                                               ch.pipeline().addLast(

                                                                 newObjectDecoder(1024,ClassResolvers

                                                                                    .cacheDisabled(this.getClass()

                                                                                                       .getClassLoader())));

                                               ch.pipeline().addLast(newObjectEncoder());

                                               ch.pipeline().addLast(newSubReqClientHandler());

                                     }

                            });

                                     //发起异步连接操作

                                     ChannelFuturef=b.connect(host,port).sync();

              // 等待客户端链路关闭

                                     f.channel().closeFuture().sync();

                   }catch (Exception e) {

                            //TODO: handle exception

                   }finally{

                            group.shutdownGracefully();

                   }

         }

  

        

         publicstatic void main(String[] args) throws Exception{

                   intport=8080;

                   if(args!=null&&args.length>0){

                            try{

                                     port=Integer.valueOf(args[0]);

                                    

                            }catch (NumberFormatException e) {

                                     //TODO: handle exception

                                    

                            }

                            newSubReqClient().connect(port,"127.0.0.1");

                   }

         }

}

2.1.3 SubReqClientHandler实现

package serializable;

 

importio.netty.channel.ChannelHandlerAdapter;

importio.netty.channel.ChannelHandlerContext;

 

public class SubReqClientHandler extendsChannelHandlerAdapter{

     

         publicSubReqClientHandler(){

                  

         }

         publicvoid channelActive(ChannelHandlerContext ctx){

                   //在链路激活的时候循环构造10条订购请求消息，最后一次性的发送给服务端

                   for(inti=0;i<10;i++){

                            ctx.write(subReq(i));

                   }

                   ctx.flush();

         }

        

         privateSubscribeReq subReq(int i){

                   SubscribeReqreq=new SubscribeReq();

                   req.setAddress("上海市");

                   req.setPhoneNumber("13311111111");

                   req.setProductName("书籍");

                   req.setSubReqID(i);

                   req.setUserName("zhenggaung");

                   returnreq;

         }

        

         @Override

         publicvoid channelRead(ChannelHandlerContext ctx,Object msg) throws Exception{

                   System.out.println("Receiveserver response:["+msg+"]");

                  

         }

         @Override

         publicvoid channelReadComplete(ChannelHandlerContext ctx) throws Exception{

                   ctx.flush();

         }

        

         @Override

         publicvoid exceptionCaught(ChannelHandlerContext ctx,Throwable cause){

                   cause.printStackTrace();

                   ctx.close();

         }

}

吸引力的觉悟
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Netty中的java序列化
10-04
Netty中使用java序列化做的demo，请运行代码中的SubReqServer和SubReqClient的Main函数即可
Java网络编程：socket与Netty
闫玉林的博客
06-16 5786
Socket 实现了TCP/IP协议，可以连接到网络上的上脑，并收发数据ServerSocket 用于服务端，可以监听服务端口，等待客户端连接，连接后可以生成用于传输数据的Socket创建服务端 创建客户端 客户端发送消息 服务端接收消息 也可以使用Netty很方便的实现socket编程 Netty介绍 简介 按照官方定义，它是一个异步的、基于事件 Client/Server 的网络框架，目标是提供一种简单、快速构建网络应用的方式，同时保证高吞吐量、低延时、高可靠性。 Netty 的
Netty 入门
shuaijunlan的专栏
05-11 317
原文地址：http://www.blog.shuaijunlan.cn/2018/05/10/netty-introduction/ Netty is a NIO client server framework which enables quick and easy development of network applications such as protocol servers ...
netty 对象序列化
weixin_43931625的博客
05-30 238
netty 对象序列化
Netty学习-java对象的序列化
markfengfeng的博客
11-03 147
package subscribeserver; import io.netty.bootstrap.Bootstrap; import io.netty.channel.ChannelFuture; import io.netty.channel.ChannelInitializer; import io.netty.channel.ChannelOption; import io.netty.channel.EventLoopGroup; import io.netty.channel.nio.Nio
Netty处理对象序列化
Lyndon的专栏
02-08 183
Netty处理对象序列化 使用LengthFieldBaseFrameDecoder处理属性的粘包拆包。 传递对象时必须设置每个对象成员的大小，以及成员的数量。否则无法进行正常序列化和反序列化操作
Netty服务端与客户端依靠Java序列化传输数据
03-16
Netty服务端与客户端依靠Java序列化传输数据
基于java序列化的Netty编解码技术
08-11
NULL 博文链接：https://hbxflihua.iteye.com/blog/2231765
用Netty实现一个简单的RPC框架
08-04
用Netty实现一个简单的RPC框架，基本上rpc主要的知识点都涉及到了，包括协议的定义，序列化反序列化，动态代理，Spring自动装配，Netty编解码器等。可以通过这个项目加强对Netty的学习掌握，也可以加深对RPC的理解。...
java8看不到源码-resp-server:REdis序列化协议的Netty实现，以及实现基于命令的协议的简单框架
06-04
序列化协议的 Netty 实现，以及一个实现基于命令的协议的简单框架。 为什么？ 我喜欢 REDIS，恕我直言，这是有史以来最好的代码之一。 快速、小巧且简单。 我喜欢 REDIS 的一件事是 RESP 协议，我认为构建一个库来...
Netty-序列化
weixin_44044929的博客
04-26 589
序列化与反序列化 序列化：把对象转换成字节的过程，称为对象序列化 反序列化：把字节恢复成对象的过程，称为反序列化 对象的持久化概念：把字节保存的硬盘上永久的存放 网络传输对象概念:客户端将对象序列化为字节（序列化），变成二进制的形式发送到服务器端端，服务器端接受到字节对象后，反序列化成对象 注意序列化的类必须要实现 Serializable 接口， transient 修饰变量使得该变量不被序列化。 ...
Netty之传输POJO(使用Java自带的序列化方式)
Learning
12-15 7922
1、使用Netty传输POJO对象，重点在于对象的序列化。序列化的对象通过TCP进行网络传输，结合Netty提供的对象编解码器，可以做到远程传输对象。首先Java需要序列化的对象，需要实现java.io.Serializable接口. 2、工程目录        2.1 项目的目录结构                2.2  关于Request和Response的讲解          
Netty中对象的序列化，反序列化
bit-cafe
12-03 4280
之前写的nettydemmo都是传递字符串的，而在真实使用的时候我们传的都是对象，然后写序列化方法进行序列化和返序列化，在netty中对序列化和返序列化都提供了相应的接口，而且netty也支持很多的序列化方式，但这里先提供java的序列化实现方式。 一、java序列化方式 package com.decode; import java.io.ByteArrayInputStream;
netty序列化实现
liuerchong的博客
03-29 699
对象序列化, 目的是为了实现对象的网络传输和本地持久化 如果使用java的序列化, 码流较大. 因此多用FastjsonSerialize, KryoSerialize,FSTSerialize等 在本例中使用FSTSerialize进行编解码传输javabean。 一，导入依赖jar <dependencies> <!-- Netty依赖包 ...
【Netty入门】几种序列化协议的介绍
白夜行
06-14 1万+
序列化概述1.序列化定义 序列化（serialization）就是将对象序列化为二进制形式（字节数组），一般也将序列化称为编码（Encode），主要用于网络传输、数据持久化等； 反序列化（deserialization）则是将从网络、磁盘等读取的字节数组还原成原始对象，以便后续业务的进行，一般也将反序列化称为解码（Decode），主要用于网络传输对象的解码，以便完成远程调用。 2.序列化的“鼻祖”我
Netty——基本使用介绍
热门推荐
隔壁老王的专栏
11-20 11万+
1.为什么选择Netty 上一篇文章我们已经了解了Socket通信（IO/NIO/AIO）编程，对于通信模型已经有了一个基本的认识。其实上一篇文章中，我们学习的仅仅是一个模型，如果想把这些真正的用于实际工作中，那么还需要不断的完善、扩展和优化。比如经典的TCP读包写包问题，或者是数据接收的大小，实际的通信处理与应答的处理逻辑等等一些细节问题需要认真的去思考，而这些都需要大量的时间和经历，以及丰富
netty4 java序列化_netty java序列化
weixin_42377695的博客
02-26 80
netty的java序列化使用.addLast(newObjectEncoder()).addLast(newObjectDecoder(ClassResolvers.weakCachingResolver(this.getClass().getClassLoader())))ObjectDecoder继承了LengthFieldBasedFrameDecoder 首先看LengthFieldBa...
使用Netty对POJO对象进行序列化
Donny的专栏
09-12 994
使用JDK的ObjectInputStream和ObjectOutputStream可以实现java对象的序列化和反序列化（只要被序列化的POJO对象实现Serializable接口）。 在不需要考虑跨语言，并且对序列化的性能要去不苛刻时，JDK默认的序列化机制是最明智的选择之一。 下面的例子中，我们使用Netty的ObjectDecoder和ObjectEncoder对请求和应答对象进行序列...
netty对象传输
Kevin.yang专栏
03-09 5157
netty进行对象传输首先对象需要序列化，然后通过ByteBuf的形式进行传输！1 引入pom文件 <dependency> <groupId>io.netty</groupId> <artifactId>netty-all</artifactId> <version>4.0.29.Final</version>
java im netty
最新发布
04-29
Java中使用Netty框架来实现IM（即即时通讯）功能是...可以定义自己的消息类型，并用Protobuf生成相应的Java类来进行序列化和反序列化。 以上是使用Netty实现IM的一些关键步骤，具体的实现还需要根据实际需求进行调整。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值