Netty源码(二)之ServerBootstrap初始化的过程

最新推荐文章于 2024-07-16 07:52:11 发布
最新推荐文章于 2024-07-16 07:52:11 发布
阅读量745 收藏 2
点赞数 1
分类专栏： netty
原文链接：https://blog.csdn.net/qq_36434742/article/details/108023416
版权

上篇博客《Netty源码(一)之NioEventLoopGroup初始化的过程》我们说了NioEventLoopGoup的初始化的过程。今天我们来讲讲ServerBootstrap的初始化的过程，我们继续重现上篇博客的代码，具体的代码如下：

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.nio.NioServerSocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;
import io.netty.handler.codec.string.StringDecoder;

//服务端
public class NettyServer {
    public static void main(String[] args) throws InterruptedException {
        //就是一个死循环，不停地检测IO事件，处理IO事件，执行任务
        //创建一个线程组:接受客户端连接   主线程
        EventLoopGroup bossGroup = new NioEventLoopGroup(1);//cpu核心数*2
        //创建一个线程组:接受网络操作   工作线程
        EventLoopGroup workerGroup = new NioEventLoopGroup();  //cpu核心数*2

        //是服务端的一个启动辅助类，通过给他设置一系列参数来绑定端口启动服务
        ServerBootstrap serverBootstrap = new ServerBootstrap();

        // 我们需要两种类型的人干活，一个是老板，一个是工人，老板负责从外面接活，
        // 接到的活分配给工人干，放到这里，bossGroup的作用就是不断地accept到新的连接，将新的连接丢给workerGroup来处理
        serverBootstrap.group(bossGroup, workerGroup)
                //设置使用NioServerSocketChannel作为服务器通道的实现
                .channel(NioServerSocketChannel.class)
                .option(ChannelOption.SO_BACKLOG, 128) //设置线程队列中等待连接的个数
                .childOption(ChannelOption.SO_KEEPALIVE, true)//保持活动连接状态
                //表示服务器启动过程中，需要经过哪些流程，这里NettyTestHandler最终的顶层接口为ChannelHandler，
                // 是netty的一大核心概念，表示数据流经过的处理器
                .handler(new NettyTestHendler())
                //表示一条新的连接进来之后，该怎么处理，也就是上面所说的，老板如何给工人配活
                .childHandler(new ChannelInitializer<NioSocketChannel>() {
                    @Override
                    protected void initChannel(NioSocketChannel nioSocketChannel) throws Exception {
                        nioSocketChannel.pipeline().addLast(new StringDecoder(), new NettyServerHendler());
                    }
                });
        System.out.println(".........server  init..........");
        // 这里就是真正的启动过程了，绑定9090端口，等待服务器启动完毕，才会进入下行代码
        ChannelFuture future = serverBootstrap.bind(9090).sync();
        System.out.println(".........server start..........");
        //等待服务端关闭socket
        future.channel().closeFuture().sync();

        // 关闭两组死循环
        bossGroup.shutdownGracefully();
        workerGroup.shutdownGracefully();
    }
}

今天我们讲的代码具体是下面的一部分：

//是服务端的一个启动辅助类，通过给他设置一系列参数来绑定端口启动服务
ServerBootstrap serverBootstrap = new ServerBootstrap();
// 我们需要两种类型的人干活，一个是老板，一个是工人，老板负责从外面接活，
// 接到的活分配给工人干，放到这里，bossGroup的作用就是不断地accept到新的连接，将新的连接丢给workerGroup来处理
serverBootstrap.group(bossGroup, workerGroup)
  //设置使用NioServerSocketChannel作为服务器通道的实现
  .channel(NioServerSocketChannel.class)
  .option(ChannelOption.SO_BACKLOG, 128) //设置线程队列中等待连接的个数
  .childOption(ChannelOption.SO_KEEPALIVE, true)//保持活动连接状态
  //表示服务器启动过程中，需要经过哪些流程，这里NettyTestHandler最终的顶层接口为ChannelHandler，
  // 是netty的一大核心概念，表示数据流经过的处理器
  .handler(new NettyTestHendler())
  //表示一条新的连接进来之后，该怎么处理，也就是上面所说的，老板如何给工人配活
  .childHandler(new ChannelInitializer<NioSocketChannel>() {
    @Override
    protected void initChannel(NioSocketChannel nioSocketChannel) throws Exception {
      nioSocketChannel.pipeline().addLast(new StringDecoder(), new NettyServerHendler());
    }
  });

