netty的基本介绍

迷南。 2022-10-14 10:53 14阅读 0赞

**一.什么是netty？为什么要用netty**  
netty是jboss提供的一个java开源框架，netty提供异步的、事件驱动的网络应用程序框架和工具，用以快速开发高性能、高可用性的网络服务器和客户端程序。也就是说netty是一个基于nio的编程框架，使用netty可以快速的开发出一个网络应用。

由于java 自带的nio api使用起来非常复杂，并且还可能出现 Epoll Bug，这使得我们使用原生的nio来进行网络编程存在很大的难度且非常耗时。但是netty良好的设计可以使开发人员快速高效的进行网络应用开发。

> Netty是什么？  
> 1）本质：JBoss做的一个Jar包  
> 2）目的：快速开发高性能、高可靠性的网络服务器和客户端程序  
> 3）优点：提供异步的、事件驱动的网络应用程序框架和工具  
> 通俗的说：一个好使的处理Socket的东东

**二.netty的功能特性和架构思想**  
如下图所示：netty的核心是支持零拷贝的bytebuf缓冲对象、通用通信api和可扩展的事件模型；它支持多种传输服务并且支持HTTP、Protobuf、二进制、文本、WebSocket 等一系列常见协议，也支持自定义协议。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQwODQ0Nw_size_16_color_FFFFFF_t_70]  
netty的模型是基于reactor多线程模型，其中mainReactor用于接收客户端请求并转发给subReactor。SubReactor负责通道的读写请求，非 IO 请求（具体逻辑处理）的任务则会直接写入队列，等待 worker threads 进行处理。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQwODQ0Nw_size_16_color_FFFFFF_t_70 1]  
**三.netty中的一些核心的概念**

1.bootstrap、serverBootstrap：bootstrap的意思是引导，其主要作用是配置整个netty程序，将各个组件整合起来。serverBootstrap是服务器端的引导类。bootstrap用于连接远程主机它有一个EventLoopGroup ；serverBootstrap用于监听本地端口有两个EventLoopGroup。

2.eventLoop：eventLoop维护了一个线程和任务队列，支持异步提交执行任务。

3.eventLoopGroup：eventLoopGroup 主要是管理eventLoop的生命周期，可以将其看作是一个线程池，其内部维护了一组eventLoop，每个eventLoop对应处理多个Channel，而一个Channel只能对应一个eventLoop。

4.channelPipeLine：是一个包含channelHandler的list，用来设置channelHandler的执行顺序。

5.Channel：Channel代表一个实体（如一个硬件设备、一个文件、一个网络套接字或者一个能够执行一个或者多个不同的IO操作的程序组件）的开放链接，如读操作和写操作。

6.Futrue、ChannelFuture ：Future提供了另一种在操作完成时通知应用程序的方式。这个对象可以看作是一个异步操作结果的占位符；它将在未来的某个时刻完成，并提供对其结果的访问。netty的每一个出站操作都会返回一个ChannelFuture。future上面可以注册一个监听器，当对应的事件发生后会出发该监听器。

7.ChannelInitializer：它是一个特殊的ChannelInboundHandler,当channel注册到eventLoop上面时，对channel进行初始化

8.ChannelHandler：用来处理业务逻辑的代码，ChannelHandler是一个父接口，ChannelnboundHandler和ChannelOutboundHandler都继承了该接口，它们分别用来处理入站和出站。

9.ChannelHandlerContext:允许与其关联的ChannelHandler与它相关联的ChannlePipeline和其它ChannelHandler来进行交互。它可以通知相同ChannelPipeline中的下一个ChannelHandler，也可以对其所属的ChannelPipeline进行动态修改。

**四.netty中常用的自带解码器和编码器（编解码器名字对应的只列举一个）**

1.DelimiterBasedFrameDecoder ：分隔符解码器，以设定的符号作为消息的结束解决粘包问题

2.FixedLengthFrameDecoder　：定长解码器，作用于定长的消息

3.LineBasedFrameDecoder　　：按照每一行进行分割，也就是特殊的分隔符解码器，它的分割符为\\n或者\\r\\n。

4.LengthFieldBasedFrameDecoder　　：通过消息中设置的长度字段来进行粘包处理。该解码器总共有5个参数

5.LengthFieldBasedFrameDecoder(int maxFrameLength,单个包的最大大小

int lengthFieldOffset,　　 定义长度的字段的相对包开始的偏移量

int lengthFieldLength,　　定义长度字段所占字节数

int lengthAdjustment,　lengthAdjustment = 数据长度字段之后剩下包的字节数 - 数据长度取值（也就是长度字段之后的所有非数据的其他信息）

int initialBytesToStrip)　　从包头开始，要忽略的字节数

6.HttpRequestDecoder　　：将字节解码为HttpRequest、HttpContent和LastHttpContent消息

7.HttpResponseDecoder　　：将字节解码为HttpResponse、HttpContent和LastHttpContent消息

8.ReplayingDecoder　　：一个特殊的ByteToMessageDecoder ，可以在阻塞的i/o模式下实现非阻塞的解码。 ReplayingDecoder 和ByteToMessageDecoder 最大的不同就是ReplayingDecoder 允许你实现decode()和decodeLast()就像所有的字节已经接收到一样，不需要判断可用的字节

9.Base64Decoder 　　：Base64编码器

