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

其他 2020-01-22 10:36:01 阅读次数: 0

文章目录


一、简介

引导一个应用程序是指对它进行配置，并使它运行起来的过程。

服务器致力于使用一个父Channel来接受来自客户端的连接，并创建子Channel用于它们之间的通信

可分为：Bootstrap 和 ServerBootstrap

关于IllegalStateException，在调用bind() 或者 connect()方法之前，必须调用：

  1. group()
  2. channel() 或者 channelFactory()
  3. handler()

（1）Bootstrap

Bootstrap类负责为客户端和使用无连接协议的应用程序创建Channel

如图：
在这里插入图片描述

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

服务器引导过程，如图：

在这里插入图片描述

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 类图：

在这里插入图片描述

在这里插入图片描述

主要作用：创建和初始化

  1. 使用SelectorProvider打开通道
  2. 为Channel分配全局唯一的channelID
  3. 创建NioMessageUnsafe，用于netty底层的读写操作
  4. 创建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;
}
  1. 创建channel channel(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;
}
  1. 创建ServerSocketChannel时候，会先初始化父类AbstractNioMessageChannel

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

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

在AbstractChannel中创建：

  1. channelId，全局唯一
  2. unsafe， Netty底层封装的网络I/O操作
  3. 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;
}

  1. 将java-channel设置为非阻塞，将关注的操作设置为SelectionKey.OP_ACCEPT（服务器）

  2. 调用子类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上：

  1. 将 channel 注册到线程池组的 selector上
  2. 触发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);
}
fanfan4569
发布了404 篇原创文章 · 获赞 270 · 访问量 42万+
他的留言板 关注

猜你喜欢

转载自blog.csdn.net/fanfan4569/article/details/101159602
今日推荐
LFOSSA 源来如此公开课 | 掌握云原生未来：CNCF 认证全面攻略与备考秘籍
国产云输入法——仅华为无云端数据上传安全问题
开源日报 | 工业开源项目OGG 1.0；姐姐，你要和我一起配置火狐吗；苹果AI遥遥落后？Fedora 40
开放签电子签章：停止新增，优化体验，前进更进（五一假期前工作）
开源日报 | 中学生开源前端动画引擎；全球首个Llama3 8B中文版开源模型；联想电脑恐出局；Linus讽刺AI炒作
“百模大战”必有一战 | 2024中国“百模大战”竞争格局分析
周排行
Family Tree 题解
BZOJ 1093 最大半连通子图 SCC + DP
幂等处理
Spring----学习（2）----XML 配置Bean 自动装配
SQL Server 远程更新目标表数据
HIbernate3.6 环境搭建
特殊符号正则表达式
【Linux】第一章 进程的理解
843. n-皇后问题（dfs+输出各种情况）
空间数据库2
每日归档
更多
2024-04-26(39)
2024-04-25(22)
2024-04-24(36)
2024-04-23(26)
2024-04-22(39)
2024-04-21(0)
2024-04-20(6)
2024-04-19(5)
2024-04-18(0)
2024-04-17(5)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022