public class BootstrapClient {

    public static void main(String[] args) {

        EventLoopGroup group = new NioEventLoopGroup();

        // 创建一个Bootstrap类的实例以创建和连接新的客户端Channel
        Bootstrap bootstrap = new Bootstrap();

        // 设置EventLoopGroup，提供用于处理Channel事件的EventLoop
        bootstrap.group(group)
                .channel(NioSocketChannel.class)
                .handler(new SimpleChannelInboundHandler<ByteBuf>() {
                    @Override
                    protected void channelRead0(ChannelHandlerContext ctx, ByteBuf msg) throws Exception {
                        System.out.println("Received data");
                    }
                });
        ChannelFuture future = bootstrap.connect(new InetSocketAddress("www.maning.com", 80));
        
        future.addListener(new ChannelFutureListener() {
            @Override
            public void operationComplete(ChannelFuture future) throws Exception {
                if (future.isSuccess()) {

                    System.out.println("Connection established");
                } else {

                    System.err.println("Connection attempt failed");
                    future.cause().printStackTrace();
                }
            }
        });
    }
}

（2）`ServerBootstrap`

服务器引导过程，如图：

【Netty】之服务器启动过程（ServerBootstrap）_bootstrap_02

public class ServerBootstrapClient {

    public static void main(String[] args) {

        NioEventLoopGroup group = new NioEventLoopGroup();

        ServerBootstrap bootstrap = new ServerBootstrap();

        bootstrap.group(group)
                .channel(NioServerSocketChannel.class)
                .childHandler(new SimpleChannelInboundHandler<ByteBuf>() {
                    @Override
                    protected void channelRead0(ChannelHandlerContext ctx, ByteBuf msg) throws Exception {

                        System.out.println("Received data");
                    }
                });

        ChannelFuture future = bootstrap.bind(new InetSocketAddress(8080));
        future.addListener(new ChannelFutureListener() {
            @Override
            public void operationComplete(ChannelFuture future) throws Exception {
                if (future.isSuccess()) {
                    System.out.println("Server bound");
                } else {

                    System.out.println("Bound attempt failed");
                    future.cause().printStackTrace();
                }
            }
        });
    }
}

二、源码分析

配置阶段的工作，主要是初始化启动类和设置相关参数。

AbstractBootstrap：

属性

// 线程组，在ServerBootstrap，为 ServerSocketChannel 服务
volatile EventLoopGroup group;

// 用去获取 Channel 的工厂
private volatile ChannelFactory<? extends C> channelFactory;

// 绑定的地址
private volatile SocketAddress localAddress;

// channel 可设置的选项
private final Map<ChannelOption<?>, Object> options = new LinkedHashMap<ChannelOption<?>, Object>();

// channel 属性，便于保存用户自定义数据
private final Map<AttributeKey<?>, Object> attrs = new LinkedHashMap<AttributeKey<?>, Object>();

// 处理器
private volatile ChannelHandler handler;

方法

group() 设置线程组
channelFactory()及channel() 设置channel工厂和channel类型
localAddress() 设置地址
option() 添加channel选项
attr() 添加属性
handler() 设置channelHander

register() 内部调用 initAndRegister() 用来初始化channel并注册到线程组
bind() 首先会调用 initAndRegister()，之后绑定IP地址，使用 Promise 保证先initAndRegister()在bind()
initAndRegister()，主要是创建netty的channel，设置options和attrs，注册到线程组

init()

（1）初始化 `init`

ServerBootstrap 类图：

【Netty】之服务器启动过程（ServerBootstrap）_Netty_03

【Netty】之服务器启动过程（ServerBootstrap）_Netty_04

主要作用：创建和初始化

使用SelectorProvider打开通道
为Channel分配全局唯一的channelID
创建NioMessageUnsafe，用于netty底层的读写操作
创建ChannelPipeline，默认是DefaultChannelPipeline

