Netty源码剖析之三：通过ServerBootstrap分析服务端启动流程

最新推荐文章于 2022-04-01 21:15:53 发布
最新推荐文章于 2022-04-01 21:15:53 发布
阅读量186 收藏 1
点赞数
分类专栏： Netty
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/linux_one_piece/article/details/111664753
版权

ServerBootstrap在Netty中负责引导启动服务端程序，下面给出一个服务端启动的例子：

	EventLoopGroup bossGroup = new NioEventLoopGroup(); //bossGroup负责处理TCP/IP连接的
	EventLoopGroup workerGroup = new NioEventLoopGroup(); //workerGroup是负责处理Channel(通道)的I/O事件
 	ServerBootstrap sb = new ServerBootstrap();
    sb.group(bossGroup, workerGroup)
            .channel(NioServerSocketChannel.class)
            .childOption(ChannelOption.SO_KEEPALIVE, true) //保持长连接
            .childHandler(new ChannelInitializer<SocketChannel>() {
                @Override
                protected void initChannel(SocketChannel sh) throws Exception {
                    sh.pipeline()
                            .addLast(new LengthFieldBasedFrameDecoder(1024, 0, 4, 0, 4))
                            .addLast(new LengthFieldPrepender(4, false))
                            .addLast(new ServerHandler()); // 业务handler
                }
            });
    //绑定监听端口，调用sync同步阻塞方法等待绑定操作完
    ChannelFuture future = sb.bind(8081).sync();
    if (future.isSuccess()) {
        System.out.println("服务端启动成功");
    } else {
        System.out.println("服务端启动失败");
        future.cause().printStackTrace();
        bossGroup.shutdownGracefully(); //关闭线程组
        workerGroup.shutdownGracefully();
    }
    //成功绑定到端口之后,给channel增加一个管道关闭的监听器并同步阻塞,直到channel关闭,线程才会往下执行,结束进程。
    future.channel().closeFuture().sync();

1. ServerBootstrap类图

在这里插入图片描述

2. ServerBootstrap成员变量

public abstract class AbstractBootstrap<B extends AbstractBootstrap<B, C>, C extends Channel> implements Cloneable {
	// 主线程池
	volatile EventLoopGroup group; 
	// 负责创建channel的工厂类，服务端为NioServerSocketChannel，客户端为NioSocketChannel
	private volatile ChannelFactory<? extends C> channelFactory;
	private volatile SocketAddress localAddress;
	// socket及其它的一些属性设置
	private final Map<ChannelOption<?>, Object> options = new LinkedHashMap<ChannelOption<?>, Object>();
	// 附加属性设置
	private final Map<AttributeKey<?>, Object> attrs = new LinkedHashMap<AttributeKey<?>, Object>();
	// handler业务逻辑处理类
	private volatile ChannelHandler handler;
}

public class ServerBootstrap extends AbstractBootstrap<ServerBootstrap, ServerChannel> {
    private final Map<ChannelOption<?>, Object> childOptions = new ConcurrentHashMap<ChannelOption<?>, Object>();
    private final Map<AttributeKey<?>, Object> childAttrs = new ConcurrentHashMap<AttributeKey<?>, Object>();
    private final ServerBootstrapConfig config = new ServerBootstrapConfig(this);
    // 工作线程组
    private volatile EventLoopGroup childGroup;
    // 客户端连接时会触发执行
    private volatile ChannelHandler childHandler;
}

3. 服务端绑定逻辑AbstractBootstrap.bind()

  1. Netty服务端何时注册SelectionKey.OP_ACCEPT ?
  2. 主线程在哪里获取TCP请求 ，即执行selector.select()方法？

带着疑问，进入到AbstractBootstrap.bind()绑定方法