上面的new ServerBootstrap();代码只是单纯的创建了一个ServerBootstrap()类,没有做任何事件，具体的赋值的代码还是在下面的链式的调用。我们先看serverBootstrap.group(bossGroup, workerGroup)方法，这儿传的两个参数，第一个参数是监听客户端连接的NioEventLoopGroup,第二个参数是处理客户端事件的NioEventLoopGroup。让我们打开group方法，一探究竟吧。打开的代码如下所示：

public class ServerBootstrap extends AbstractBootstrap<ServerBootstrap, ServerChannel> {
  //parentGroup监听客户端连接的EventLoopGroup
  //childGroup处理客户端事件的EventLoopGroup
  public ServerBootstrap group(EventLoopGroup parentGroup, EventLoopGroup childGroup) {
    		//首先调用的是父类的group方法，我们继续跟进去看看
        super.group(parentGroup);
        ObjectUtil.checkNotNull(childGroup, "childGroup");
        if (this.childGroup != null) {
            throw new IllegalStateException("childGroup set already");
        }
        this.childGroup = childGroup;
        return this;
    }
}

上面的group方法首先调用的是父类的group的方法。我们先打开父类的group方法。具体的代码如下：

public abstract class AbstractBootstrap<B extends AbstractBootstrap<B, C>, C extends Channel> implements Cloneable {
  public B group(EventLoopGroup group) {
        ObjectUtil.checkNotNull(group, "group");
        if (this.group != null) {
            throw new IllegalStateException("group set already");
        }
        // 处理的用户连接的  group=new NioEventLoopGroup();
        this.group = group;
        return self();
    }
}

上面的代码主要赋值，然后返回当前的对象，便于后面的链式的调用。这个时候AbstractBootstrap类具体的结构如下图所示：

在这里插入图片描述

在这里插入图片描述

上面的两张图应该是整合在一起的。其中NioEventLoop是继承的SingleThreadEventLoop，而SingleThreadEventLoop是继承SingleThreadEventExecutor所以NioEventLoop中有SingleThreadEventExecutor的属性，所以最终的样子就是把SingleThreadEventExecutor中的属性移动到NioEventLoop中去，让两张图进行对应的整合，就得到了AbstractBootstrap类的样子。AbstractBootstrap类的赋值结束后，我们继续查看ServerBootstrap中的group方法,具体的代码如下：

public class ServerBootstrap extends AbstractBootstrap<ServerBootstrap, ServerChannel> {
  //parentGroup监听客户端连接的EventLoopGroup
  //childGroup处理客户端事件的EventLoopGroup
  public ServerBootstrap group(EventLoopGroup parentGroup, EventLoopGroup childGroup) {
    		//父类的方法调用返回
        super.group(parentGroup);
        ObjectUtil.checkNotNull(childGroup, "childGroup");
        if (this.childGroup != null) {
            throw new IllegalStateException("childGroup set already");
        }
    		//子类进行赋值，这个时候ServerBootstrap和上面的差不多。
        this.childGroup = childGroup;
        return this;
    }
}

这个时候ServerBootstrap中的childGroup进行对应的赋值，具体如下图所示：

在这里插入图片描述

在这里插入图片描述

同样是两张图的合体。和AbstractBootstrap类差不多。到此我们的group方法就看完了，我们继续看调用链中后续的方法。具体的代码如下：

