netty使用(7)传输一个序列化对象

最新推荐文章于 2023-01-09 14:09:17 发布
最新推荐文章于 2023-01-09 14:09:17 发布
阅读量106 收藏
点赞数
文章标签： netty java
原文链接：http://www.cnblogs.com/legion/p/8686700.html
版权

Server代码

package club.test;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.List;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.codec.ByteToMessageDecoder;
//必须实现Serializable接口
class Person implements Serializable{
    private static final long    serialVersionUID    = 1L;
    private String    name;
    private String    sex;
    private int        age;

    public String toString() {
        return "name:" + name + " sex:" + sex + " age:" + age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}


public class HttpServer
{
    public void start(int port) throws Exception {
        EventLoopGroup bossGroup = new NioEventLoopGroup(); 
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            ServerBootstrap b = new ServerBootstrap(); 
            b.group(bossGroup, workerGroup).channel(NioServerSocketChannel.class) 
                    .childHandler(new ChannelInitializer<SocketChannel>() { 
                                @Override
                                public void initChannel(SocketChannel ch) throws Exception {
                                    ch.pipeline().addLast(new PersonDecoder());
                                    ch.pipeline().addLast(new BusinessHandler());
                                }
                            }).option(ChannelOption.SO_BACKLOG, 128) 
                    .childOption(ChannelOption.SO_KEEPALIVE, true); 

            ChannelFuture f = b.bind(port).sync(); 

            f.channel().closeFuture().sync();
        } finally {
            workerGroup.shutdownGracefully();
            bossGroup.shutdownGracefully();
        }
    }

