2.netty源码分析，从实例分析netty源码执行流程

前言

        学习netty源码前需要熟悉nio的执行流程，netty就是对nio的封装和优化，netty的部分代码会用到和nio一样的代码。熟悉nio的执行流程：https://blog.csdn.net/qq_33743572/article/details/110209722

        框架源码大多不简单，许多代码前后呼应，仅凭看代码很难把有些框架的逻辑理清楚，需要画图才能清晰。
        此篇着重从图看代码，我是一边看代码一边画的，看完后重复看了好几遍修改了好几遍。
        netty的源码没有spring的那么模块化，初学者一定要有耐心看，一边看代码一边看图或自己画图，我也是看了一个星期才整理完成。
        只画了server端的图，client端相差不多。
        大神如果发现有问题也请指教，或者加我一起探讨。

netty简介

netty是jboss提供的一个java开源的网络编程框架，特点是异步、nio、事件驱动。是对nio的封装优化，因为java原生nio代码不友好。

netty的介绍网上很多。此篇专注源码流程。

netty线程模型

两个NioEventLoop：BossGroup和WorkerGroup，就是下面实例NettyServer里bootstrap.group(bossGroup, workerGroup)的那两个。也是两个线程。NioEventLoopGroup是管理NioEventLoop周期的线程池。

BossGroup负责监听处理客户端连接。WorkerGroup负责监听读、写。这两个NioEventLoop里有各自的selector，负责循环监听事件。

BossGroup和WorkerGroup是netty对nio的优化，nio只有一个selector监听连接和读、写事件，而netty让BossGroup专门监听连接事件，这样可以同时支持更高的并发连接。

 

再了解几个netty的组件：

​Channel：通道。负责建立连接、io。

​Selector：选择器。是channel的注册中心。channel与selector建立连接，selector监听channe的事件（网络连接、读、写）。每次注册的时候生成一个selectionKey(channel+selector)，放在Selector的数组里。

​Buffer：缓冲区。发送方先将数据写到缓冲区，再将缓冲区交给线程。

​ChannelHandler：通道处理器。在连接、读、写的时候做些操作，有点类似拦截器。

​ChannelPipeline：ChannelHandler的责任链，每个channel都有自己的pipeline。

接下来看实例

实例代码：

实例也可从我github上下载：https://github.com/chendaliu/architectCourse/tree/master/nettyDemo/src/main/java/com/czl/netty/base

maven依赖：

    
        io.netty
        netty-all
        4.1.35.Final
    

1.NettyServer.java

package com.czl.netty.base;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;

public class NettyServer {

    public static void main(String[] args) throws Exception {
        //创建两个线程组bossGroup和workerGroup, 含有的子线程NioEventLoop的个数默认为cpu核数的两倍
        // bossGroup只是处理连接请求 ,真正的和客户端业务处理，会交给workerGroup完成
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            //创建服务器端的启动对象
            ServerBootstrap bootstrap = new ServerBootstrap();
            //使用链式编程来配置参数
            bootstrap.group(bossGroup, workerGroup) //设置两个线程组
                    .channel(NioServerSocketChannel.class) //使用NioServerSocketChannel作为服务器的通道实现
                    // 初始化服务器连接队列大小，服务端处理客户端连接请求是顺序处理的,所以同一时间只能处理一个客户端连接。
                    // 多个客户端同时来的时候,服务端将不能处理的客户端连接请求放在队列中等待处理
                    .option(ChannelOption.SO_BACKLOG, 1024)
                    .childHandler(new ChannelInitializer() {//创建通道初始化对象，设置初始化参数

                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            //对workerGroup的SocketChannel设置处理器
                            ch.pipeline().addLast(new NettyServerHandler());
                        }
                    });
            System.out.println("netty server start。。");
            //绑定一个端口并且同步, 生成了一个ChannelFuture异步对象，通过isDone()等方法可以判断异步事件的执行情况
            //启动服务器(并绑定端口)，bind是异步操作，sync方法是等待异步操作执行完毕
            ChannelFuture cf = bootstrap.bind(9000).sync();
            //给cf注册监听器，监听我们关心的事件
            //对通道关闭进行监听，closeFuture是异步操作，监听通道关闭
            // 通过sync方法同步等待通道关闭处理完毕，这里会阻塞等待通道关闭完成
            cf.channel().closeFuture().sync();
        } finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }
}