serverBootstrap.group(bossGroup, workerGroup)
  //设置使用NioServerSocketChannel作为服务器通道的实现
  .channel(NioServerSocketChannel.class)
  .option(ChannelOption.SO_BACKLOG, 128) //设置线程队列中等待连接的个数
  .childOption(ChannelOption.SO_KEEPALIVE, true)//保持活动连接状态
  //表示服务器启动过程中，需要经过哪些流程，这里NettyTestHandler最终的顶层接口为ChannelHandler，
  // 是netty的一大核心概念，表示数据流经过的处理器
  .handler(new NettyTestHendler())
  //表示一条新的连接进来之后，该怎么处理，也就是上面所说的，老板如何给工人配活
  .childHandler(new ChannelInitializer<NioSocketChannel>() {
    @Override
    protected void initChannel(NioSocketChannel nioSocketChannel) throws Exception {
      nioSocketChannel.pipeline().addLast(new StringDecoder(), new NettyServerHendler());
    }
  });

我们继续查看channel(NioServerSocketChannel.class)方法。打开对应的源码如下：

public abstract class AbstractBootstrap<B extends AbstractBootstrap<B, C>, C extends Channel> implements Cloneable {
  //泛型B  为  ServerBootstrap  C  为  ServerChannel
  public B channel(Class<? extends C> channelClass) {
    //channelClass=NioServerSocketChannel.class
    //首先调用的new ReflectiveChannelFactory<C>(ObjectUtil.checkNotNull(channelClass, "channelClass")
    return channelFactory(new ReflectiveChannelFactory<C>(
      ObjectUtil.checkNotNull(channelClass, "channelClass")
    ));
  }
}