10.StringDecoder　　：将接收到的ByteBuf转化为String

11.ByteArrayDecoder　　：将接收到的ByteBuf转化为byte 数组

12.DatagramPacketDecoder　　：运用指定解码器来对接收到的DatagramPacket进行解码

13.MsgpackDecoder　　：用于Msgpack序列化的解码器

14.ProtobufDecoder　　：用于Protobuf协议传输的解码器

15.HttpObjectAggregator ：将http消息的多个部分聚合起来形成一个FullHttpRequest或者FullHttpResponse消息。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQwODQ0Nw_size_16_color_FFFFFF_t_70 2]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQwODQ0Nw_size_16_color_FFFFFF_t_70 3]  
LengthFieldPrepender　　:将消息的长度添加到消息的前端的编码器，一般是和LengthFieldBasedFrameDecoder搭配使用

HttpServerCodec:相当于HttpRequestDecoder和HttpResponseEncoder

HttpClientCodec:相当于HttpRequestEncoder和HttpResponseDecoder

ChunkedWriteHandler：在进行大文件传输的时候，一次将文件的全部内容映射到内存中，很有可能导致内存溢出，ChunkedWriteHandler可以解决大文件或者码流传输过程中可能发生的内存溢出问题.

**五.netty的简单使用**

public class MyClient { 
    
        public static void main(String[] args) throws InterruptedException { 
            NioEventLoopGroup nioEventLoopGroup = new NioEventLoopGroup();
            try{ 
                Bootstrap bootstrap = new Bootstrap();
                bootstrap.group(nioEventLoopGroup).channel(NioSocketChannel.class)
                    .handler(new ChannelInitializer<Channel>() { 
    
                        @Override
                        protected void initChannel(Channel ch) throws Exception { 
                            ch.pipeline().addLast(new LengthFieldBasedFrameDecoder(Integer.MAX_VALUE, 0,4,0,4))
                            .addLast(new LengthFieldPrepender(4))
                            .addLast(new StringDecoder(CharsetUtil.UTF_8))
                            .addLast(new StringEncoder(CharsetUtil.UTF_8))
                            .addLast(new SimpleChannelInboundHandler<String>() { 
    
                                @Override
                                protected void channelRead0(ChannelHandlerContext ctx, String msg) throws Exception { 
                                    System.out.println(ctx.channel().remoteAddress()+": "+msg);
                                    ctx.writeAndFlush("来自客户端的信息");
                                }
                                
                                @Override
                                public void channelActive(ChannelHandlerContext ctx) throws Exception { 
                                    for(int i=0;i<10;i++){ 
                                        ctx.writeAndFlush("客户端第"+i+"条消息");
                                    }
                                }
                                
                                @Override
                                public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception { 
                                    cause.printStackTrace();
                                    ctx.close();
                                }
                            });
                        }
                        
                    });
                
                ChannelFuture future = bootstrap.connect("localhost", 9999).sync();
                future.channel().closeFuture().sync();
                
            }finally{ 
                nioEventLoopGroup.shutdownGracefully().sync();
            }
        }
    
    }

public class MyServer { 
    
        public static void main(String[] args) throws InterruptedException { 
            NioEventLoopGroup bossGroup = new NioEventLoopGroup();
            NioEventLoopGroup workerGroup = new NioEventLoopGroup();
            try{ 
                ServerBootstrap serverBootstrap = new ServerBootstrap();
                serverBootstrap.group(bossGroup,workerGroup).channel(NioServerSocketChannel.class)
                    .childHandler(new ChannelInitializer<Channel>() { 
    
                        @Override
                        protected void initChannel(Channel ch) throws Exception { 
                            ch.pipeline()
                            .addLast(new LengthFieldBasedFrameDecoder(Integer.MAX_VALUE, 0, 4,0,4))
                            .addLast(new LengthFieldPrepender(4))
                            .addLast(new StringDecoder(CharsetUtil.UTF_8))
                            .addLast(new StringEncoder(CharsetUtil.UTF_8))
                            .addLast(new SimpleChannelInboundHandler<String>() { 
                                
                                @Override
                                protected void channelRead0(ChannelHandlerContext ctx, String msg) throws Exception { 
                                    System.out.println(ctx.channel().remoteAddress()+":"+msg);
                                    ctx.writeAndFlush("from server: "+UUID.randomUUID());
                                }
                                
                                @Override
                                public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception { 
                                    cause.printStackTrace();
                                    ctx.close();
                                }
                            });
                        }
                    });
                ChannelFuture future = serverBootstrap.bind(9999).sync();
                future.channel().closeFuture().sync();
            }finally{ 
                bossGroup.shutdownGracefully().sync();
                workerGroup.shutdownGracefully().sync();
            }
        }
    
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQwODQ0Nw_size_16_color_FFFFFF_t_70]: /images/20221014/ec911209bbf24564a6ef49f7a4029544.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQwODQ0Nw_size_16_color_FFFFFF_t_70 1]: /images/20221014/5221ac2661ce4034bfd29962da9ab081.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQwODQ0Nw_size_16_color_FFFFFF_t_70 2]: /images/20221014/18d9f61f6fc64765bf752a2917d97791.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQwODQ0Nw_size_16_color_FFFFFF_t_70 3]: /images/20221014/4680585faca74b15b1b70dedabb50bbb.png