投稿
  1. 极客之音首页
  2. 后端开发

八.Netty入门到超神系列-Netty入门&核心类

小半 • • 后端开发 • 阅读 89

导读：本篇文章讲解 八.Netty入门到超神系列-Netty入门&核心类，希望对大家有帮助，欢迎收藏，转发！站点地址：www.bmabk.com

前言

上一章讨论的是Netty的线程模型，这一章我们基于上一章的线程模型来实战一把。由于Netty5出现重大BUG被官方废弃，所以我们使用Netty4进行学习。

Netty入门实战

在开始之前再来看一下Netty的线程模型
在这里插入图片描述

我们需要有GoosGroup来循环监听请求事件，需要有WorkGroup来处理事件，而这两个角色都通过来就NioEventLoopGroup来进行事件监听，我们还需要创建事件处理器ChannelHandler,通过 Channel的ChannelPipeline把ChannelHandler进行关联。

导入依赖

我们来写一个简单的服务端和客户端通信的案例，首先创建Maven项目，导入Maven依赖

<dependency>
  <groupId>io.netty</groupId>
    <artifactId>netty-all</artifactId>
    <version>4.1.42.Final</version>
</dependency>

服务端代码

对于服务端我们要做如下事情

  1. 创建两个NioEventLoopGroup ,一个作为BossGroup ，一个作为 WorkGroup
  2. 创建 ServerBootstrap 加入两个NioEventLoopGroup
  3. 通过 ServerBootstrap 添加Handler ，需要自己创建Handler
  4. 编写Handler ，通过继承ChannelInboundHandlerAdapter 来对不同的事件做不同的处理

服务端代码如下

public class NettyServer {
    public static void main(String[] args) throws InterruptedException {

        //创建Boss Group ：负责处理链接
        NioEventLoopGroup bossGroup = new NioEventLoopGroup();

        //创建 workGroup ：负责处理读写事件
        NioEventLoopGroup workGroup = new NioEventLoopGroup();

        //创建服务端启动对象
        ServerBootstrap bootstrap = new ServerBootstrap();

        try{
            //把 bossGroup 和 workGroup 加入启动对象
            bootstrap
                    .group(bossGroup,workGroup)
                    //保存活动链接状态，启用该功能时，TCP会主动探测空闲连接的有效性
                    .childOption(ChannelOption.SO_KEEPALIVE,true)
                    //多个客户端过来，处理不过来的请求在队列排队，指定存放请求的队列的大小
                    .option(ChannelOption.SO_BACKLOG,64)
                    //指定服务器使用什么样的通道
                    .channel(NioServerSocketChannel.class)
                    //添加事件处理器Handler
                    .childHandler(new ChannelInitializer<SocketChannel>(){

                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            //把处理器添加进去 , 每个channel都对应一个pieline
                            //pieline通道和Handler进行绑定，通过Pieline可以获取到Handler
                            ch.pipeline().addLast(new MyServerHandler());
                        }
                    });

            //绑定端口，开始接收客户端请求
            //bind方法中会创建 Channel，然后使用 EventLoop注册Channel 
            ChannelFuture future = bootstrap.bind(new InetSocketAddress("127.0.0.1", 6000)).sync();

            //对关闭通道进行监听
            //当此通道关闭时将收到通知
            future.channel().closeFuture().sync();

        }catch (Exception e){
            e.printStackTrace();
        }finally {
          	//关闭资源
            workGroup.shutdownGracefully();
            bossGroup.shutdownGracefully();
        }

    }
}
  • ChannelOption.SO_BACKLOG：服务端处理客户端连接请求是顺序处理的，所以同一事件只能处理一个客户端连接，多个客户端来的时候，服务端将不能处理的客户端连接请求放在队列中等待处理，backlog参数指定了队列的大小
  • ChannelOption.SO_KEEPALIVE：当设置该选项以后，如果在两小时内没有数据的通信时，TCP会自动发送一个活动探测数据报文。

handler代码如下

//这个Handler是用来处理客户端channel的IO事件
public class MyServerHandler extends ChannelInboundHandlerAdapter {

