从IO模型到Netty笔记（六）

最新推荐文章于 2023-03-10 17:07:23 发布
最新推荐文章于 2023-03-10 17:07:23 发布
阅读量1.5k 收藏
点赞数
分类专栏： NIO 文章标签： netty
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wai_58934/article/details/123458151
版权

出站入站

入站从pipeline的头部开始执行

出站从pipeline的尾部开始执行

服务端代码

public class NettyServer {
    public static void main(String[] args) {
        NioEventLoopGroup bossGroup = new NioEventLoopGroup(1);
        NioEventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            ServerBootstrap serverBootstrap = new ServerBootstrap();
            serverBootstrap.group(bossGroup,workerGroup)
                    .channel(NioServerSocketChannel.class)
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel socketChannel) throws Exception {
                            ChannelPipeline pipeline = socketChannel.pipeline();
                            pipeline.addLast(new MyEncode());
                            pipeline.addLast(new MyDecode());
                            pipeline.addLast(new MyServerHandler());
                        }
                    });

            ChannelFuture channelFuture = serverBootstrap.bind(6668).sync();
            channelFuture.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            workerGroup.shutdownGracefully();
            bossGroup.shutdownGracefully();
        }
    }
}
public class MyServerHandler extends SimpleChannelInboundHandler<Long> {
    @Override
    protected void channelRead0(ChannelHandlerContext channelHandlerContext, Long aLong) throws Exception {
        System.out.println("服务端接收到消息"+aLong);
    }

    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
//        System.out.println("服务端发送数据");
//        ctx.writeAndFlush(98765L);
    }

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

客户端代码

public class NettyClient {
    public static void main(String[] args) {
        NioEventLoopGroup loopGroup = new NioEventLoopGroup();
        try {
            Bootstrap bootstrap = new Bootstrap();
            bootstrap.group(loopGroup)
                    .channel(NioSocketChannel.class)
                    .handler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel socketChannel) throws Exception {
                            ChannelPipeline pipeline = socketChannel.pipeline();
                            pipeline.addLast(new MyEncode());
                            pipeline.addLast(new MyDecode());
                            pipeline.addLast(new MyClientHanlder());
                        }
                    });
            ChannelFuture channelFuture = bootstrap.connect("localhost", 6668).sync();
            channelFuture.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            loopGroup.shutdownGracefully();
        }
    }
}
public class MyClientHanlder extends SimpleChannelInboundHandler<Long> {
    @Override
    protected void channelRead0(ChannelHandlerContext channelHandlerContext, Long aLong) throws Exception {
//        System.out.println("客户端接收消息"+aLong);
    }

    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        System.out.println("发送信息");
//        ctx.writeAndFlush(1234L); // long 是8字节 解码一次即可
        // "abcdabcdabcdabcd" 是十六字节 所以解码两次
        ctx.writeAndFlush(Unpooled.copiedBuffer("abcdabcdabcdabcd", CharsetUtil.UTF_8));
    }

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

编解码

public class MyEncode extends MessageToByteEncoder<Long> {
    @Override
    protected void encode(ChannelHandlerContext channelHandlerContext, Long aLong, ByteBuf byteBuf) throws Exception {
        System.out.println("编码---------------------");
        byteBuf.writeLong(aLong);
    }
}
public class MyDecode extends ByteToMessageDecoder {
    @Override
    protected void decode(ChannelHandlerContext channelHandlerContext, ByteBuf byteBuf, List<Object> list) throws Exception {
        System.out.println("解码---------------------");
        if(byteBuf.readableBytes()>=8){
            list.add(byteBuf.readLong());
        }
    }
}

总结

1.从上边的运行结果可以看出，只有符合编码条件才会编码

ctx.writeAndFlush(Unpooled.copiedBuffer("abcdabcdabcdabcd", CharsetUtil.UTF_8));

写入字符串不属于long类型，所以不会经过编码器。

2.解码时如果传入msg大于指定数字，则会进行多次解码