2.NettyServerHandler.java

package com.czl.netty.base;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.util.CharsetUtil;

/**
 * 自定义Handler需要继承netty规定好的某个HandlerAdapter(规范)
 */
public class NettyServerHandler extends ChannelInboundHandlerAdapter {

    /**
     * 读取客户端发送的数据
     *
     * @param ctx 上下文对象, 含有通道channel，管道pipeline
     * @param msg 就是客户端发送的数据
     * @throws Exception
     */
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        System.out.println("服务器读取线程 " + Thread.currentThread().getName());
        //Channel channel = ctx.channel();
        //ChannelPipeline pipeline = ctx.pipeline(); //本质是一个双向链接, 出站入站
        //将 msg 转成一个 ByteBuf，类似NIO 的 ByteBuffer
        ByteBuf buf = (ByteBuf) msg;
        System.out.println("客户端发送消息是:" + buf.toString(CharsetUtil.UTF_8));
    }

    /**
     * 数据读取完毕处理方法
     *
     * @param ctx
     * @throws Exception
     */
    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        ByteBuf buf = Unpooled.copiedBuffer("HelloClient".getBytes(CharsetUtil.UTF_8));
        ctx.writeAndFlush(buf);
    }

    /**
     * 处理异常, 一般是需要关闭通道
     *
     * @param ctx
     * @param cause
     * @throws Exception
     */
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        ctx.close();
    }
}

3.NettyClient.java

package com.czl.netty.base;

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;

public class NettyClient {
    public static void main(String[] args) throws Exception {
        //客户端需要一个事件循环组
        EventLoopGroup group = new NioEventLoopGroup();
        try {
            //创建客户端启动对象
            //注意客户端使用的不是ServerBootstrap而是Bootstrap
            Bootstrap bootstrap = new Bootstrap();
            //设置相关参数
            bootstrap.group(group) //设置线程组
                    .channel(NioSocketChannel.class) // 使用NioSocketChannel作为客户端的通道实现
                    .handler(new ChannelInitializer() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            //加入处理器
                            ch.pipeline().addLast(new NettyClientHandler());
                        }
                    });

            System.out.println("netty client start。。");
            //启动客户端去连接服务器端
            ChannelFuture cf = bootstrap.connect("127.0.0.1", 9000).sync();
            //对通道关闭进行监听
            cf.channel().closeFuture().sync();
        } finally {
            group.shutdownGracefully();
        }
    }
}

4.NettyClientHandler.java

package com.czl.netty.base;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.util.CharsetUtil;

public class NettyClientHandler extends ChannelInboundHandlerAdapter {

    /**
     * 当客户端连接服务器完成就会触发该方法
     *
     * @param ctx
     * @throws Exception
     */
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        ByteBuf buf = Unpooled.copiedBuffer("HelloServer".getBytes(CharsetUtil.UTF_8));
        ctx.writeAndFlush(buf);
    }

    //当通道有读取事件时会触发，即服务端发送数据给客户端
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        ByteBuf buf = (ByteBuf) msg;
        System.out.println("收到服务端的消息:" + buf.toString(CharsetUtil.UTF_8));
        System.out.println("服务端的地址： " + ctx.channel().remoteAddress());
    }

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

跑起实例

1.先把NettyServer跑起来，输出如下说明server启动成功：

netty server start。。

2.把NettyClient跑起来

服务端输出如下：

1. 服务器读取线程 nioEventLoopGroup-3-1
2. 客户端发送消息是:HelloServer
3. 服务器读取线程 nioEventLoopGroup-3-2
4. 客户端发送消息是:HelloServer

说明client和server连接成功。

源码跟踪

停掉服务，开启debug。

从NettyServer的  ChannelFuture cf = bootstrap.bind(9000).sync() 这一行开始断点调试，进入bind方法后，执行流程如下图：

原图地址：https://www.jianguoyun.com/p/DR0I9J0QqKrvCBiyic4D