netty学习【三】：发送对象

最新推荐文章于 2022-04-08 13:22:12 发布
最新推荐文章于 2022-04-08 13:22:12 发布
阅读量272 收藏
点赞数
分类专栏： Netty 文章标签： netty java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chaijuntao/article/details/84912819
版权

1、项目结构：

看下项目的结构：
这里写图片描述

2、项目源码：

2.1、服务器端：

EchoServer.java

package send_object.server;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.Channel;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import send_object.coder.PersonDecoder;

/**
 * • 配置服务器功能，如线程、端口 • 实现服务器处理程序，它包含业务逻辑，决定当有一个请求连接或接收数据时该做什么
 *
 */
public class EchoServer {

    private final int port;

    public EchoServer(int port) {
        this.port = port;
    }

    public void start() throws Exception {
        EventLoopGroup eventLoopGroup = null;
        try {
            //创建ServerBootstrap实例来引导绑定和启动服务器
            ServerBootstrap serverBootstrap = new ServerBootstrap();
            //创建NioEventLoopGroup对象来处理事件，如接受新连接、接收数据、写数据等等
            eventLoopGroup = new NioEventLoopGroup();
            //指定通道类型为NioServerSocketChannel，一种异步模式，OIO阻塞模式为OioServerSocketChannel
            //设置InetSocketAddress让服务器监听某个端口已等待客户端连接。
            serverBootstrap.group(eventLoopGroup).channel(NioServerSocketChannel.class).localAddress("localhost",port)
            .childHandler(new ChannelInitializer<Channel>() {
                //设置childHandler执行所有的连接请求
                @Override
                protected void initChannel(Channel ch) throws Exception {
                    //注册解码的handler
                    ch.pipeline().addLast(new PersonDecoder());  //IN1  反序列化
                    //添加一个入站的handler到ChannelPipeline  
                    ch.pipeline().addLast(new EchoServerHandler());   //IN2
                }
                    });
            // 最后绑定服务器等待直到绑定完成，调用sync()方法会阻塞直到服务器完成绑定,然后服务器等待通道关闭，因为使用sync()，所以关闭操作也会被阻塞。
            ChannelFuture channelFuture = serverBootstrap.bind().sync();
            System.out.println("开始监听，端口为：" + channelFuture.channel().localAddress());
            channelFuture.channel().closeFuture().sync();
        } finally {
            eventLoopGroup.shutdownGracefully().sync();
        }
    }

    public static void main(String[] args) throws Exception {
        new EchoServer(20000).start();
    }
}
 

EchoServerHandler.java

package send_object.server;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import send_object.bean.Person;

import java.util.Date;

public class EchoServerHandler extends ChannelInboundHandlerAdapter {

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg)
            throws Exception {
        System.out.println("接收客户端消息：");
        Person person = (Person) msg;
        System.out.println(person.getName());
        System.out.println(person.getAge());
        System.out.println(person.getSex());

        //向客户端写数据
        System.out.println("server向client发送数据");
        String currentTime = new Date(System.currentTimeMillis()).toString();
        ByteBuf resp = Unpooled.copiedBuffer(currentTime.getBytes());
        ctx.write(resp);
    }

    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        System.out.println("server 读取数据完毕..");

        ctx.flush();//刷新后才将数据发出到SocketChannel
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause)
            throws Exception {
        cause.printStackTrace();
        ctx.close();
    }

}
 

2.2、客户端：

EchoClient.java

package send_object.client;

import io.netty.bootstrap.Bootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
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 send_object.coder.PersonEncoder;

import java.net.InetSocketAddress;


/**
 * • 连接服务器 • 写数据到服务器 • 等待接受服务器返回相同的数据 • 关闭连接
 * 
 * @author wilson
 *
 */
public class EchoClient {

    private final String host;
    private final int port;

    public EchoClient(String host, int port) {
        this.host = host;
        this.port = port;
    }