ctx.writeAndFlush(Unpooled.copiedBuffer("abcdabcdabcdabcd", CharsetUtil.UTF_8));

字符串是16字节，所以进行两次解码（以上边例子为例）。

粘包和拆包——发现问题

由于TCP无消息保护边界，需要在接收端处理边界问题。

若不处理，则会出现的现象

服务端代码

public class NettyServer {
    public static void main(String[] args) {
        NioEventLoopGroup bossGroup = new NioEventLoopGroup(1);
        NioEventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            ServerBootstrap serverBootstrap = new ServerBootstrap();
            serverBootstrap.group(bossGroup,workerGroup)
                    .channel(NioServerSocketChannel.class)
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel socketChannel) throws Exception {
                            ChannelPipeline pipeline = socketChannel.pipeline();
                            pipeline.addLast(new MyServerHandler());
                        }
                    });

            ChannelFuture channelFuture = serverBootstrap.bind(6668).sync();
            channelFuture.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            workerGroup.shutdownGracefully();
            bossGroup.shutdownGracefully();
        }
    }
}

handler

public class MyServerHandler extends SimpleChannelInboundHandler<ByteBuf> {
    @Override
    protected void channelRead0(ChannelHandlerContext channelHandlerContext, ByteBuf msg) throws Exception {
        byte[] b = new byte[msg.readableBytes()];
        msg.readBytes(b);
        System.out.println("服务端接收到消息:"+new String(b, CharsetUtil.UTF_8));
    }

    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
//        System.out.println("服务端发送数据");
//        ctx.writeAndFlush(98765L);
    }

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

客户端代码

public class NettyClient {
    public static void main(String[] args) {
        NioEventLoopGroup loopGroup = new NioEventLoopGroup();
        try {
            Bootstrap bootstrap = new Bootstrap();
            bootstrap.group(loopGroup)
                    .channel(NioSocketChannel.class)
                    .handler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel socketChannel) throws Exception {
                            ChannelPipeline pipeline = socketChannel.pipeline();
                            pipeline.addLast(new MyClientHanlder());
                        }
                    });
            ChannelFuture channelFuture = bootstrap.connect("localhost", 6668).sync();
            channelFuture.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            loopGroup.shutdownGracefully();
        }
    }
}

handler

public class MyClientHanlder extends SimpleChannelInboundHandler<ByteBuf> {
    @Override
    protected void channelRead0(ChannelHandlerContext channelHandlerContext, ByteBuf msg) throws Exception {
    }

    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        for (int i = 0; i <10 ; i++) {
            ByteBuf buf = Unpooled.copiedBuffer("hello"+i, CharsetUtil.UTF_8);
            ctx.writeAndFlush(buf);
        }
    }

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

运行结果展示

第一次运行

服务端接收到消息:hello0hello1hello2hello3hello4hello5hello6hello7hello8hello9

 第二次运行

服务端接收到消息:hello0
服务端接收到消息:hello1hello2
服务端接收到消息:hello3
服务端接收到消息:hello4
服务端接收到消息:hello5
服务端接收到消息:hello6
服务端接收到消息:hello7
服务端接收到消息:hello8
服务端接收到消息:hello9

 第三次运行

服务端接收到消息:hello0
服务端接收到消息:hello1
服务端接收到消息:hello2hello3hello4hello5hello6hello7hello8hello9

 粘包和拆包——解决问题

自定义协议+编解码器

协议实体类

@Data
@AllArgsConstructor
@NoArgsConstructor
public class MessageProtocol {
    private int length;
    private byte[] content;
}

服务端

public class NettyServer {
    public static void main(String[] args) {
        NioEventLoopGroup bossGroup = new NioEventLoopGroup(1);
        NioEventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            ServerBootstrap serverBootstrap = new ServerBootstrap();
            serverBootstrap.group(bossGroup,workerGroup)
                    .channel(NioServerSocketChannel.class)
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel socketChannel) throws Exception {
                            ChannelPipeline pipeline = socketChannel.pipeline();
                            pipeline.addLast(new MyMessageEncode());
                            pipeline.addLast(new MyMessageDecode());
                            pipeline.addLast(new MyServerHandler());
                        }
                    });

            ChannelFuture channelFuture = serverBootstrap.bind(6668).sync();
            channelFuture.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            workerGroup.shutdownGracefully();
            bossGroup.shutdownGracefully();
        }
    }
}