public ChannelFuture bind(int inetPort) {
    return bind(new InetSocketAddress(inetPort));
}
public ChannelFuture bind(SocketAddress localAddress) {
    validate(); // 验证
    return doBind(ObjectUtil.checkNotNull(localAddress, "localAddress"));
}
private ChannelFuture doBind(final SocketAddress localAddress) {
    final ChannelFuture regFuture = initAndRegister();
    final Channel channel = regFuture.channel();
    if (regFuture.cause() != null) {
        return regFuture;
    }

    if (regFuture.isDone()) {
        ChannelPromise promise = channel.newPromise();
        doBind0(regFuture, channel, localAddress, promise);
        return promise;
    } else {
        final PendingRegistrationPromise promise = new PendingRegistrationPromise(channel);
        regFuture.addListener(new ChannelFutureListener() {
            @Override
            public void operationComplete(ChannelFuture future) throws Exception {
                Throwable cause = future.cause();
                if (cause != null) {
                    promise.setFailure(cause);
                } else {
                    promise.registered();
                    doBind0(regFuture, channel, localAddress, promise);
                }
            }
        });
        return promise;
    }
}
3.1 AbstractBootstrap.initAndRegister()

大概流程：

  1. 实例化NioServerSocketChannel对象，创建服务端的Java Nio Channel、设置通道非阻塞，初始化字段pipeline和unsafe等。
  2. init()方法，往ChannelPipeLine链表中中添加一个ChannelInitializer类型的事件处理。
  3. register(channel)，将NioServerSocketChannel绑定主线程池的一个NioEventLoop线程，
    给Nio Channel感兴趣的事件0，并绑定当前NioServerSocketChannel对象给SelectedKey的attach，添加ServerBootstrapAcceptor到pipeline中。
  4. doBind0()绑定地址和端口，当通道注册工作完成后绑定地址和端口，同时向通道中注册SelectionKey.OP_ACCEPT事件。
final ChannelFuture initAndRegister() {
    Channel channel = null;
    try {
        channel = channelFactory.newChannel(); // 实例化NioServerSocketChannel对象
        init(channel);
    } catch (Throwable t) {
    	// 异常返回
        if (channel != null) {
            channel.unsafe().closeForcibly();
            return new DefaultChannelPromise(channel, GlobalEventExecutor.INSTANCE).setFailure(t);
        }
        return new DefaultChannelPromise(new FailedChannel(), GlobalEventExecutor.INSTANCE).setFailure(t);
    }
    // 注册
    ChannelFuture regFuture = config().group().register(channel);
    // 注册失败，关闭Nio通道
    if (regFuture.cause() != null) {
        if (channel.isRegistered()) {
            channel.close();
        } else {
            channel.unsafe().closeForcibly();
        }
    }
    return regFuture;
}
3.1.1 NioServerSocketChannel对象实例化

大概流程：

  1. 创建NIO原生的Channel通道。
  2. 初始化变量AbstractNioChannel.readInterestOp = SelectionKey.OP_ACCEPT。
  3. 设置通道非阻塞。
  4. 初始化变量AbstractChannel.unsafe = new NioMessageUnsafe()。
  5. 初始化变量AbstractChannel.pipeline = new DefaultChannelPipeline(this)。
// 多路复用选择器提供者SelectorProvider，用来创建多路复用选择器Selector
private static final SelectorProvider DEFAULT_SELECTOR_PROVIDER = SelectorProvider.provider();
// 创建Java Nio Channel
private static ServerSocketChannel newSocket(SelectorProvider provider) {
    try {
        return provider.openServerSocketChannel();
    } catch (IOException e) {
        throw new ChannelException(
                "Failed to open a server socket.", e);
    }
}
public NioServerSocketChannel() {
    this(newSocket(DEFAULT_SELECTOR_PROVIDER));
}
public NioServerSocketChannel(ServerSocketChannel channel) {
    super(null, channel, SelectionKey.OP_ACCEPT);
    config = new NioServerSocketChannelConfig(this, javaChannel().socket());
}

继续调用父类AbstractNioChannel的构造函数