首先调用的是new ReflectiveChannelFactory<C>(ObjectUtil.checkNotNull(channelClass, "channelClass")的方法，我们打开对应的方法，具体的代码如下：

public class ReflectiveChannelFactory<T extends Channel> implements ChannelFactory<T> {
    private final Constructor<? extends T> constructor;
    public ReflectiveChannelFactory(Class<? extends T> clazz) {
        //判断不为空
        ObjectUtil.checkNotNull(clazz, "clazz");
        try {
            //clazz=NioServerSocketChannel.class
            //constructor=NioServerSocketChannel.class.getConstructor();
            this.constructor = clazz.getConstructor();
        } catch (NoSuchMethodException e) {
            throw new IllegalArgumentException("Class " + StringUtil.simpleClassName(clazz) +
                    " does not have a public non-arg constructor", e);
        }
    }
}

可以发现上面的代码就是将传进来的class类的无参的构造函数赋值给ReflectiveChannelFactory的constructor的属性。具体如下图所示：

在这里插入图片描述

ReflectiveChannelFactory中属性和方法就如上图所示，当该方法执行完后，就直接执行channelFactory方法，具体的代码如下所示：

public abstract class AbstractBootstrap<B extends AbstractBootstrap<B, C>, C extends Channel> implements Cloneable {
  //泛型B  为  ServerBootstrap  C  为  ServerChannel
  public B channel(Class<? extends C> channelClass) {
    //channelClass=NioServerSocketChannel.class
    //首先调用的new ReflectiveChannelFactory<C>(ObjectUtil.checkNotNull(channelClass, "channelClass")
    return channelFactory(new ReflectiveChannelFactory<C>(
      ObjectUtil.checkNotNull(channelClass, "channelClass")
    ));
  }
  public B channelFactory(io.netty.channel.ChannelFactory<? extends C> channelFactory) {
        //channelFactory=new ReflectiveChannelFactory
        return channelFactory((ChannelFactory<C>) channelFactory);
  }
  public B channelFactory(ChannelFactory<? extends C> channelFactory) {
        ObjectUtil.checkNotNull(channelFactory, "channelFactory");
        if (this.channelFactory != null) {
            throw new IllegalStateException("channelFactory set already");
        }
        //channelFactory=new ReflectiveChannelFactory
        this.channelFactory = channelFactory;
        return self();
   }
}

最后一样是给AbstractBootstrap对象的channelFactory属性进行对应的赋值，这个时候AbstractBootstrap如下图所示：

在这里插入图片描述

这个时候AbstractBootstrap就变成了上图的样子，最后这个channel方法就执行完成。并返回了自己，方面继续链式调用，我们继续查看链式调用的后续的方法option(ChannelOption.SO_BACKLOG, 128)。具体的代码如下所示：

serverBootstrap.group(bossGroup, workerGroup)
  //设置使用NioServerSocketChannel作为服务器通道的实现
  .channel(NioServerSocketChannel.class)
  .option(ChannelOption.SO_BACKLOG, 128) //设置线程队列中等待连接的个数
  .childOption(ChannelOption.SO_KEEPALIVE, true)//保持活动连接状态
  //表示服务器启动过程中，需要经过哪些流程，这里NettyTestHandler最终的顶层接口为ChannelHandler，
  // 是netty的一大核心概念，表示数据流经过的处理器
  .handler(new NettyTestHendler())
  //表示一条新的连接进来之后，该怎么处理，也就是上面所说的，老板如何给工人配活
  .childHandler(new ChannelInitializer<NioSocketChannel>() {
    @Override
    protected void initChannel(NioSocketChannel nioSocketChannel) throws Exception {
      nioSocketChannel.pipeline().addLast(new StringDecoder(), new NettyServerHendler());
    }
  });

我们继续查看option(ChannelOption.SO_BACKLOG, 128)方法，让我们点开对应的源码，具体的源码如下：

public abstract class AbstractBootstrap<B extends AbstractBootstrap<B, C>, C extends Channel> implements Cloneable {
	public <T> B option(ChannelOption<T> option, T value) {
        //options=new LinkedHashMap<ChannelOption<?>, Object>();
        ObjectUtil.checkNotNull(option, "option");
        if (value == null) {
            synchronized (options) {
                options.remove(option);
            }
        } else {
            synchronized (options) {
                options.put(option, value);
            }
        }
        return self();
    }
}

这个时候，我们可以知道，如果传入的值为空的话，我们就直接从原来的options删除我们传入的option,如果传入的值不为空的话，我们就将该值put到options中去，最后返回当前对象，便于链式的调用。这个时候AbstractBootstrap变成下图的样子。

在这里插入图片描述

options可以设置的参数如下图所示：

在这里插入图片描述

这个时候options方法也执行完了，最后返回的是自己，继续链式调用，继续执行childOption(ChannelOption.SO_KEEPALIVE, true)方法具体的代码如下所示：

serverBootstrap.group(bossGroup, workerGroup)
  //设置使用NioServerSocketChannel作为服务器通道的实现
  .channel(NioServerSocketChannel.class)
  .option(ChannelOption.SO_BACKLOG, 128) //设置线程队列中等待连接的个数
  .childOption(ChannelOption.SO_KEEPALIVE, true)//保持活动连接状态
  //表示服务器启动过程中，需要经过哪些流程，这里NettyTestHandler最终的顶层接口为ChannelHandler，
  // 是netty的一大核心概念，表示数据流经过的处理器
  .handler(new NettyTestHendler())
  //表示一条新的连接进来之后，该怎么处理，也就是上面所说的，老板如何给工人配活
  .childHandler(new ChannelInitializer<NioSocketChannel>() {
    @Override
    protected void initChannel(NioSocketChannel nioSocketChannel) throws Exception {
      nioSocketChannel.pipeline().addLast(new StringDecoder(), new NettyServerHendler());
    }
  });

这个时候，我们打开childOption(ChannelOption.SO_KEEPALIVE, true)方法的源码，具体如下：

public class ServerBootstrap extends AbstractBootstrap<ServerBootstrap, ServerChannel> {
  public <T> ServerBootstrap childOption(ChannelOption<T> childOption, T value) {
    //childOptions=new LinkedHashMap<ChannelOption<?>, Object>();
    ObjectUtil.checkNotNull(childOption, "childOption");
    if (value == null) {
      synchronized (childOptions) {
        childOptions.remove(childOption);
      }
    } else {
      synchronized (childOptions) {
        childOptions.put(childOption, value);
      }
    }
    return this;
  }
}
  • 和options方法一样，只不过保存的对象的不同，上面的方法执行完后，这个时候ServerBootstrap类如下图所示：

在这里插入图片描述

childOption可以设置的参数和上面的option的设置的参数是一样的。这个时候childOption方法执行完，返回的自己，便于链式调用，这个时候调用的handler方法，具体的代码如下：

serverBootstrap.group(bossGroup, workerGroup)
  //设置使用NioServerSocketChannel作为服务器通道的实现
  .channel(NioServerSocketChannel.class)
  .option(ChannelOption.SO_BACKLOG, 128) //设置线程队列中等待连接的个数
  .childOption(ChannelOption.SO_KEEPALIVE, true)//保持活动连接状态
  //表示服务器启动过程中，需要经过哪些流程，这里NettyTestHandler最终的顶层接口为ChannelHandler，
  // 是netty的一大核心概念，表示数据流经过的处理器
  .handler(new NettyTestHendler())
  //表示一条新的连接进来之后，该怎么处理，也就是上面所说的，老板如何给工人配活
  .childHandler(new ChannelInitializer<NioSocketChannel>() {
    @Override
    protected void initChannel(NioSocketChannel nioSocketChannel) throws Exception {
      nioSocketChannel.pipeline().addLast(new StringDecoder(), new NettyServerHendler());
    }
  });

这个时候执行handler(new NettyTestHendler())方法，在看源码之前，我们先看看NettyTestHendler类，具体的代码如下：

@ChannelHandler.Sharable
public class NettyTestHendler extends ChannelInboundHandlerAdapter{

    //通道准备就绪事件
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        System.out.println("channelActive-----"+ctx);
    }

    //读取数据事件
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        if(msg instanceof NioSocketChannel){
            System.out.println(msg.getClass());
            ctx.fireChannelRead(msg);
            return;
        }
        ByteBuf byteBuf= (ByteBuf) msg;
        System.out.println("channelRead:"+byteBuf.toString(CharsetUtil.UTF_8));
    }

    @Override
    public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
        System.out.println("handlerAdded");
    }


    @Override
    public void channelRegistered(ChannelHandlerContext ctx) throws Exception {
        System.out.println("channelRegistered");
    }

}