// AbstractBootstrap.java
final ChannelFuture initAndRegister() {
    Channel channel = null;
    try {
        // 创建 netty channel
        channel = channelFactory.newChannel();
        // 初始化
        init(channel);
    } catch (Throwable t) {
        if (channel != null) {
       
            channel.unsafe().closeForcibly();
        }
       
        return new DefaultChannelPromise(channel, GlobalEventExecutor.INSTANCE).setFailure(t);
    }
    
    // 注册
    ChannelFuture regFuture = config().group().register(channel);
    // 是否有异常原因
    if (regFuture.cause() != null) {
        if (channel.isRegistered()) {
            channel.close();
        } else {
            channel.unsafe().closeForcibly();
        }
    }

    return regFuture;
}

创建channelchannel(NioServerSocketChannel.class)

根据设置的 channel 类型，进行创建。
因为使用 class 的方法，会使用 ReflectiveChannelFactory 作为工厂类
然后调用 class 的 newInstance 方法

public B channel(Class<? extends C> channelClass) {
    if (channelClass == null) {
        throw new NullPointerException("channelClass");
    }
    return channelFactory(new ReflectiveChannelFactory<C>(channelClass));
}

// ReflectiveChannelFactory.java
@Override
public T newChannel() {
    try {
        return clazz.newInstance();
    } catch (Throwable t) {
        throw new ChannelException("Unable to create Channel from class " + clazz, t);
    }
}

// NioServerSocketChannel.java
public NioServerSocketChannel() {
    this(newSocket(DEFAULT_SELECTOR_PROVIDER));
}

// NioServerSocketChannel.java
private static ServerSocketChannel newSocket(SelectorProvider provider) {
    try {
        // 打开服务器套接字通道
        // 具体的实现类有 SelectorProviderImpl EpollSelectorProvider PollSelectorProvider
        // 选择器的主要工作是根据操作系统类型和版本选择合适的 Provider
        // 如果 Linux 内核版本 >= 2.6，则为 EpollSelectorProvider
        return provider.openServerSocketChannel();
    } catch (IOException e) {
        throw new ChannelException(
                "Failed to open a server socket.", e);
    }
}

// ServerSocketChannelImpl.java
ServerSocketChannelImpl(SelectorProvider sp) throws IOException {
    super(sp);
    this.fd =  Net.serverSocket(true); // 文件描述符
    this.fdVal = IOUtil.fdVal(fd);     // 文件描述符 ID
    this.state = ST_INUSE;
}

创建ServerSocketChannel时候，会先初始化父类AbstractNioMessageChannel

会创建NioMessageUnsafe实例，该类为Channel提供了用于完成网络通讯相关的底层操作
如：connect(), read(), register(), bind(), close()等

为Channel创建DefaultChannelPipeline，初始化双向链表

在AbstractChannel中创建：
channelId，全局唯一
unsafe， Netty底层封装的网络I/O操作
pipeline，DefaultChannelPipeline

protected DefaultChannelPipeline(Channel channel) {
    this.channel = ObjectUtil.checkNotNull(channel, "channel");
    succeededFuture = new SucceededChannelFuture(channel, null);
    voidPromise =  new VoidChannelPromise(channel, true);

    tail = new TailContext(this);
    head = new HeadContext(this);

    head.next = tail;
    tail.prev = head;
}

将java-channel设置为非阻塞，将关注的操作设置为SelectionKey.OP_ACCEPT（服务器）
调用子类init()完善配置，如ServerBootstrap的init()

将启动器设置的选项和属性设置到 Netty 的 Channel 上面
向Pipeline添加初始化Handler，供注册后使用

