netty启动过程源码

小灰灰 2022-10-15 04:52 213阅读 0赞

## netty启动原理 ##

代码案例：

/** * @author liuzihao * @create 2021-05-09-15:24 * netty客户端 */
    public class NettyServer { 
    
        public static void main(String[] args) throws Exception{ 
    
            /** * 创建两个线程组合 bossGroup workGroup 如上图所介绍 * bossGroup; 只负责连接请求 * workGroup; 真正和客户段业务处理 */
            EventLoopGroup bossGroup = new NioEventLoopGroup();
    
            EventLoopGroup workGroup = new NioEventLoopGroup();
    
            // 创建服务器的启动参数配置类
            ServerBootstrap serverBootstrap = new ServerBootstrap();
            try { 
    
                serverBootstrap.group(bossGroup, workGroup)
                        // 指定类型为 NioServerSocketChannel
                        .channel(NioServerSocketChannel.class)
                        // 设置线程队列连接个数 108
                        .option(ChannelOption.SO_BACKLOG, 108)
                        // 设置保持连接活动状态
                        .childOption(ChannelOption.SO_KEEPALIVE, true)
                        // 初始化业务handler 如图处理业务到handler
                        .childHandler(new ChannelInitializer<SocketChannel>() { 
                            @Override
                            protected void initChannel(SocketChannel ch) throws Exception { 
                                // 往管道加入业务处理handler
                                ch.pipeline().addLast(new NettyServerHandler());
                            }
                        });
    
                System.out.println("服务器端初始化完成 ....");
    
                // 绑定端口 获取异步对象
                ChannelFuture sync = serverBootstrap.bind(8888).sync();
    
                // 异步监听关闭通道
                sync.channel().closeFuture().sync();
    
            }finally { 
                // 发生异常优雅关闭
                bossGroup.shutdownGracefully();
            }
        }
    }

##### 一、创建NioEventLoopGroup #####

`NioEventLoopGroup`、和`NioEventLoopGroup` 是netty中的核心对象，前者用于建立连接，注册channel；后者是真正与客户端交流

new NioEventLoopGroup() 如果不指定会默认创建 cup核数 \* 2 个线程进行处理；

// cpu核心数 乘以 2
    DEFAULT_EVENT_LOOP_THREADS = Math.max(1, SystemPropertyUtil.getInt(
                    "io.netty.eventLoopThreads", NettyRuntime.availableProcessors() * 2));
    
    // 创建线程组 部分代码
      children = new EventExecutor[nThreads];
    
            for (int i = 0; i < nThreads; i ++) { 
                boolean success = false;
                try { 
                  // 其实就是 NioEventLoopGroup对象 （顶层都是EventExecutor接口）
                    children[i] = newChild(executor, args);
                }

##### 二、创建ServerBootstrap #####

ServerBootstrap是netty的引导类，是进行服务的启动和参数的初始化。

==serverBootstrap.group(bossGroup, workGroup)==将循环事件组赋值给引导类:

public ServerBootstrap group(EventLoopGroup parentGroup, EventLoopGroup childGroup) { 
            super.group(parentGroup);
            if (this.childGroup != null) { 
                throw new IllegalStateException("childGroup set already");
            }
            this.childGroup = ObjectUtil.checkNotNull(childGroup, "childGroup");
            return this;
        }

.channel(NioServerSocketChannel.class) 设置一个Channel类信息

// 根据class 创建生成channel的 Factory 后面会根据这个工厂 创建对应的Channel
    public B channel(Class<? extends C> channelClass) { 
            return channelFactory(new ReflectiveChannelFactory<C>(
                    ObjectUtil.checkNotNull(channelClass, "channelClass")
            ));
        }

.option(ChannelOption.SO\_BACKLOG, 108) 设置tcp参数

// option是一个LinkedHashMap 存储相关配置
    public <T> B option(ChannelOption<T> option, T value) { 
            ObjectUtil.checkNotNull(option, "option");
            synchronized (options) { 
                if (value == null) { 
                    options.remove(option);
                } else { 
                    options.put(option, value);
                }
            }
            return self();
        }

.childHandler(Handler) 设置一个处理的Handler

// handler属性赋值 会在每次客户端连接的时候调用
    public ServerBootstrap childHandler(ChannelHandler childHandler) { 
            this.childHandler = ObjectUtil.checkNotNull(childHandler, "childHandler");
            return this;
        }

##### 三、端口绑定 serverBootstrap.bind(8888).sync(); #####

这个方法的作用就是创建NioServerSocketChannel，并设置相关属性，然后进行绑定；

//部分代码
    private ChannelFuture doBind(final SocketAddress localAddress) { 
           // 初始化 和注册 channel
            final ChannelFuture regFuture = initAndRegister();
            final Channel channel = regFuture.channel();
            if (regFuture.cause() != null) { 
                return regFuture;
            }
    
            if (regFuture.isDone()) { 
                // At this point we know that the registration was complete and successful.
                ChannelPromise promise = channel.newPromise();
              // 绑定操作
                doBind0(regFuture, channel, localAddress, promise);
                return promise;

initAndRegister()方法

// 部分代码
        final ChannelFuture initAndRegister() { 
            Channel channel = null;
            try { 
              // channelFactory 创建出 Channel对象，这个工厂就是 channel(NioServerSocketChannel.class) 所创建的工厂
              // 这里用于创建具体的 Channel
                channel = channelFactory.newChannel();
              
              // 进行初始化 主要是进行初始化，内部操作如下：
              //1、为channel设置TCP属性
              //2、将handler添加到pipeline的末尾（在tail之前），并且会创建一个context对象将handler 与 pipeline进行关联
                init(channel);
              
               // 注册 将Channel注册到EventGroup当中
                ChannelFuture regFuture = config().group().register(channel);

doBind0(regFuture, channel, localAddress, promise);

// 这bind最终会调用到 NioServerSocketChannel到 doBind方法上 底层使用的是NIO
      protected void doBind(SocketAddress localAddress) throws Exception { 
            if (PlatformDependent.javaVersion() >= 7) { 
                javaChannel().bind(localAddress, config.getBacklog());
            } else { 
                javaChannel().socket().bind(localAddress, config.getBacklog());
            }
        }