这个时候我们查看handler方法的源码，具体如下所示：

public abstract class AbstractBootstrap<B extends AbstractBootstrap<B, C>, C extends Channel> implements Cloneable {
	public B handler(ChannelHandler handler) {
        this.handler = ObjectUtil.checkNotNull(handler, "handler");
        return self();
    }
}

上面的操作一样是赋值，将我们写好的类赋值给AbstractBootstrap中的handler属性，然后AbstractBootstrap变成如下图所示：

在这里插入图片描述

这个时候handler方法就执行完成了，同时返回的是当前对象，方便继续链式调用。我们继续查看后续的方法childHandler(),具体的代码如下：

serverBootstrap.group(bossGroup, workerGroup)
  //设置使用NioServerSocketChannel作为服务器通道的实现
  .channel(NioServerSocketChannel.class)
  .option(ChannelOption.SO_BACKLOG, 128) //设置线程队列中等待连接的个数
  .childOption(ChannelOption.SO_KEEPALIVE, true)//保持活动连接状态
  //表示服务器启动过程中，需要经过哪些流程，这里NettyTestHandler最终的顶层接口为ChannelHandler，
  // 是netty的一大核心概念，表示数据流经过的处理器
  .handler(new NettyTestHendler())
  //表示一条新的连接进来之后，该怎么处理，也就是上面所说的，老板如何给工人配活
  .childHandler(new ChannelInitializer<NioSocketChannel>() {
    @Override
    protected void initChannel(NioSocketChannel nioSocketChannel) throws Exception {
      nioSocketChannel.pipeline().addLast(new StringDecoder(), new NettyServerHendler());
    }
  });