void init(Channel channel) throws Exception {
    final Map<ChannelOption<?>, Object> options = options0();
    synchronized (options) {
        setChannelOptions(channel, options, logger);
    }

    final Map<AttributeKey<?>, Object> attrs = attrs0();
    synchronized (attrs) {
        for (Entry<AttributeKey<?>, Object> e: attrs.entrySet()) {
            @SuppressWarnings("unchecked")
            AttributeKey<Object> key = (AttributeKey<Object>) e.getKey();
            channel.attr(key).set(e.getValue());
        }
    }

    ChannelPipeline p = channel.pipeline();

    final EventLoopGroup currentChildGroup = childGroup;
    final ChannelHandler currentChildHandler = childHandler;
    final Entry<ChannelOption<?>, Object>[] currentChildOptions;
    final Entry<AttributeKey<?>, Object>[] currentChildAttrs;
    synchronized (childOptions) {
        currentChildOptions = childOptions.entrySet().toArray(newOptionArray(childOptions.size()));
    }
    synchronized (childAttrs) {
        currentChildAttrs = childAttrs.entrySet().toArray(newAttrArray(childAttrs.size()));
    }

    // init 初始化 添加 ChannelInitializer
    p.addLast(new ChannelInitializer<Channel>() {
        @Override
        public void initChannel(final Channel ch) throws Exception {
            final ChannelPipeline pipeline = ch.pipeline();
            ChannelHandler handler = config.handler();  // 获取 config时 设置 handler
            if (handler != null) {
                pipeline.addLast(handler); // 将其添加到链表末尾
            }

            // 加入一个 ServerBootstrapAcceptor处理器，用于处理 Accept
            ch.eventLoop().execute(new Runnable() {
                @Override
                public void run() {
                    pipeline.addLast(new ServerBootstrapAcceptor(
                            ch, currentChildGroup, currentChildHandler, currentChildOptions, currentChildAttrs));
                }
            });
        }
    });
}

（2）注册 `register`

这个阶段主要：将 netty channel 注册到 selector上：

将channel 注册到线程池组的selector上
触发pipeline上面channelHandler的channelRegistered

// AbstractBootstrap.java  initAndRegister()
ChannelFuture regFuture = config().group().register(channel);

register(channel) -> SingleThreadEventLoop.java -> unsafe.java的register()

// SingleThreadEventLoop.java
public ChannelFuture register(Channel channel) {
    return register(new DefaultChannelPromise(channel, this));
}

// SingleThreadEventLoop.java
@Override
public ChannelFuture register(final ChannelPromise promise) {
    ObjectUtil.checkNotNull(promise, "promise");
    promise.channel().unsafe().register(this, promise);
    return promise;
}

// AbstractChannel.java
@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);
        }
    }
}

主要方法：register0()

private void register0(ChannelPromise promise) {
    try {
        // 确保通道打开
        if (!promise.setUncancellable() || !ensureOpen(promise)) {
            return;
        }
        // 是否为首次注册
        boolean firstRegistration = neverRegistered;
        
        // 注册
        doRegister();
        neverRegistered = false;
        registered = true;

        // 将注册之前加入的 handler 加入进来
        pipeline.invokeHandlerAddedIfNeeded();

        // 注册成功
        safeSetSuccess(promise);
        
        // pipeline通知注册成功
        pipeline.fireChannelRegistered();
        
        // 是否已经绑定，因为 register 和 bind 阶段是异步的
        if (isActive()) {
            if (firstRegistration) {
                // 首次注册，通知
                pipeline.fireChannelActive();
            } else if (config().isAutoRead()) { // channel会deregister后重新注册到线程组时，且配置了AutoRead
               
                beginRead();
            }
        }
    } catch (Throwable t) {
        
        closeForcibly();
        closeFuture.setClosed();
        safeSetFailure(promise, t);
    }
}

（3）绑定 `bind`

此阶段，主要将 Netty Channel 中 ServerSocketChannel绑定本地端口

结束后使用 fireChannelActive 通知 Pipeline里的ChannelHandle，执行其channelActive方法

// AbstractBootstrap.java
public final void bind(final SocketAddress localAddress, final ChannelPromise promise) {

    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);
}