handler

public class MyServerHandler extends SimpleChannelInboundHandler<MessageProtocol> {
    @Override
    protected void channelRead0(ChannelHandlerContext channelHandlerContext, MessageProtocol msg) throws Exception {
        System.out.println("服务端接收到消息:"+new String(msg.getContent(), CharsetUtil.UTF_8));
    }

    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
//        System.out.println("服务端发送数据");
//        ctx.writeAndFlush(98765L);
    }

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

客户端

public class NettyClient {
    public static void main(String[] args) {
        NioEventLoopGroup loopGroup = new NioEventLoopGroup();
        try {
            Bootstrap bootstrap = new Bootstrap();
            bootstrap.group(loopGroup)
                    .channel(NioSocketChannel.class)
                    .handler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel socketChannel) throws Exception {
                            ChannelPipeline pipeline = socketChannel.pipeline();
                            pipeline.addLast(new MyMessageEncode());
                            pipeline.addLast(new MyMessageDecode());
                            pipeline.addLast(new MyClientHanlder());
                        }
                    });
            ChannelFuture channelFuture = bootstrap.connect("localhost", 6668).sync();
            channelFuture.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            loopGroup.shutdownGracefully();
        }
    }
}

handler

public class MyClientHanlder extends SimpleChannelInboundHandler<MessageProtocol> {
    @Override
    protected void channelRead0(ChannelHandlerContext channelHandlerContext, MessageProtocol msg) throws Exception {
    }

    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {

        for (int i = 0; i <10 ; i++) {
            byte[] content = ("测试用例"+i).getBytes();
            int length = content.length;
            ctx.writeAndFlush(new MessageProtocol(length,content));
        }
    }

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

编解码器

public class MyMessageEncode extends MessageToByteEncoder<MessageProtocol> {
    @Override
    protected void encode(ChannelHandlerContext channelHandlerContext, MessageProtocol messageProtocol, ByteBuf byteBuf) throws Exception {
        byteBuf.writeInt(messageProtocol.getLength());
        byteBuf.writeBytes(messageProtocol.getContent());
    }
}
public class MyMessageDecode extends ReplayingDecoder<Void> {