    public static void main(String[] args) throws Exception {
        HttpServer server = new HttpServer();
        server.start(8000);
    }
}
class PersonDecoder extends ByteToMessageDecoder {
    @Override
    protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {
        System.out.println("Person Decoder called...");
        ByteBufToBytes read = new ByteBufToBytes();
        Object obj = ByteObjConverter.ByteToObject(read.read(in));
        out.add(obj);
    }

}
class BusinessHandler extends ChannelInboundHandlerAdapter {
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        Person person = (Person) msg;
        System.out.println("BussinessHandler called and...");
        System.out.println("Person is:"+person);
        //logger.info("BusinessHandler read msg from client :" + person);
    }

    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        System.out.println("read complete called...");
        ctx.flush();
    }
    
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        
    }
}
class ByteObjConverter {
    public static Object ByteToObject(byte[] bytes) {
        Object obj = null;
        ByteArrayInputStream bi = new ByteArrayInputStream(bytes);
        ObjectInputStream oi = null;
        try {
            oi = new ObjectInputStream(bi);
            obj = oi.readObject();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                bi.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                oi.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return obj;
    }

    public static byte[] ObjectToByte(Object obj) {
        byte[] bytes = null;
        ByteArrayOutputStream bo = new ByteArrayOutputStream();
        ObjectOutputStream oo = null;
        try {
            oo = new ObjectOutputStream(bo);
            oo.writeObject(obj);
            bytes = bo.toByteArray();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                bo.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                oo.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return (bytes);
    }
}
class ByteBufToBytes {
    private ByteBuf    temp;

    private boolean    end    = true;

    public ByteBufToBytes(int length) {
        temp = Unpooled.buffer(length);
    }

    public ByteBufToBytes() {
        // TODO Auto-generated constructor stub
    }

    public void reading(ByteBuf datas) {
        datas.readBytes(temp, datas.readableBytes());
        if (this.temp.writableBytes() != 0) {
            end = false;
        } else {
            end = true;
        }
    }

    public boolean isEnd() {
        return end;
    }

    public byte[] readFull() {
        if (end) {
            byte[] contentByte = new byte[this.temp.readableBytes()];
            this.temp.readBytes(contentByte);
            this.temp.release();
            return contentByte;
        } else {
            return null;
        }
    }

    public byte[] read(ByteBuf datas) {
        byte[] bytes = new byte[datas.readableBytes()];
        datas.readBytes(bytes);
        return bytes;
    }
}

Client代码

package club.test;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

import io.netty.bootstrap.Bootstrap;
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;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;
import io.netty.handler.codec.MessageToByteEncoder;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
class Person implements Serializable{
    private static final long    serialVersionUID    = 1L;
    private String    name;
    private String    sex;
    private int        age;

    public String toString() {
        return "name:" + name + " sex:" + sex + " age:" + age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

public class HttpClient {
    public void connect(String host, int port) throws Exception {
        EventLoopGroup workerGroup = new NioEventLoopGroup();

        try {
            Bootstrap b = new Bootstrap(); 
            b.group(workerGroup); 
            b.channel(NioSocketChannel.class); 
            b.option(ChannelOption.SO_KEEPALIVE, true); 
            b.handler(new ChannelInitializer<SocketChannel>() {
                @Override
                public void initChannel(SocketChannel ch) throws Exception {
                    ch.pipeline().addLast(new PersonEncoder());
                    ch.pipeline().addLast(new ClientInitHandler());
                }
            });

            ChannelFuture f = b.connect(host, port).sync();
            f.channel().closeFuture().sync();
        } finally {
            workerGroup.shutdownGracefully();
        }

    }

    public static void main(String[] args) throws Exception {
        HttpClient client = new HttpClient();
        client.connect("127.0.0.1", 8000);
    }
}


 class ClientInitHandler extends ChannelInboundHandlerAdapter {
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        System.out.println("client channel active");
        Person person = new Person();
        person.setName("Lannister");
        person.setSex("man");
        person.setAge(30);
        ctx.write(person);
        ctx.flush();
    }
}
 class PersonEncoder extends MessageToByteEncoder<Person> {

    @Override
    protected void encode(ChannelHandlerContext ctx, Person msg, ByteBuf out) throws Exception {
        byte[] datas = ByteObjConverter.ObjectToByte(msg);
        System.out.println("Person Encoder called...");
        out.writeBytes(datas);
        ctx.flush();
    }
}
 class ByteObjConverter {
        public static Object ByteToObject(byte[] bytes) {
            Object obj = null;
            ByteArrayInputStream bi = new ByteArrayInputStream(bytes);
            ObjectInputStream oi = null;
            try {
                oi = new ObjectInputStream(bi);
                obj = oi.readObject();
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                try {
                    bi.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                try {
                    oi.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return obj;
        }

        public static byte[] ObjectToByte(Object obj) {
            byte[] bytes = null;
            ByteArrayOutputStream bo = new ByteArrayOutputStream();
            ObjectOutputStream oo = null;
            try {
                oo = new ObjectOutputStream(bo);
                oo.writeObject(obj);
                bytes = bo.toByteArray();
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                try {
                    bo.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                try {
                    oo.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return (bytes);
        }
    }
    class ByteBufToBytes {
        private ByteBuf    temp;

        private boolean    end    = true;

        public ByteBufToBytes(int length) {
            temp = Unpooled.buffer(length);
        }

        public ByteBufToBytes() {
            // TODO Auto-generated constructor stub
        }

        public void reading(ByteBuf datas) {
            datas.readBytes(temp, datas.readableBytes());
            if (this.temp.writableBytes() != 0) {
                end = false;
            } else {
                end = true;
            }
        }

        public boolean isEnd() {
            return end;
        }

        public byte[] readFull() {
            if (end) {
                byte[] contentByte = new byte[this.temp.readableBytes()];
                this.temp.readBytes(contentByte);
                this.temp.release();
                return contentByte;
            } else {
                return null;
            }
        }

        public byte[] read(ByteBuf datas) {
            byte[] bytes = new byte[datas.readableBytes()];
            datas.readBytes(bytes);
            return bytes;
        }
    }

程序运行输出

客户端

client channel active
Person Encoder called...

服务端

Person Decoder called...
BussinessHandler called and...
Person is:name:Lannister sex:man age:30
read complete called...

 

转载于:https://www.cnblogs.com/legion/p/8686700.html

weixin_30872157
关注
netty 对象序列化
weixin_43931625的博客
05-30 302
netty 对象序列化
初始Netty原理（四）— 序列化
monkey-jie的博客
01-05 767
在开发一些远程过程调用（RPC）的程序时，一般都会涉及到对象的序列化和反序列化的问题（因为TCP或UDP这些低层协议只能传输字节流，所以应用层需要将Java POJO对象序列化为字节流才能传输）。 对象的序列化方式有以下几种方式： JSON：将Java POJO对象转换成JSON结构化的字符串。一般用于Web应用和移动开发，可读性较强，性能较差。 XML：与JSON一样，也是序列化为字符串，...
Netty处理对象序列化
Lyndon的专栏
02-08 229
Netty处理对象序列化 使用LengthFieldBaseFrameDecoder处理属性的粘包拆包。 传递对象时必须设置每个对象成员的大小，以及成员的数量。否则无法进行正常序列化和反序列化操作
Netty 序列化
Fisher3652的博客
11-11 721
目录Netty内置的序列化器集成第三方 MessagePackpom创建实体类创建解码器创建编码器创建客户端handler创建客户端创建服务端handler创建服务端启动服务端，再启动客户端代码下载地址 Netty内置的序列化器 JBoss Marshalling 和 Protocol Buffers 集成第三方 MessagePack LengthFieldBasedFrame 详解 maxFrameLength：表示的是包的最大长度 lengthFieldOffset：指的是长度域的偏移量
Netty-序列化
weixin_44044929的博客
04-26 673
序列化与反序列化 序列化：把对象转换成字节的过程，称为对象序列化 反序列化：把字节恢复成对象的过程，称为反序列化 对象的持久化概念：把字节保存的硬盘上永久的存放 网络传输对象概念:客户端将对象序列化为字节（序列化），变成二进制的形式发送到服务器端端，服务器端接受到字节对象后，反序列化成对象 注意序列化的类必须要实现 Serializable 接口， transient 修饰变量使得该变量不被序列化。 ...
netty对象序列化传输机制（序）
网络
09-18 561
4.4.    对象传输的另一种实现机制这种机制主要是为了应对其中一方不采用netty框架传输对象。实现方案：采用通用的ObjectInputStream和ObjectOutputStream将对象转换成byte数组，然后传输（即实际传输的是byte数组）。此种方式下无需设定编解码器就可传递对象，通过调试助手等终端也可以传输对象 (1)  UDPServerPipelineFactory.java
netty传输kryo序列化的对象基于socket传输
10-25
Kryo则是一种高效的Java对象序列化库，能够快速地序列化和反序列化对象，尤其适合于内存有限或者需要高速传输数据的场景。 本主题“netty传输kryo序列化的对象基于socket传输”探讨的是如何结合Netty和Kryo，实现...
Netty服务端与客户端依靠Java序列化传输数据
03-16
在Java世界中，序列化是将对象转换为字节流以便在网络间或存储系统中传输的一种常见技术。Java序列化是Java平台内建的一种标准对象序列化机制，它允许对象的状态被保存和恢复，这对于分布式应用和服务之间的通信尤其...
使用 netty实现一个简单的聊天室
最新发布
02-01
7. **序列化与反序列化**：消息在传输前需要进行序列化，到达目的地后再进行反序列化，JSON 或 Protobuf 是常用的序列化工具。 8. **性能优化**：Netty 提供了许多优化选项，如零拷贝、内存池等，可以根据实际需求...
Netty之序列化协议
12-22
在IT行业中，网络通信是关键的一环，而高效、安全的数据传输往往依赖于优秀的序列化协议。Netty作为一款高性能的异步事件驱动的网络应用框架，为Java开发者提供了强大的网络编程工具。在这个主题中，我们将深入探讨...
netty的NioSocketChannel对象 怎么实现 Serializable 接口
weixin_42584507的博客
01-09 119
NioSocketChannel类本身并没有实现Serializable接口，也就是说它本身不能被序列化。如果你想将NioSocketChannel对象序列化，你需要自己定义一个类来实现Serializable接口，并将NioSocketChannel对象作为该类的一个成员变量。然后你就可以将这个自定义类的对象序列化了。 具体实现方式可以参考如下代码： import java.io.Seriali...
Netty序列化问题解决方案（十二）
nandao158的博客
02-19 522
Netty序列化问题解决方案 Java 序列化的目的主要有两个： 1.网络传输 2.对象持久化当选行远程跨迸程服务调用时，需要把被传输的 Java 对象编码为字节数组或者 ByteBuffer 对象。而当远程服务读取到 ByteBuffer 对象或者字节数组时，需要将其解码为发 送时的 Java 对象。这被称为 Java 对象编解码技术。 Java 序列化仅仅是 Java 编解码技术的一种，由于它的种种缺陷，衍生出了多种编解码 技术和框架 Java 序列化的缺点 Java
Netty之传输POJO(使用Java自带的序列化方式)
Learning
12-15 7971
1、使用Netty传输POJO对象，重点在于对象的序列化。序列化的对象通过TCP进行网络传输，结合Netty提供的对象编解码器，可以做到远程传输对象。首先Java需要序列化的对象，需要实现java.io.Serializable接口. 2、工程目录        2.1 项目的目录结构                2.2  关于Request和Response的讲解          
使用Netty对POJO对象进行序列化
Donny的专栏
09-12 1018
使用JDK的ObjectInputStream和ObjectOutputStream可以实现java对象的序列化和反序列化（只要被序列化的POJO对象实现Serializable接口）。 在不需要考虑跨语言，并且对序列化的性能要去不苛刻时，JDK默认的序列化机制是最明智的选择之一。 下面的例子中，我们使用Netty的ObjectDecoder和ObjectEncoder对请求和应答对象进行序列...
Netty编解码技术(对象序列化)
peng_0129的博客
05-23 2447
-------Netty编解码技术---------序列化和反序列化把对象转换为字节序列的过程称为对象的序列化。把字节序列恢复为对象的过程称为对象的反序列化。--------具体代码服务端启动类package bhz.netty.serial;import io.netty.bootstrap.ServerBootstrap;import io.netty.channel.ChannelFutur...
netty序列化实现
liuerchong的博客
03-29 736
对象序列化, 目的是为了实现对象的网络传输和本地持久化 如果使用java的序列化, 码流较大. 因此多用FastjsonSerialize, KryoSerialize,FSTSerialize等 在本例中使用FSTSerialize进行编解码传输javabean。 一，导入依赖jar <dependencies> <!-- Netty依赖包 ...
Netty中对象的序列化，反序列化
bit-cafe
12-03 4397
之前写的nettydemmo都是传递字符串的，而在真实使用的时候我们传的都是对象，然后写序列化方法进行序列化和返序列化，在netty中对序列化和返序列化都提供了相应的接口，而且netty也支持很多的序列化方式，但这里先提供java的序列化实现方式。 一、java序列化方式 package com.decode; import java.io.ByteArrayInputStream;
netty源码解解析(4.0)-11 Channel NIO实现-概览
weixin_30832143的博客
01-15 123
　 结构设计 　　Channel的NIO实现位于io.netty.channel.nio包和io.netty.channel.socket.nio包中，其中io.netty.channel.nio是抽象实现，io.netty.channel.socket.nio最终实现。下面是Channel NIO相关类的派生图: 　　NIO实现最终派生出3个类型NioServerSocketChan...
netty 5.0 实现 序列化 对象发送-简单示例
老徐的博客
08-22 243
netty5.0实现序列化对象发送 序列化工具： jboss marshalling jdk: 1.8 依赖包信息 <dependency> <groupId>io.netty</groupId> <artifactId>netty-all</artifactId> ...
Netty编解码框架：Java序列化与Protobuf对比
3. **序列化效率低下**：实验表明，对于同样大小的POJO对象，使用二进制编码的序列化速度远超Java原生序列化，性能差距明显，这对于大规模并发场景尤其重要。 Google的Protobuf是一种替代方案，它是由谷歌开发并...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值