    //处理读事件 ChannelHandlerContext ：上下文，含有通道，pipline ,地址 ；  msg就是数据
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        ByteBuf buffer = (ByteBuf) msg;
        System.out.println("MyServerHandler,接收到:"+ctx.channel().remoteAddress()+"发来的消息："+buffer.toString(CharsetUtil.UTF_8));
    }

    //数据读取完毕
    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        //给客户端恢复消息
        ctx.writeAndFlush(Unpooled.copiedBuffer("你好，我收到了消息",CharsetUtil.UTF_8));
    }
}

上面有几个陌生的类

  • ChannelInboundHandlerAdapter ：这个是为Channel通道绑定处理事件的Handler,用来接收请求。
  • ByteBuf ：Netty提供的byte缓冲区
  • Unpooled.copiedBuffer ：工具，把数据拷贝到ByteBuf

客户端代码

客户端要做如下事情

  1. 创建 NioEventLoopGroup 用于监听服务端的事件
  2. 创建 Bootstrap启动对象 ，加入 NioEventLoopGroup
  3. 一样要通过 Bootstrap 添加Handler ，需要自己创建Handler
  4. 编写Handler ，通过继承ChannelInboundHandlerAdapter 来对不同的事件做不同的处理

客户端代码如下

public class NettyClient {
    public static void main(String[] args) throws InterruptedException {
        //客户端线程循环组
        NioEventLoopGroup eventExecutors = new NioEventLoopGroup();

        //客户端启动对象
        Bootstrap bootstrap = new Bootstrap();

        try {
            bootstrap.group(eventExecutors)
                    //指定客户端使用的通道类型
                    .channel(NioSocketChannel.class)
                    //添加客户端处理器
                    .handler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            //添加客户端处理器
                            ch.pipeline().addLast(new MyClientHandler());
                        }
                    });
            //链接服务端
            ChannelFuture channelFuture = bootstrap
                    .connect(new InetSocketAddress("127.0.0.1", 6000)).sync();
            //监听关闭事件
            channelFuture.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            eventExecutors.shutdownGracefully();
        }
    }
}

客户端handler代码如下


//这个Handler是用来处理客户端channel的IO事件
public class MyClientHandler extends ChannelInboundHandlerAdapter {

    //链接激活
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        //给服务端发送消息
        ctx.writeAndFlush(Unpooled.copiedBuffer("你好服务端",CharsetUtil.UTF_8));
    }

    //处理读事件 ChannelHandlerContext ：上下文，含有通道，pipline ,地址 ；  msg就是数据
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        ByteBuf buffer = (ByteBuf) msg;
        System.out.println("MyClientHandler,接收到:"+ctx.channel().remoteAddress()+"发来的消息："+buffer.toString(CharsetUtil.UTF_8));
    }

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

分别启动服务端和客户端，最终效果如下

  • 服务端
    在这里插入图片描述
  • 客户端
    在这里插入图片描述

核心类认识

在上面的入门案例中涉及到一些类，这里做一个解释

NioEventLoopGroup

NioEventLoopGroup 继承于 EventLoopGroup ，代表Nio 事件循环组，用来循环监听注册的Channel的IO事件，如上图，我们需要两个NioEventLoopGroup，一个为BossGroup做事件监听 ，一个为 WorkGroup做事件监听

ServerBootstrap，Bootstrap

ServerBootstrap是Netty服务端启动引导对象 ，Bootstrap是客户端的启动引导对象，作用都差不多，主要是用来配置整个netty程序,整合各个组件。

ServerBootstrap 常用方法如下：

  • group(EventLoopGroup parentGroup, EventLoopGroup childGroup) ： 该方法用于服务端，主要是为 BossGroup(Acceptor) 设置 EventLoopGroup 来监听连接事件，以及为 WorkGroup 设置EventLoopGroup来监听读写事件。
  • channel(Class<? extends C> channelClass) : 指定用来创建channel通道实例的class
  • option(ChannelOption option, T value) : 方法的作用是用来给ServerChannel添加配置项
  • childOption(ChannelOption childOption, T value) :为请求的channel添加配置项
  • handler(ChannelHandler handler) : 给BossGrop添加Handler
  • childHandler(ChannelHandler childHandler) : 给WorkGroup添加Handler
  • bind(InetAddress inetHost, int inetPort) : 为服务端绑定监听的地址和端口

