Netty入门

Netty

什么是Netty

Netty is an asynchronous event-driven network application framework
for rapid development of maintainable high performance protocol servers & clients.

Netty 是一个异步的、基于事件驱动的网络应用框架，用于快速开发可维护、高性能的网络服务器和客户端

注意:netty的异步还是基于多路复用的，并没有实现真正意义上的异步IO

Netty的优势

如果使用传统NIO，其工作量大，bug 多

• 需要自己构建协议
• 解决 TCP 传输问题，如粘包、半包
• 因为bug的存在，epoll 空轮询导致 CPU 100%

Netty 对 API 进行增强，使之更易用，如

• FastThreadLocal => ThreadLocal
• ByteBuf => ByteBuffer

入门案例

服务器端代码

package com.vmware.netty.utils.s1;

import io.netty.bootstrap.Bootstrap;
import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;
import io.netty.handler.codec.string.StringDecoder;

public class HelloServer {
    public static void main(String[] args) {
        new ServerBootstrap()//启动器，负责组装netty组件，启动服务器
                //包含BossEventLoop WorkerEventLoop =>EventLoop指的（selector+thread）
                .group(new NioEventLoopGroup())
                .channel(NioServerSocketChannel.class) //服务器的ServerSocketChannel实现
                // boss负责处理连接   worker负责处理读写  决定了worker（child）能执行哪些操作(handler)
                .childHandler(
                        // channel代表与客户端的数据读写通道  Initializer初始化，负责添加别的handler
                        new ChannelInitializer<NioSocketChannel>() {
                    @Override  //连接建立后调用方法
                    protected void initChannel(NioSocketChannel nioSocketChannel) throws Exception {
                        nioSocketChannel.pipeline().addLast(new StringDecoder());//将bytebuf转为字符串
                        nioSocketChannel.pipeline().addLast(new ChannelInboundHandlerAdapter() {//自定义handler
                            @Override //处理读事件
                            public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
                                System.out.println(msg);
                            }
                        });
                    }
                    //绑定服务端口
                }).bind(9001);
        System.out.println("server started ...");
    }
}

客户端代码

public class HelloClient {
    public static void main(String[] args) throws InterruptedException {
        //启动类
        new Bootstrap()
                //添加EventLoop
                .group(new NioEventLoopGroup())
                //选择客户端channel实现
                .channel(NioSocketChannel.class)
                //添加处理器
                .handler(new ChannelInitializer<NioSocketChannel>() {
                    @Override //在连接建立后被调用
                    protected void initChannel(NioSocketChannel nioSocketChannel) throws Exception {
                        nioSocketChannel.pipeline().addLast(new StringEncoder());
                    }
                })
                //连接到服务器
                .connect(new InetSocketAddress("localhost",9001))
                .sync()
                //向服务器发送数据
                .channel().writeAndFlush("hello,netty");
    }
}

执行流程

为什么服务器端使用childHandler添加组件而客户端使用handler方法添加组件?

• ServerBootstrap的handler方法用于为bossGroup添加组件,而childHander用于为workerGroup添加组件
• 而Bootstrap只有handler方法，主要原因是客户端不需要处理accept event,不存在boss与worker的区分

组件解释

• 把 channel 理解为数据的通道
• 把 msg 理解为流动的数据，最开始输入是 ByteBuf，但经过 pipeline 的加工，会变成其它类型对象，最后输出又变成 ByteBuf
• 把 handler 理解为数据的处理工序
  • 工序有多道，合在一起就是 pipeline，pipeline 负责发布事件（读、读取完成…）传播给每个 handler， handler 对自己感兴趣的事件进行处理（重写了相应事件处理方法）
  • handler 分 Inbound 和 Outbound 两类
• 把 eventLoop 理解为处理数据的工人
  • 工人可以管理多个 channel 的 io 操作，并且一旦工人负责了某个 channel，就要负责到底（绑定）
  • 工人既可以执行 io 操作，也可以进行任务处理，每位工人有任务队列，队列里可以堆放多个 channel 的待处理任务，任务分为普通任务、定时任务
  • 工人按照 pipeline 顺序，依次按照 handler 的规划（代码）处理数据，可以为每道工序指定不同的工人