这个时候我们点开childHandler()方法的源码，具体的源码如下：

public class ServerBootstrap extends AbstractBootstrap<ServerBootstrap, ServerChannel> {
  public ServerBootstrap childHandler(ChannelHandler childHandler) {
        // this.childHandler=new ChannelInitializer<ServerSocketChannel>()
        this.childHandler = ObjectUtil.checkNotNull(childHandler, "childHandler");
        return this;
    }
}

和上面的handler差不多，同样都是赋值，赋完值后ServerBootstrap如下图所示：

在这里插入图片描述

到此整个ServerBootstrap类初始化到赋值就结束了。下篇博客我会介绍服务端启动的流程的源码。

四、netty源码分析之ServerBootstrap
feijianke666的博客
09-05 323
一、功能概述 前两篇我们分别介绍了EventLoopGroup和EventLoop在netty中的作用。但是仅仅知道这些，可能对netty如何完成一整个网络事件监控到任务分发处理还是有些模糊。本篇我们要分析一下netty的启动流程。在我们使用netty编程的时候，我们的使用ServerBootstrap和Bootstrap来实现服务端和客户端的启动。我们先来看一下这两个类的相关类图： netty...
Netty源码解析-ServerBootstrap及初始化服务端启动
ybin__的博客
09-22 897
       在https://blog.csdn.net/ybin__/article/details/81007018 中分析了NioEventGroupLoop的初始化，这一章主要ServerBootstrap的初始化，及Netty服务端的启动。  ServerBootstrap的UML图: ServerBootstrap继承至AbstractBootstrap，ServerBootSt...