protected AbstractNioChannel(Channel parent, SelectableChannel ch, int readInterestOp) {
    super(parent);
    this.ch = ch;
    this.readInterestOp = readInterestOp;
    try {
        ch.configureBlocking(false); // 设置通道非阻塞
    } catch (IOException e) {
        try {
            ch.close();
        } catch (IOException e2) {
            logger.warn(
                        "Failed to close a partially initialized socket.", e2);
        }
        throw new ChannelException("Failed to enter non-blocking mode.", e);
    }
}

继续调用父类AbstractChannel的构造函数

protected AbstractChannel(Channel parent) {
    this.parent = parent;
    id = newId();
    unsafe = newUnsafe();
    pipeline = newChannelPipeline();
}
3.1.2 ServerBootstrap.init()

往ChannelPipeLine链表中中添加一个ChannelInitializer类型的事件处理，当Channel注册时会调用该initChannel()方法。

@Override
void init(Channel channel) {
    setChannelOptions(channel, options0().entrySet().toArray(newOptionArray(0)), logger);
    setAttributes(channel, attrs0().entrySet().toArray(newAttrArray(0)));

    ChannelPipeline p = channel.pipeline();

    final EventLoopGroup currentChildGroup = childGroup;
    final ChannelHandler currentChildHandler = childHandler;
    final Entry<ChannelOption<?>, Object>[] currentChildOptions =
            childOptions.entrySet().toArray(newOptionArray(0));
    final Entry<AttributeKey<?>, Object>[] currentChildAttrs = childAttrs.entrySet().toArray(newAttrArray(0));
    // AbstractUnsafe.register0()方法中的代码pipeline.invokeHandlerAddedIfNeeded();
    // 此段代码会调用以下的initChannel方法
    p.addLast(new ChannelInitializer<Channel>() {
        @Override
        public void initChannel(final Channel ch) {
            final ChannelPipeline pipeline = ch.pipeline();
            ChannelHandler handler = config.handler();
            if (handler != null) {
                pipeline.addLast(handler);
            }
            ch.eventLoop().execute(new Runnable() {
                @Override
                public void run() {
                    pipeline.addLast(new ServerBootstrapAcceptor(
                            ch, currentChildGroup, currentChildHandler, currentChildOptions, currentChildAttrs));
                }
            });
        }
    });
}

继续查看DefaultChannelPipeline的addLast()方法，大概流程为：

  1. 将handler添加到pipeline的双向链表中。
  2. 如果未注册说明NioServerSocketChannel未绑定到NioEventLoop中，一旦注册则需要当前handler的handlerAdded()方法。
@Override
public final ChannelPipeline addLast(EventExecutorGroup group, String name, ChannelHandler handler) {
    final AbstractChannelHandlerContext newCtx;
    synchronized (this) {
        checkMultiplicity(handler);

        newCtx = newContext(group, filterName(name, handler), handler);

        addLast0(newCtx);

        // If the registered is false it means that the channel was not registered on an eventLoop yet.
        // In this case we add the context to the pipeline and add a task that will call
        // ChannelHandler.handlerAdded(...) once the channel is registered.
        if (!registered) {
            newCtx.setAddPending();
            callHandlerCallbackLater(newCtx, true);
            return this;
        }

        EventExecutor executor = newCtx.executor();
        if (!executor.inEventLoop()) {
            callHandlerAddedInEventLoop(newCtx, executor);
            return this;
        }
    }
    callHandlerAdded0(newCtx);
    return this;
}
// 将handler封装成上下文环境ctx，插入到pipeline管道中
private AbstractChannelHandlerContext newContext(EventExecutorGroup group, String name, ChannelHandler handler) {
    return new DefaultChannelHandlerContext(this, childExecutor(group), name, handler);
}
3.1.3 EventLoopGroup.register()注册通道