    public void start() throws Exception {
        EventLoopGroup nioEventLoopGroup = null;
        try {
            // 创建Bootstrap对象用来引导启动客户端
            Bootstrap bootstrap = new Bootstrap();
            // 创建EventLoopGroup对象并设置到Bootstrap中，EventLoopGroup可以理解为是一个线程池，这个线程池用来处理连接、接受数据、发送数据
            nioEventLoopGroup = new NioEventLoopGroup();
            // 创建InetSocketAddress并设置到Bootstrap中，InetSocketAddress是指定连接的服务器地址
            bootstrap.group(nioEventLoopGroup)//
                    .channel(NioSocketChannel.class)//
                    .remoteAddress(new InetSocketAddress(host, port))//
                    .handler(new ChannelInitializer<SocketChannel>() {//
                                // 添加一个ChannelHandler，客户端成功连接服务器后就会被执行
                                @Override
                                protected void initChannel(SocketChannel ch)
                                        throws Exception {
                                    // 注册编码的handler
                                    ch.pipeline().addLast(new PersonEncoder());  //out
                                    //注册处理消息的handler
                                    ch.pipeline().addLast(new EchoClientHandler());   //in
                                }
                            });
            // • 调用Bootstrap.connect()来连接服务器
            ChannelFuture f = bootstrap.connect().sync();
            // • 最后关闭EventLoopGroup来释放资源
            f.channel().closeFuture().sync();
        } finally {
            nioEventLoopGroup.shutdownGracefully().sync();
        }
    }

    public static void main(String[] args) throws Exception {
        new EchoClient("localhost", 20000).start();
    }
}
 

EchoClientHandler.java

package send_object.client;

import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import send_object.bean.Person;

public class EchoClientHandler extends SimpleChannelInboundHandler<ByteBuf> {
    // 客户端连接服务器后被调用
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
         Person person = new Person();
            person.setName("angelababy");
            person.setSex("girl");
            person.setAge(18);
            ctx.write(person);
            ctx.flush();
    }

    // • 从服务器接收到数据后调用
    @Override
    protected void channelRead0(ChannelHandlerContext ctx, ByteBuf msg)
            throws Exception {
        System.out.println("client 读取server数据..");
        // 服务端返回消息后
//      ByteBuf buf = (ByteBuf) msg;
//      byte[] req = new byte[buf.readableBytes()];
//      buf.readBytes(req);
        byte[] req = new byte[msg.readableBytes()];
        msg.readBytes(req);
        String body = new String(req, "UTF-8");
        System.out.println("服务端数据为 :" + body);
    }

    // • 发生异常时被调用
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause)
            throws Exception {
        System.out.println("client exceptionCaught..");
        // 释放资源
        ctx.close();
    }
}
 

2.3、其他：

Person.java

package send_object.bean;

import java.io.Serializable;

public 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;
    }
}
 

PersonDecoder.java

package send_object.coder;

import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.ByteToMessageDecoder;
import send_object.utils.ByteBufToBytes;
import send_object.utils.ByteObjConverter;

import java.util.List;


 /**
  * 反序列化
  * 将Byte[]转换为Object
  * @author wilson
  *
  */
public class PersonDecoder extends ByteToMessageDecoder {
    @Override
    protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {
        //工具类：将ByteBuf转换为byte[]
        ByteBufToBytes read = new ByteBufToBytes();
        byte[] bytes = read.read(in);
        //工具类：将byte[]转换为object
        Object obj = ByteObjConverter.byteToObject(bytes);
        out.add(obj);
    }

}
 

PersonEncoder.java

package send_object.coder;

import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.MessageToByteEncoder;
import send_object.bean.Person;
import send_object.utils.ByteObjConverter;

/**
  * 序列化
  * 将object转换成Byte[]
  * @author wilson
  *
  */
public class PersonEncoder extends MessageToByteEncoder<Person> {

    @Override
    protected void encode(ChannelHandlerContext ctx, Person msg, ByteBuf out) throws Exception {
        //工具类：将object转换为byte[]
        byte[] datas = ByteObjConverter.objectToByte(msg);
        out.writeBytes(datas);
        ctx.flush();
    }
}
 

ByteBufToBytes.java

package send_object.utils;

import io.netty.buffer.ByteBuf;