Bootstrap 常用方法如下

  • connect(InetAddress inetHost, int inetPort) ：用来连接服务端
  • group(EventLoopGroup group) : 为客户端添加EventLoopGroup事件循环组。

Future,ChannelFuture

由于Netty的IO是异步的，不能立即得到消息是否被处理完成，所以需要通过Future,ChannelFuture 注册事件监听，当操作完成后会触发相应的事件，从而对事件结果做出相应的处理。

Channel

通道，用来关联IO操作和处理的Handler,不同的协议有不同的Channel

  • NioServerSocketChannel : 服务端的TCP Socket 连接
  • NioSocketChannel ：客户端的TCP Socket连接

ChannelHandler

ChannelHandler是用来处理IO事件的Handler，Handler实际上分为两种，Inbound 入站和Outbound出站，ChannelHandler比较常用的有如下两个子类

  • ChannelInboundHandlerAdapter

    该适配器 实现了ChannelInboundHandler 接口，ChannelInboundHandler 又实现了ChannelHandler接口，主要是用来处理IO入站事件

  • ChannelOutboundHandlerAdapter

    适配器 实现了ChannelOutboundHandler，ChannelOutboundHandler又实现了 ChannelHandler接口，它主要是用处理IO出站事件

  • ChannelDuplexHandler ：双通道处理器，它同时实现了ChannelInboundHandler 和 ChannelOutboundHandler ，既可以处理IO入站事件，也可以处理IO出站事件。

在这里插入图片描述

ChannelPipeline

对于每个新的通道Channel，都会创建一个新的ChannelPipeline，并将器pipeline附加到channel中，可以把ChannelPipeline看成是一个ChandlerHandler的链表，当有事件发生的时候，Pipeline负责依次调用每一个Handler进行处理或截获通道的接收和发送数据，ChannelPipeline 通过 ChannelHandlerContext来管理ChannelHandler
在这里插入图片描述

下面是端点后的 ChannelPipeline的调用链截图
在这里插入图片描述
通过Cahnnel可以获取到ChannelPipeline，通过ChannelPipeline也可以获取到Channel,ChannelPipeline是ChandlerHandler形成的双向链表 ，ChandlerHandler中包含了真正的Handler , 上图的Head是头节点，tail是尾节点 。 如下图：
在这里插入图片描述
所以整个IO事件的处理是通过 Channel ,ChannelPipeline 和 Handler 三者一起来完成的。这里要注意的是，如果事件运动方向是从客户端到服务端，数据会通过pipeline中的一些列的OutboundHandler进行处理，事件被称之为出站，反之就是入站。两种类型的Handller相互不影响

Unpooled

Unpooled是Netty提供的buffer缓冲工具类，可以根据给定的数据和编码创建一个ByteBuf，如 ByteBuf buffer = Unpooled.buffer(1024);。ByteBuf类似于NIO中的ByteBuffer 。区别在于ByteBuffer需要调用flip()读写转换，而ByteBuf无需转换。

和ByteBuffer一样，ByteBuf中维护了一个byte[]来存储数据，同时还维护了一个writerIndex和readerIndex,当执行 buffer.writeByte 写操作writerIndex就会向后移动，指向下一个存储位置。当执行 buffer.readByte()操作的时候readerIndex就会向后移动指向下一个读的位置。当readerIndex等于writerIndex，ByteBuf中的数据读取完成。

文章到这就结束了，点赞还是要求一下的，万一屏幕面前的大帅哥，或者大漂亮一不小心就一键三连了啦，那我就是熬夜到头发掉光，也出下章

版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 举报，一经查实，本站将立刻删除。

文章由极客之音整理，本文链接：https://www.bmabk.com/index.php/post/10635.html

赞 (0)
小半的头像小半
0 0

相关推荐

极客之音——专业性很强的中文编程技术网站，欢迎收藏到浏览器，订阅我们！