大概流程：

  1. 调用主线程池中的线程NioEventLoop.register()方法，最终调用的是NioServerSocketChannel.unsafe.register()方法。
  2. 将NioServerSocketChannel绑定主线程池的一个NioEventLoop线程，之后Channel中的IO事件都交给该线程。
  3. 注册新连接的Channel到选择的NioEventLoop线程的Selector上，注册感兴趣的事件0，并绑定当前NioServerSocketChannel对象给SelectedKey，因此IO事件到来的时候能够获取到NioServerSocketChannel对象。
  4. 通知pipeline处理handler的handlerAdded()方法，最终执行ServerBootstrap.ChannelInitializer.initChannel()方法，即想pipeline中添加ServerBootstrapAcceptor，并移除当前ServerBootstrap.ChannelInitializer。

查看NioEventLoopGroup类的register()方法，通过线程选择器轮询选择一个线程执行。

@Override
public ChannelFuture register(Channel channel) {
    return next().register(channel);
}

查看NioEventLoop类的register()方法，这里调用NioServerSocketChannel类的unsafe成员的register()方法，服务端的unsafe为NioMessageUnsafe对象。

@Override
public ChannelFuture register(Channel channel) {
    return register(new DefaultChannelPromise(channel, this));
}
@Override
public ChannelFuture register(final ChannelPromise promise) {
    ObjectUtil.checkNotNull(promise, "promise");
    promise.channel().unsafe().register(this, promise);
    return promise;
}

继续查看NioMessageUnsafe类的register()方法，调用父类AbstractUnsafe的register()方法，大概流程：

  1. 绑定NioServerSocketChannel所在的线程为轮询获取到的线程，即NioEventLoop，Netty的无锁串行化体现在这里。
  2. 由于线程未启动，所以会执行启动NioEventLoop线程，并添加注册任务到NioEventLoop的任务队列中。
  3. 注册新连接的Channel到选择的NioEventLoop线程的Selector上，注册感兴趣的事件0，，将当前NioServerSocketChannel对象绑定给SelectedKey的attach。
@Override
public final void register(EventLoop eventLoop, final ChannelPromise promise) {
    if (eventLoop == null) {
        throw new NullPointerException("eventLoop");
    }
    if (isRegistered()) {
        promise.setFailure(new IllegalStateException("registered to an event loop already"));
        return;
    }
    if (!isCompatible(eventLoop)) {
        promise.setFailure(
                new IllegalStateException("incompatible event loop type: " + eventLoop.getClass().getName()));
        return;
    }
    // 无锁串行化
    AbstractChannel.this.eventLoop = eventLoop;
    // 线程已经启动
    if (eventLoop.inEventLoop()) {
        register0(promise);
    } else {
    	// 提交任务到线程的任务队列中，并启动线程
        try {
            eventLoop.execute(new Runnable() {
                @Override
                public void run() {
                    register0(promise);
                }
            });
        } catch (Throwable t) {
            logger.warn(
                    "Force-closing a channel whose registration task was not accepted by an event loop: {}",
                    AbstractChannel.this, t);
            closeForcibly();
            closeFuture.setClosed();
            safeSetFailure(promise, t);
        }
    }
}
private void register0(ChannelPromise promise) {
    try {
        if (!promise.setUncancellable() || !ensureOpen(promise)) {
            return;
        }
        boolean firstRegistration = neverRegistered;
        // 注册感兴趣的事件并绑定SelctedKey的attach为NioServerSocketChannel
        doRegister();
        neverRegistered = false;
        registered = true;
        // 通知pipeline执行handlerAdded()方法
        pipeline.invokeHandlerAddedIfNeeded();
        safeSetSuccess(promise);
        pipeline.fireChannelRegistered();
        if (isActive()) {
            if (firstRegistration) {
                pipeline.fireChannelActive();
            } else if (config().isAutoRead()) {
                beginRead();
            }
        }
    } catch (Throwable t) {
        closeForcibly();
        closeFuture.setClosed();
        safeSetFailure(promise, t);
    }
}

AbstractNioChannel类的doRegister()方法