1.ServerBootstrap初始化
HENJI122的博客
08-16 389
使用版本4.1.12.Final。边学习，边总结。如侵权，请报删。 因为也是初学，错误地方请指正并见谅 ServerBootstrap初始化ServerBootstrap初始化 io.netty.bootstrap包中的ServerBootstrap方法中有初始化ServerBootstrap的一些方法 以最简单的EchoServer.class为例(代码不写全)
Netty源码学习系列之2-ServerBootstrap的初始化
keocce的博客
06-02 197
前言 根据前文我们知道，NioEventLoopGroup和NioEventLoop是netty对Reactor线程模型的实现，而本文要说的ServerBootstrap是对上面二者的整合与调用，是一个统筹者和协调者。具体netty使用的是Reactor单线程模型还是多线程模型、抑或者主从多线程模型，都是ServerBootstrap的不同配置决定的。 下面照例粘贴一下示例demo（以Reactor多线程模式构建），开始正文。 1 public class NettyDemo1...
ServerBootstrap
anningzhu的博客
08-18 653
ServerBootstrap负责初始化netty服务器，并且开始监听端口的socket请求。 [java] view plain copy bootstrap bootstrap = new ServerBootstrap(         new NioServerSocketChannelFactory(             Exe
Netty--核心模块组件 BootStrap ServerBootstrap（一）
Tjimmy的博客
12-27 404
BootStrap ServerBootStarp BootStarp 意思是引导，一个Netty 应用通常由一个BootStarp 开始，主要作用是配置整个Netty程序，串联各个组件，Netty中BootStarp 类是客户端程序的启动引导类，ServerBootStarp 是服务端启动引导类。 常见方法 public ServerBootstrap group(EventLoopGroup...
Netty Bootstrap/ServerBootstrap
最新发布
王小工小工历程
07-16 1241
Netty中的Bootstrap和ServerBootstrap是Netty框架中的两个核心引导类，它们分别用于客户端和服务端的启动配置。
netty源码阅读之ServerBootStrap类
m0_48187193的博客
04-12 182
netty源码阅读之ServerBootStrap实例化的过程 在netty中有两个引导器，一个是服务端的引导器，一个是客户端的引导器。本次主要跟踪ServerBootstrap类的实例化在看它搞啥事。 调试代码如下： ServerBootStrap类 ...
netty源码学习之服务端客户端初始化
热门推荐
liushangzaibeijing的博客
09-25 5万+
本篇博文从netty的使用例子出发，服务端bind()方法和客户端的connect()方法，分别分析了一下netty服务端和客户端的建立过程（大量篇幅），最终给予对上述理解简要总结了一次基于netty的一次请求和响应过程图解，希望对大家学习netty知识有所帮助，如果帮到你的话希望点赞、转发、一键三连让我们一起在技术的海洋遨游，奥利给！！！
Netty 源码分析之 一 服务端创建（ServerBootstrap ）
刘剑峰的博客
04-05 4022
目录 服务器端 Channel 的初始化过程 ChannelPipeline 初始化（和客户端一致） Channel 的注册（和客户端一致） 关于 bossGroup 与 workerGroup（重点） handler 的添加过程（重点，牵扯到childHandler和Handler） 服务器端 在分析客户端的代码时, 我们已经对 Bootstrap 启动
一切从ServerBootstrap开始
kdy527的专栏
08-23 7866
ServerBootstrap负责初始化netty服务器，并且开始监听端口的socket请求。 [java] view plain copy bootstrap bootstrap = new ServerBootstrap(         new NioServerSocketChannelFactory(             E
Netty中ServerBootstrap类介绍
小飞侠的博客
06-09 2792
Netty中的核心类之一：ServerBootstrap类。
Netty Review - ServerBootstrap源码解析
小工匠
02-13 4023
ServerBootstrap是Netty中用于创建服务器端应用程序的引导类。它的设计目的是提供一种简洁、灵活的方式来配置和启动服务器，并处理与客户端的连接。
netty 源码解析一：ServerBootstrap 服务端
Pazz
01-20 419
ServerBootstrap 服务启动类 继承自 AbstractBootstrap group(EventLoopGroup) 赋值 EventLoopGroup (创建 NioEventLoopGroup） 线程组(池) channel(Class) 赋值 ChannelFactory (通过class的构造器,创建 Re...
Netty4学习笔记（3）-- ServerBootstrap
zxh的专栏
12-24 1万+
这篇文章接着上一篇，分析一下Netty4的ServerBootstrp是如何工作的。
浅谈Netty中ServerBootstrap服务端源码（含bind全流程）
持续Java学习中
03-27 2003
文章目录一、梳理Java中NIO代码二、Netty服务端代码1、new NioEventLoopGroup()2、group3、channel4、NioServerSocketChannel.class5、childHandler6、bind 一、梳理Java中NIO代码 Java中的NIO其本质是网络层面定义中的多路复用IO模型（一定要和NIO模型区分开）。NIO代码主要分为下列几步： 初始ServerSocketChannel 初始化Selector， 完成Selector和Channel的绑
Netty | ServerBootstrap
Willian的博客屋
12-27 455
博客引用处（以下内容在原有博客基础上进行补充或更改，谢谢这些大牛的博客指导）： 一切从ServerBootstrap开始 ServerBootstrap负责初始化netty服务器，并且开始监听端口的socket请求。 bootstrap bootstrap = new ServerBootstrap( new NioServerSocketChannelFactory( ...
netty 源码分析之（二.1）ServerBootstrap、Boss/workers线程池
liao49的专栏
03-02 990
1、 ServerBootstrap bootstrap = new ServerBootstrap(                 new NioServerSocketChannelFactory(                         Executors.newCachedThreadPool(),                         Executors.n...
Netty源码深度剖析与未来展望
Channel的创建通常由Bootstrap或ServerBootstrap辅助完成，并通过ChannelInitializer来初始化ChannelPipeline。Channel有自己的生命周期，包括注册、激活、非活动、关闭等状态，每个状态变化都会触发相应的事件。 3...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值