    @Override
    protected void decode(ChannelHandlerContext channelHandlerContext, ByteBuf byteBuf, List<Object> list) throws Exception {
        int len = byteBuf.readInt();
        byte[] content = new byte[len];
        byteBuf.readBytes(content);
        list.add(new MessageProtocol(len,content));
    }
}

效果

每次运行都不出现粘包

服务端接收到消息:测试用例0
服务端接收到消息:测试用例1
服务端接收到消息:测试用例2
服务端接收到消息:测试用例3
服务端接收到消息:测试用例4
服务端接收到消息:测试用例5
服务端接收到消息:测试用例6
服务端接收到消息:测试用例7
服务端接收到消息:测试用例8
服务端接收到消息:测试用例9

明天一定.
关注
专栏目录
Netty全局异常捕获器
m0_53246313的博客
02-20 2099
自定义Netty的全局异常捕获器
netty学习笔记01——IO多路复用模型
qq_22343953的博客
04-28 584
文章目录netty学习笔记01——IO多路复用模型阻塞I/O模型非阻塞I/O模型i/o多路复用poll方法select方法epoll方法信号驱动I/O模型异步I/O netty学习笔记01——IO多路复用模型 阻塞I/O模型 阻塞i/o模型就是常见的io模型，请看如下的一个例子： server = new ServerSocket(port); server.accept(); 上述的代码会被阻...
netty入门（十九）Netty入站与出站机制
最新发布
zhufei463738313的博客
03-10 553
ChannelPipeline 提供了 ChannelHandler 链的容器。以客户端应用程序为例，如果事件的运动方向是从客户端到服务端的，那么我们称这些事件为出站的，即客户端发送服务端的数据会通过 pipeline 中的一系列 ChannelOutboundHandler，并被这些 Handler 处理，反之则称为入站的
ChannelInitializer 的添加
Leon_Jinhai_Sun的博客
01-12 565
前面我们已经分析过Channel 的组成，其中我们了解到，最开始的时候ChannelPipeline 中含有两个ChannelHandlerContext（同时也是ChannelHandler），但是这个Pipeline 并不能实现什么特殊的功能，因为我们还没有给它添加自定义的ChannelHandler。通常来说，我们在初始化Bootstrap，会添加我们自定义的ChannelHandler，就以我们具体的客户端启动代码片段来举例： Bootstrap bootstrap = new Bootstra
Netty源码解析- ChannelPipeline对异常事件的处理
恐龙弟旺仔的博客
12-21 2902
前言： 之前我们分析了inbound outbound事件在ChannelPipeline中的流转过程，确定了inbound事件在ChannelHandler中的处理顺序为head -- > tail，而outbound事件在ChannelHandler中的处理顺序为tail --> head。 以上都是正常的流程，如果当ChannelHandler处理请求出现问题时，关于异常是如何在ChannelPipeline中流转的呢？本文就此问题来进行探讨。 1.AbstractChannel
Netty 编解码器详解
Charge8的博客
05-05 5386
Netty 编解码器详解
Java网络编程深入解析：IO模型与Netty框架应用
资源摘要信息:"本文件是一份关于Java网络编程和Netty框架的读书笔记，它涉及了Java在网络编程方面的两个核心内容：IO和Netty框架。 首先，Java的IO部分是Java网络编程的基础。Java的IO体系结构主要分为输入(input)...
从BIO到NIO到Netty，从阻塞IO到Reactor模型深度剖析Netty核心原理（干货）
Harrison
06-21 702
很想写一篇关于Netty的剖析，但是只写Netty有些童鞋可能会一脸懵，这篇文章从浅入深，从BIO到NIO讲了个透彻，最后再讲到Netty底层原理，期间也是翻阅资料，也算是自己对相关知识的总结和复习吧~~ 1、什么是I/O模型？什么是BIO NIO AIO？三者有什么区别？ 2、AIO性能更好，为什么Netty不使用AIO？ 3、Redis、Nginx等为什么这么快？ 4、Netty相比NIO有何优势？底层如何实现？ 这些问题希望看完这篇文章之后都能找到答案~~ 目录 一、I/O模型 1..
Netty学习笔记（四）Netty概述及传统阻塞 IO 、Reactor 模式线程模型
yangwen-bo的博客
09-27 576
原生NIO存在的问题 1.NIO 的类库和 API 繁杂，使用麻烦：需要熟练掌握 Selector、ServerSocketChannel、SocketChannel、ByteBuffer 等。 2.需要具备其他的额外技能：要熟悉 Java 多线程编程，因为 NIO 编程涉及到 Reactor 模式，你必须对多线程和网络编程非常熟悉，才能编写出高质量的 NIO 程序。 3.开发工作量和难度都非常大：例如客户端面临断连重连、网络闪断、半包读写、失败缓存、网络拥塞和异常流的处理等等。 4.JDK NIO 的 B
[Netty学习笔记]六、Netty概述与线程模型简介
我就是我的博客
01-30 291
Netty概述 原生NIO存在的问题 NIO的类库和API比较繁琐，使用麻烦。需要熟练掌握Selector/ServerSocketChannel等 需要具备其他的额外技能，如多线程编程和网路编程等，才能编写出高质量的NIO程序 开发工作量和难度非常大，例如客户端面临断连重连、网络闪断、半包读写、失败缓存、网络拥塞和异常流 的处理等等。 JDK NIO 的 Bug:例如臭名昭著的 Epoll B...
netty中ChannelHandler执行顺序案例详解
入门菜鸟程序员的成长
07-13 1591
一、netty的Pipeline模型 netty的Pipeline模型用的是责任链设计模式，当boss线程监控到绑定端口上有accept事件，此时会为该socket连接实例化Pipeline，并将InboundHandler和OutboundHandler按序加载到Pipeline中，然后将该socket连接（也就是Channel对象）挂载到selector上。一个selector对应一个线程，该线程会轮询所有挂载在他身上的socket连接有没有read或write事件，然后通过线程池去执行Pipelin
netty自定义编码解码器解决拆包粘包
dingruibao的博客
11-11 1287
通过发送数据时同时发送数据长度，解决拆包粘包问题 自定义编码器、解码器 消息实体类： public class MyMessage { private int len;//发送内容的长度 private byte[] content;//发送的内容 public int getLen() { return len; } public void setLen(int len) { this.len = len; }
Netty在Android开发中的应用实战系列（二）——— Encoder,Decoder,Handler 的使用
刘桂林
12-14 589
来自阿钟的投稿，本文阅读大约7分钟一、Encoder的作用将发送的数据进行编码成需要的数据格式，然后发送出去二、Decoder的作用将收到的数据根据数据协议进行解码，然后处理三、Hand...
6 - 编码解码器-一种channelHandler
weixin_30306905的博客
08-09 183
6.1 解码器 6.1.1 抽象类-ByteToMessageDecoder decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) a). 必须实现的抽象方法，调用时传入包含数据的ByteBuf，一个添加解码消息的List, 对这个方法的调用会重复进行,直到byteBuf中没有可读取的数据。 b). 如果list...
Netty-内置的 ChannelHandler
小毛贼_哪里逃
05-18 1120
ChannelInboundHandlerAdapter public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception { ctx.fireChannelRead(msg); } 接收上一个 handler 的输出，这里的msg就是上一个 handler 的输出。默认情况下 adapter 会通过fireChannelRead()方法直接把上一个 handler 的输出结果传递到下...
Netty(十三)——ChannelHandler之意
学会改变自己——才能突破
11-30 1520
       上篇我们讲述了消息容器ChannelPipeline的相关知识，这篇我们来看下由它管理的，负责对I/O事件或者I/O操作进行拦截和处理，可以选择性的拦截和处理自己感兴趣的事件，也可以透传和终止事件的传递，也是由我们亲自实现的ChannelHandler业务处理。而Netty也帮我们实现一些通用的Handler，我们直接用就可以，前边写的例子中应该都有体会。我们还是来先看知识思维导图吧...