@Override
protected void doRegister() throws Exception {
    boolean selected = false;
    for (;;) {
        try {
            selectionKey = javaChannel().register(eventLoop().unwrappedSelector(), 0, this);
            return;
        } catch (CancelledKeyException e) {
            if (!selected) {
                eventLoop().selectNow();
                selected = true;
            } else {
                throw e;
            }
        }
    }
}
3.2 AbstractBootstrap.doBind0()绑定地址和端口

等待通道注册成功后绑定地址，最终调用的是NioServerSocketChannel.unsafe.bind()方法。

  1. 绑定地址和端口。
  2. 注册SelectionKey.OP_ACCEPT 事件。
@Override
public final void bind(final SocketAddress localAddress, final ChannelPromise promise) {
    assertEventLoop();
    if (!promise.setUncancellable() || !ensureOpen(promise)) {
        return;
    }
    if (Boolean.TRUE.equals(config().getOption(ChannelOption.SO_BROADCAST)) &&
        localAddress instanceof InetSocketAddress &&
        !((InetSocketAddress) localAddress).getAddress().isAnyLocalAddress() &&
        !PlatformDependent.isWindows() && !PlatformDependent.maybeSuperUser()) {
        logger.warn(
                "A non-root user can't receive a broadcast packet if the socket " +
                "is not bound to a wildcard address; binding to a non-wildcard " +
                "address (" + localAddress + ") anyway as requested.");
    }
    boolean wasActive = isActive();
    try {
        doBind(localAddress);
    } catch (Throwable t) {
        safeSetFailure(promise, t);
        closeIfClosed();
        return;
    }
    if (!wasActive && isActive()) {
        invokeLater(new Runnable() {
            @Override
            public void run() {
                pipeline.fireChannelActive();
            }
        });
    }
    safeSetSuccess(promise);
}

@Override
protected void doBind(SocketAddress localAddress) throws Exception {
    if (PlatformDependent.javaVersion() >= 7) {
        javaChannel().bind(localAddress, config.getBacklog());
    } else {
        javaChannel().socket().bind(localAddress, config.getBacklog());
    }
}

注册SelectionKey.OP_ACCEPT 事件的逻辑有点长，继续看fireChannelActive()。

@Override
public final ChannelPipeline fireChannelActive() {
    AbstractChannelHandlerContext.invokeChannelActive(head);
    return this;
}

执行HeadContext.active()方法。

@Override
public void channelActive(ChannelHandlerContext ctx) {
    ctx.fireChannelActive();
    readIfIsAutoRead();
}
private void readIfIsAutoRead() {
    if (channel.config().isAutoRead()) {
        channel.read();
    }
}

channel.read();最终执行的是DefaultChannelPipeline.read()方法。

@Override
public ChannelHandlerContext read() {
    final AbstractChannelHandlerContext next = findContextOutbound(MASK_READ);
    EventExecutor executor = next.executor();
    if (executor.inEventLoop()) {
        next.invokeRead();
    } else {
        Tasks tasks = next.invokeTasks;
        if (tasks == null) {
            next.invokeTasks = tasks = new Tasks(next);
        }
        executor.execute(tasks.invokeReadTask);
    }

    return this;
}

这里的next是HeadContext对象。

private void invokeRead() {
    if (invokeHandler()) {
        try {
            ((ChannelOutboundHandler) handler()).read(this);
        } catch (Throwable t) {
            notifyHandlerException(t);
        }
    } else {
        read();
    }
}
@Override
public void read(ChannelHandlerContext ctx) {
    unsafe.beginRead();
}

unsafe.beginRead()最终调用的是AbstractNioChannel.doBeginRead()，如果当前selectionKey为0 ，则重新绑定readInterestOp，这里的readInterestOp就是AbstractNioChannel的构造函数中传进来的SelectionKey.OP_ACCEPT。