public class ByteBufToBytes {
    /**
     * 将ByteBuf转换为byte[]
     * @param datas
     * @return
     */
    public byte[] read(ByteBuf datas) {
        byte[] bytes = new byte[datas.readableBytes()];// 创建byte[]
        datas.readBytes(bytes);// 将ByteBuf转换为byte[]
        return bytes;
    }
}
 

ByteObjConverter.java

package send_object.utils;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class ByteObjConverter {
    /**
     * 使用IO的inputstream流将byte[]转换为object
     * @param bytes
     * @return
     */
    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;
    }
    /**
     * 使用IO的outputstream流将object转换为byte[]
     * @param obj
     * @return
     */
    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;
    }
}
 

3、最后结果：

服务器端：

开始监听，端口为：/127.0.0.1:20000
接收客户端消息：
angelababy
18
girl
server向client发送数据
server 读取数据完毕..

 客户端：

client 读取server数据..
服务端数据为 :Thu Dec 22 10:32:34 CST 2016
chaijuntao
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
netty发送对象消息
congge
09-28 5625
前言 通过之前的学习，我们知道使用netty在客户端和服务端之间很容易发送一个文本类的消息，但在实际应用中这肯定是不够用的，像java中使用最多的对象这种形式的数据，在客户端和服务端通信的时候也必然会涉及，那么netty作为通信的框架，也会有相应的支持 其实在所有的通信过程中，不管是普通的文本消息还是对象消息甚至是其他格式的数据，在传输过程中，对方解析的时候就会涉及到序列化和反序列化的问题，同样，...
【五】Netty 传输Java对象
最新发布
echohuangshihuxue的博客
01-08 694
通过使用Netty 的java序列化编解码handle,我们通过短短几行代码，就能完成POJO的序列化和反序列化。我们只需要将精力聚焦在业务逻辑上面，不用考虑底层的编解码逻辑，极大的提升了开发效率
Netty4.0学习笔记系列之五：自定义通讯协议
热门推荐
路漫漫其修远兮，吾将上下而求索
03-20 1万+
Netty中，通讯的双方建立连接后，会把数据按照ByteBuf的方式进行传输，例如http协议中，就是通过HttpRequestDecoder对ByteBuf数据流进行处理，转换成http的对象。基于这个思路，我自定义一种通讯协议：Server和客户端直接传输java对象。 实现的原理是通过Encoder把java对象转换成ByteBuf流进行传输，通过Decoder把ByteBuf转换成jav
Object转byte[]←→byte[]转Object
IT匠人的博客
09-15 2185
import java.io.ByteArrayInputStream;   import java.io.ByteArrayOutputStream;   import java.io.IOException;   import java.io.ObjectInputStream;   import java.io.ObjectOutputStream;      public cl
Netty学习教程之Netty与Marshalling结合发送对象
08-30
4. 实现业务逻辑：在服务器端和客户端的handler中，我们可以将自定义对象通过`channel.writeAndFlush(obj)`发送出去，而在接收端则可以通过`channelRead`方法的参数获取到反序列化后的对象。 总的来说，通过Netty与...
netty-client:netty client学习
07-12
Netty 客户端的学习过程中，你还会接触到许多其他概念，如 ByteBuf（用于高效地处理网络数据），以及各种编解码器（如 LengthFieldBasedFrameDecoder、ProtobufVarint32FrameDecoder 等）以适应不同协议的需求。...
netty-test:netty学习使用
05-16
这个"netty-test"项目显然是一个用于学习和实践 Netty 的示例工程，通过创建一个简单的服务器和客户端来展示 Netty 的基本用法。 在描述中提到的两个关键类，`com.hwy.ServerRun` 和 `com.hwy.ClientRun`，分别代表...
netty-test:阶段六Netty学习
04-01
标签"Java"确认了这是基于Java语言的Netty学习，意味着我们将讨论Java相关的编程概念，如面向对象设计，多线程，以及Java NIO（非阻塞I/O）等。 根据压缩包子文件的文件名称列表"netty-test-master"，我们可以推测...
netty-demo:学习netty时的例子, 各种demo
04-27
5. **编解码器示例**：在 Netty 中，自定义编解码器是常见的需求，用于将原始字节流转换为业务对象，或者反之。 通过研究这些示例，你可以逐步理解 Netty 如何处理网络事件、如何组织 Pipeline 以及如何编写自定义 ...
Netty笔记二(发送对象--服务端客户端附可运行源码)
04-18
NULL 博文链接：https://blueyan.iteye.com/blog/1852296
Netty(十一) Netty对象传输
文若书生的专栏
06-13 4747
Netty对象传输 Netty客户端与服务端使用Java序列化方式传输对象。使用netty4.x 1.自定义传输对象，必须实现序列化接口，因为使用Java的序列化方式 package com.iscas.netty.c2; import java.io.Serializable; import java.util.ArrayList; import java.util.List; ...
一文搞懂Netty发送数据全流程 | 你想知道的细节全在这里
bin的技术小屋
04-08 4537
关于Netty如何高效地发送网络数据，你想知道的所有细节都在这里
Netty(三十八) - Netty请求过程源码剖析
yangxshn的博客
03-20 261
一、基本说明 1）、服务器启动后肯定是要接收客户端请求并返回客户端想要的信息，Netty 在启动后是如何接收客户端请求的？ 2）、源码包：io.netty.example 二、请求过程源码剖析 1）、从服务器启动源码中，可以得知，服务器最终注册了一个 Accept 事件等待客户端的连接。我们也知道，NioServerSocketChannel 将自己注册到了 boss 单例线程池（reactor线程）上，也就是 EventLoop。 2）、EventLoop 的作用是一个死循环，在这个死循环中要处理三件事：
基于netty进行对象传输（操作数据库）
weixin_42304484的博客
01-24 1172
基于netty进行对象传输 编写了一个使用netty搭建的C/S项目，该项目用于远程访问数据库，实现客户端发送请求，服务端接收请求进行相应的数据库操作，返回数据给客户端。 项目结构 客户端代码 package com.syx.client; import com.syx.client.handler.ClientHandler; import com.syx.entity.SendMsg; import com.syx.entity.User; import io.netty.bootstrap.Boo
Netty 学习笔记（八）、Netty 如何发送（接收）类对象
meiyongdesan的博客
11-03 1102
概述 通过前几篇博客的介绍，我们知道 Netty 是一款高性能客户端、服务端框架，它底层通过 NIO 实现非阻塞传输流数据。前几篇测试 Demo 我们都是通过将字符串转字节数组的形式进行交互，然而实际应用场景中几乎很少用到字符串作为源数据，大部分数据结构都被封装为类对象的形式，本篇博客我就来简单介绍下 Netty 一般是如何发送和接收类对象信息的： Netty 如何发送（接收）类对象 在正式开始介绍前，我们先了解序列化、反序列化的概念： 序列化：Java 类对象转化为流数据的这个过程就叫序列化 反序列化
netty 学习 （3）发送对象
limuzi13的专栏
05-24 2116
Netty中，通讯的双方建立连接后，会把数据按照ByteBuf的方式进行传输，例如http协议中，就是通过HttpRequestDecoder对ByteBuf数据流进行处理，转换成http的对象。基于这个思路，我自定义一种通讯协议：Server和客户端直接传输Java对象。 实现的原理是通过Encoder把java对象转换成ByteBuf流进行传输，通过Decoder把ByteBuf转换成java
netty传输java bean对象
huan的学习记录
12-22 1352
在上一篇博客(netty入门实现简单的echo程序)中，我们知道了如何使用netty发送一个简单的消息，但是这远远是不够的。在这篇博客中，我们来使用netty发送一个java bean对象的消息，但是要发送对象类型的消息，必然要将java对象进行序列化，在java中序列化框架有很多中，此处我们使用protostuff来进行序列化，不了解protostuff的可以先看一下这篇博客(prot...
netty用户指南.pdf
03-01
此外，该指南还包含了 Netty 4.x 版本的中文翻译，方便中文读者更好地理解和学习。读者可以通过 GitBook 或相关网站找到完整的中文版指南，以便于深入学习和参考。 Netty 用户指南是开发者掌握和应用 Netty 框架的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值