Netty 学习笔记二 ByteToMessageDecoder使用
热门推荐
编程圈子-谢厂节的博客
05-21 1万+
服务端使用上节的 Netty Time服务端 对客户端进行改写： package io.netty.example.time; import java.util.List; import io.netty.buffer.ByteBuf; import io.netty.channel.ChannelHandlerContext; import io.netty.handler.codec.
netty自定义协议解析
爱音乐的程序猿的博客
02-19 1521
文章目录前言一、ByteToMessageDecoder二、使用步骤1.引入库2.读入数据总结 前言 Netty是由JBOSS提供的一个java开源框架，现为 Github上的独立项目。Netty提供异步的、事件驱动的网络应用程序框架和工具，用以快速开发高性能、高可靠性的网络服务器和客户端程序。 也就是说，Netty 是一个基于NIO的客户、服务器端的编程框架，使用Netty 可以确保你快速和简单的开发出一个网络应用，例如实现了某种协议的客户、服务端应用。Netty相当于简化和流线化了网络应用的编程开发过
Netty封装的ChannelHandler
ZERO
06-15 1136
转载自：http://www.cnblogs.com/wade-luffy/p/6222960.html        ChannelHandler类似于Servlet的Filter过滤器，负责对I/O事件或者I/O操作进行拦截和处理，它可以选择性地拦截和处理自己感兴趣的事件，也可以透传和终止事件的传递。基于ChannelHandler接口，用户可以方便地进行业务逻辑定制，例如打印日志、统一
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值