@Override
protected void doBeginRead() throws Exception {
    // Channel.read() or ChannelHandlerContext.read() was called
    final SelectionKey selectionKey = this.selectionKey;
    if (!selectionKey.isValid()) {
        return;
    }
    readPending = true;
    final int interestOps = selectionKey.interestOps();
    if ((interestOps & readInterestOp) == 0) {
        selectionKey.interestOps(interestOps | readInterestOp);
    }
}
君子一笑
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Netty服务端源码阅读笔记（四）ServerBootstrap(4)
xyjy11的博客
03-28 105
接上章节 Netty服务端源码阅读笔记（四）ServerBootstrap(1) Netty服务端源码阅读笔记（四）ServerBootstrap(2) Netty服务端源码阅读笔记（四）ServerBootstrap(3) serverBootStrap.bind() -->doBind0 绑定服务端channel的端口号 private static void doBind0( final ChannelFuture regFuture, fi...
Netty 源码分析之 一 服务端创建（ServerBootstrap ）
刘剑峰的博客
04-05 3965
目录 服务器端 Channel 的初始化过程 ChannelPipeline 初始化（和客户端一致） Channel 的注册（和客户端一致） 关于 bossGroup 与 workerGroup（重点） handler 的添加过程（重点，牵扯到childHandler和Handler） 服务器端 在分析客户端的代码时, 我们已经对 Bootstrap 启动
netty系列之：Bootstrap,ServerBootstrap和netty中的实现
a6636656的博客
04-01 814
虽然netty很强大，但是使用netty来构建程序却是很简单，只需要掌握特定的netty套路就可以写出强大的netty程序。每个netty程序都需要一个Bootstrap，什么是Bootstrap呢？Bootstrap翻译成中文来说就是鞋拔子，在计算机世界中，Bootstrap指的是引导程序，通过Bootstrap可以轻松构建和启动程序。 在netty中有两种Bootstrap：客户端的Bootstrap和服务器端的ServerBootstrap。两者有什么不同呢？netty中这两种Bootstrap到底
02-Bootstrap和ServerBootstrap
my_momo_csdn的博客
10-23 1075
文章目录Bootstrap和ServerBootstrap一、AbstractBootstrap1.1 doBind和doBind01.2 initAndRegister二、Bootstrap2.1 connect2.2 doResolveAndConnect和doResolveAndConnect02.3 init2.4 doConnect三、ServerBootstrap3.1 属性和构造方法...
netty的引导程序ServerBootStrap
惜暮
12-19 1万+
BootStrap在netty的应用程序中负责引导服务器和客户端。netty包含了两种不同类型的引导： 1. 使用服务器的ServerBootStrap，用于接受客户端的连接以及为已接受的连接创建子通道。 2. 用于客户端的BootStrap，不接受新的连接，并且是在父通道类完成一些操作。ServerBootStrap的运行原理下面先看一下这两个引导类的类继承图： 服务端的ServerBoot
netty源码剖析视频.zip
05-22
《Netty源码剖析视频》课程是一份深度探讨Netty框架源码及其实战应用的资源集合。课程分为两个主要部分，旨在帮助开发者深入理解Netty的内部机制，并通过实战项目提升其在实际开发中的应用能力。 第一部分，深入浅...
06.NettyServerBootstrap启动的详细过程类图分析.rar
最新发布
09-24
在提供的资源 "课时07：NettyServerBootstrap启动的详细过程类图分析.avi" 中，可能包含了动画或讲解视频，详细展示了这些步骤的可视化过程，帮助理解NettyServerBootstrap启动时涉及的类和对象之间的关系，以及它们...
netty源码分析之服务端启动全解析
12-17
netty基本使用以及入门资料，具有netty的源码的分析以及服务器启动过程的介绍
learn_netty_source_code:Netty源码分析教程
03-23
在工作中，虽然我经常使用到Netty库，但是很多时候对Netty的一些概念还是位于知其然，不知其所以然的状态，因此就萌生了学习Netty源码的想法。刚开始看原始代码的时候，自然是比较痛苦的，首先有两个：第一，网上...
Springboot+Netty搭建TCP服务端
热门推荐
蚂蚁舞
06-02 3万+
Netty是业界最流行的nio框架之一，它具有功能强大、性能优异、可定制性和可扩展性的优点 Netty的优点： 1.API使用简单，开发入门门槛低。 2.功能十分强大，预置多种编码解码功能，支持多种主流协议。 3.可定制、可扩展能力强，可以通过其提供的ChannelHandler进行灵活的扩展。 4.性能优异，特别在综合性能上的优异性。 5.成熟，稳定，适用范围广。 6.可用于智能G...
Netty源码(二)之ServerBootstrap初始化的过程
了不起的盖茨比的博客
08-15 571
上篇博客《Netty源码(一)之NioEventLoopGroup初始化的过程》我们说了NioEventLoopGoup的初始化的过程。今天我们来讲讲ServerBootstrap的初始化的过程，我们继续重现上篇博客的代码，具体的代码如下： import io.netty.bootstrap.ServerBootstrap; import io.netty.channel.ChannelFuture; import io.netty.channel.ChannelInitializer; import io
关于netty配置的理解serverBootstrap.option和serverBootstrap.childOption
zuixiaoyao_001的博客
05-13 5895
关于netty配置的理解serverBootstrap.option和serverBootstrap.childOption The parameters that we set using ServerBootStrap.option apply to the ChannelConfig of a newly created ServerChan...
使用springboot+netty处理tcp/ip服务端编程
qq_24516549的博客
04-03 1万+
1.添加依赖 略 2.netty服务器启动 springboot的bean代码,另开一个线程启动 @Component public class NettyServer { private static Logger logger = LoggerFactory.getLogger(NettyServer.class); // 保存response的map public static M...
4、ServerBootstrap之通道的创建与注册
zhen_hong的博客
08-11 594
一、ServerBootstrap概览 在第一节的例子中有以下代码 public void bind(int port) { //NIO线程组，Reactor线程组，一个用于接受客户端的请求，另一个用于进行SocketChannel的操作 EventLoopGroup bossGroup = new NioEventLoopGroup(); EventLoopGroup work...
四、netty源码分析之ServerBootstrap
feijianke666的博客
09-05 291
一、功能概述 前两篇我们分别介绍了EventLoopGroup和EventLoop在netty中的作用。但是仅仅知道这些，可能对netty如何完成一整个网络事件监控到任务分发处理还是有些模糊。本篇我们要分析一下netty的启动流程。在我们使用netty编程的时候，我们的使用ServerBootstrap和Bootstrap来实现服务端和客户端的启动。我们先来看一下这两个类的相关类图： netty...
netty(七）--Bootstrap
ljz2016的博客
09-26 1275
引导一个应用程序是指对它进行配置，并使他运行起来的过程。 服务器致力于使用一个父 Channel 来接受 来自客户端的连接， 并创建子 Channel 以用于它们之间的通信；而客户端将最可能只需要一个 单独的、 没有父 Channel 的 Channel 来用于所有的网络交互。 bootstrap类的API 名称 描述 Bootstrap group(EventLoopGrou...
Netty 服务监听多个端口
大鱼的博客
03-04 7655
本文记录使用 Netty 实现多个端口监听
bootStrap家族介绍----3BootStrap初始化--initAndRegister
yangh13的博客
07-20 964
无论是服务端还是客户端，都会有一步需要调用到父类AbstractBootStrap的initAndRegister()方法，将相应的channel注册到bossReactor线程池中去。 initAndRegister()方法主要分为3个部分： 创建Channel 绑定用户自定义的Handler() 将该Channel注册到Reactor中去   final Ch...
Netty5.0源码深度解析：架构与实战
在Netty中，服务端的创建通常涉及`ServerBootstrap`类，它用于配置服务器并启动监听。`NioServerSocketChannel`是Netty的服务器端通道，用于接受客户端连接。新客户端接入时，Netty会自动管理这些连接，分配合适的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值