Netty源码分析(三)之NioServerSocketChannel

最新推荐文章于 2024-09-01 15:04:22 发布
原创 最新推荐文章于 2024-09-01 15:04:22 发布 · 445 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#NioServerSocketChannel #netty

文章目录

netty版本

  1. 使用的netty版本是io.netty:netty-all:4.1.33.Final

NioServerSocketChannel的创建过程

  1. NioServerSocketChannel创建过程

无参构造方法的执行流程

  1. 构造方法

       public NioServerSocketChannel() {
        this(newSocket(DEFAULT_SELECTOR_PROVIDER));
    }

  2. newSocket()方法:这里为什么不用ServerSocketChannel.open()来创建,而是使用缓存的SelectorProvider?继续看下面分析

        private static final SelectorProvider DEFAULT_SELECTOR_PROVIDER = SelectorProvider.provider();
    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(ServerSocketChannel channel) {
        super(null, channel, SelectionKey.OP_ACCEPT);
        config = new NioServerSocketChannelConfig(this, javaChannel().socket());
    }

    构造方法调用父类的构造,设置感兴趣的事件SelectionKey.OP_ACCEPT，设置JDK底层的Channel为非阻塞模式

        protected AbstractNioMessageChannel(Channel parent, SelectableChannel ch, int readInterestOp) {
        super(parent, ch, readInterestOp);
    }

    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) {
                if (logger.isWarnEnabled()) {
                    logger.warn(
                            "Failed to close a partially initialized socket.", e2);
                }
            }

            throw new ChannelException("Failed to enter non-blocking mode.", e);
        }
    }

  3. ServerSocketChannel的open()方法:每个新Channel创建都需要SelectorProvider.provider()（包含synchronized块）。 当应用程序创建大量连接时，这可能会导致不必要的阻塞。查看issue

        public static ServerSocketChannel open() throws IOException {
        return SelectorProvider.provider().openServerSocketChannel();
    }

  4. 从构造方法中可以看到每个NioServerSocketChannel实例都关联一个NioServerSocketChannelConfig,NioServerSocketChannelConfig是TCP相关参数的配置，以及Netty中NioServerSocketChannel相关的配置

        private final class NioServerSocketChannelConfig extends DefaultServerSocketChannelConfig {
        private NioServerSocketChannelConfig(NioServerSocketChannel channel, ServerSocket javaSocket) {
            super(channel, javaSocket);
        }

        @Override
        protected void autoReadCleared() {
            clearReadPending();
        }

        @Override
        public <T> boolean setOption(ChannelOption<T> option, T value) {
            if (PlatformDependent.javaVersion() >= 7 && option instanceof NioChannelOption) {
                return NioChannelOption.setOption(jdkChannel(), (NioChannelOption<T>) option, value);
            }
            return super.setOption(option, value);
        }

        @Override
        public <T> T getOption(ChannelOption<T> option) {
            if (PlatformDependent.javaVersion() >= 7 && option instanceof NioChannelOption) {
                return NioChannelOption.getOption(jdkChannel(), (NioChannelOption<T>) option);
            }
            return super.getOption(option);
        }

        @SuppressWarnings("unchecked")
        @Override
        public Map<ChannelOption<?>, Object> getOptions() {
            if (PlatformDependent.javaVersion() >= 7) {
                return getOptions(super.getOptions(), NioChannelOption.getOptions(jdkChannel()));
            }
            return super.getOptions();
        }

        private ServerSocketChannel jdkChannel() {
            return ((NioServerSocketChannel) channel).javaChannel();
        }
    }

NioServerSocketChannel的初始化

  1. ServerBootstrap的init(Channel channel)方法

    • 设置自定义的ChannelOption和AttributeKey
    • 设置自定义的ChildChannelOption和ChildAttributeKey
    • 设置ChannelPipeline
    • 添加ServerBootstrapAcceptor
        @Override
    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(0));
        }
        synchronized (childAttrs) {
            currentChildAttrs = childAttrs.entrySet().toArray(newAttrArray(0));
        }

        p.addLast(new ChannelInitializer<Channel>() {
            @Override
            public void initChannel(final Channel ch) throws Exception {
                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));
                    }
                });
            }
        });
    }

AbstractChannel.doRegister

  1. 注册Channel

        @Override
    protected void doRegister() throws Exception {
        boolean selected = false;
        for (;;) {
            try {
                //jdk中SelectableChannel类的	register(Selector sel, int ops, Object attachment)，使用一个给定的Selector注册Channel。事件是0表示不关心任何事件(这里仅仅是将Channel绑定到Selector上)。 this表示attachment，即Netty的AbstractNioChannel，当Selector轮询到当前javaChannel()上时，可以通过attachment获取Netty的AbstractNioChannel。这是一个很巧妙的设计
                selectionKey = javaChannel().register(eventLoop().unwrappedSelector(), 0, this);
                return;
            } catch (CancelledKeyException e) {
                //当试图使用不再SelectionKey时，抛出此异常。
                if (!selected) {
                    //`SelectionKey`代表Channel与Selector的注册关系，可以调用`cancel()`取消这种关系,但是这种注销关系并不是立即生效，因为尚未调用Select.select(),所以一旦发现此异常，需要调用selectNow()让这种取消关系生效。
                    eventLoop().selectNow();
                    selected = true;
                } else {
                    // We forced a select operation on the selector before but the SelectionKey is still cached
                    // for whatever reason. JDK bug ?
                    throw e;
                }
            }
        }
    }

AbstractChannel.bind

  1. 端口绑定

        public final void bind(final SocketAddress localAddress, final ChannelPromise promise) {
            assertEventLoop();

            if (!promise.setUncancellable() || !ensureOpen(promise)) {
                return;
            }

            // See: https://github.com/netty/netty/issues/576
            if (Boolean.TRUE.equals(config().getOption(ChannelOption.SO_BROADCAST)) &&
                localAddress instanceof InetSocketAddress &&
                !((InetSocketAddress) localAddress).getAddress().isAnyLocalAddress() &&
                !PlatformDependent.isWindows() && !PlatformDependent.maybeSuperUser()) {
                // Warn a user about the fact that a non-root user can't receive a
                // broadcast packet on *nix if the socket is bound on non-wildcard address.
                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.");
            }
            //Channel是否激活 @1
            boolean wasActive = isActive();
            try {
            // 调用JDK底层的bind @2
                doBind(localAddress);
            } catch (Throwable t) {
                safeSetFailure(promise, t);
                closeIfClosed();
                return;
            }
            //端口绑定完成会返回true @3
            if (!wasActive && isActive()) {
                invokeLater(new Runnable() {
                    @Override
                    public void run() {
                        //@4
                        pipeline.fireChannelActive();
                    }
                });
            }

            safeSetSuccess(promise);
        }

@1: 对于NioServerSocketChannel来说，在服务端启动的时候一定是未激活的(因为端口绑定未完成)
@2:NioServerSocketChannel的doBind()方法

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

@3:此时端口绑定已经完成。校验是否是端口绑定完成之前是false，绑定完成之后是true
@4:这里的pipeline是DefaultChannelPipeline实例对象，此pipeline的第一个节点是HeadContext(DefaultChannelPipeline的构造方法如下)。实际上调用的就是HeadContext的channelActive()方法

	```java
	        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. 分析HeadContext的channelActive

        @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        ctx.fireChannelActive();
        //@1
        readIfIsAutoRead();
    }
    //触发一个read事件 @2
     private void readIfIsAutoRead() {
        if (channel.config().isAutoRead()) {
            channel.read();
        }
    }
    //调用pipeline的read方法 @3
    @Override
    public Channel read() {
        pipeline.read();
        return this;
    }
    
    //DefaultChannelPipeline的read() @4
    @Override
    public final ChannelPipeline read() {
        tail.read();
        return this;
    }
    //AbstractChannelHandlerContext的read() @5
    @Override
    public ChannelHandlerContext read() {
        final AbstractChannelHandlerContext next = findContextOutbound();
        EventExecutor executor = next.executor();
        if (executor.inEventLoop()) {
            next.invokeRead();
        } else {
            Runnable task = next.invokeReadTask;
            if (task == null) {
                next.invokeReadTask = task = new Runnable() {
                    @Override
                    public void run() {
                        next.invokeRead();
                    }
                };
            }
            executor.execute(task);
        }
        return this;
    }
    //AbstractChannelHandlerContext的invokeRead() @6
    private void invokeRead() {
        if (invokeHandler()) {
            try {
                //调用HeadContext的read(ChannelHandlerContext ctx)
                ((ChannelOutboundHandler) handler()).read(this);
            } catch (Throwable t) {
                notifyHandlerException(t);
            }
        } else {
            read();
        }
    }
    //DefaultChannelPipeline中HeadContext的read() @7
    @Override
    public void read(ChannelHandlerContext ctx) {
        unsafe.beginRead();
    }
    
    //AbstractChannel.AbstractUnsafe类的beginRead @8
    @Override
    public final void beginRead() {
        assertEventLoop();

        if (!isActive()) {
            return;
        }

        try {
            doBeginRead(); //@9
        } catch (final Exception e) {
            invokeLater(new Runnable() {
                @Override
                public void run() {
                    pipeline.fireExceptionCaught(e);
                }
            });
            close(voidPromise());
        }
    }

调用流程

        @1->@2->@3->@4->@5->@6->@7->@8

@9: AbstractNioChannel的doBeginRead()方法,this.selectionKey是服务端注册时返回的selectionKey

    
        @Override
        protected void doBeginRead() throws Exception {
            // Channel.read() or ChannelHandlerContext.read() was called
            final SelectionKey selectionKey = this.selectionKey;
            if (!selectionKey.isValid()) {
                return;
            }
    
            readPending = true;
            //获取感兴趣的事件，对于服务端，注册Channel之后，感兴趣的事件是0(即仅仅绑定而已)，此处readInterestOp是OP_ACCEPT事件
            final int interestOps = selectionKey.interestOps();
            
            if ((interestOps & readInterestOp) == 0) {
                selectionKey.interestOps(interestOps | readInterestOp);
            }
        }
95-30-017-Channel-NioServerSocketChannel
九师兄
03-14 211
文章目录1. 概述2. 类图2.1 继承关系2.2 类图简介3. bind4. doReadMessages5. doClose6. 构造方法 1. 概述 你肯定已经使用过NioServerSocketChannel，作为处于Channel最底层的子类，NioServerSocketChannel会实现I/O事件框架的底层细节。首先需要注意的是：NioServerSocketChannel只支持bind、read和close操作。 2. 类图 2.1 继承关系 2.2 类图简介 3. bind @O
Netty源码分析系列之四：Netty启动之NioServerSocketChannel创建
2401_84092868的博客
05-03 871
即使是面试跳槽，那也是一个学习的过程。只有全面的复习，才能让我们更好的充实自己，武装自己，为自己的面试之路不再坎坷！今天就给大家分享一个Github上全面的Java面试题大全，就是这份面试大全助我拿下大厂Offer，月薪提至30K！我也是第一时间分享出来给大家，希望可以帮助大家都能去往自己心仪的大厂！为金三银四做准备！
Java netty之NioServerSocketChannel
fjs的专栏
06-25 3969
在上一篇文章中分析了AbstractNioChannel，那么在这一篇文章中就分析一个具体的NioChannel类。。。 NioServerSocketChannel类用过netty的应该都比较熟悉吧，如果做服务器端的编程，那么我们一般情况下都是使用的这种类型的channel。 按照惯例，我们还是先来分析一下它的继承体系： NioServerSocketChannel直接继承自Abs
Netty-NioServerSocketChannel与NioSocketChannel
xiaopang2020的博客
04-17 909
NioServerSocketChannel与NioSocketChannel
Netty系列-2 NioServerSocketChannel和NioSocketChannel介绍
shengyu
09-01 1432
本文介绍Netty的通道组件NioServerSocketChannel和NioSocketChannel，从源码的角度介绍其实现原理。
netty源码分析3-NioServerSocketChannel,NioSocketChannel
chenchangqun11的专栏
12-03 672
本文分析内容如下 Channel主要接口分析 AbstractChannel分析 AbstractNioChannel分析 AbstractNioByteChannel分析 AbstractNioMessageChannel 分析 NioSocketChannel分析 AbstractNioMessageServerChannel分析 NioServerSocketChannel分...
Netty源码分析系列之四：Netty启动之NioServerSocketChannel创建_netty socketchannel
m0_60144796的博客
04-27 738
既已说到spring cloud alibaba，那对于整个微服务架构，如果想要进一步地向上提升自己，到底应该掌握哪些核心技能呢？就个人而言，对于整个微服务架构，像RPC、Dubbo、Spring Boot、Spring Cloud Alibaba、Docker、kubernetes、Spring Cloud Netflix、Service Mesh等这些都是最最核心的知识，架构师必经之路！下图，是自绘的微服务架构路线体系大纲，如果有还不知道自己该掌握些啥技术的朋友，可根据小编手绘的大纲进行一个参考。
Netty架构篇 - NioServerSocketChannel、NioSocketChannel
The Secret
08-10 3082
本文主要介绍Netty的NioServerSocketChannel、NioSocketChannel模型，在Netty底层中如何实例化、初始化、注册。
Netty4.x 源码实战系列（三）：NioServerSocketChannel全剖析
风清扬的专栏
12-31 1953
根据上一篇《Netty4.x 源码实战系列（二）：服务端bind流程详解》所述，在进行服务端开发时，必须通过ServerBootstrap引导类的channel方法来指定channel类型， channel方法的调用其实就是实例化了一个用于生成此channel类型对象的工厂对象。 并且在bind调用后，会调用此工厂对象来生成一个新channel。本篇将通过NioServerSocketChannel
【NIO】ServerSocketChannel
热门推荐
yhl_jxy的博客
02-18 1万+
前言 Github：https://github.com/yihonglei/java-all Project：java-nio 一 ServerSocketChannel概述 Java NIO中的ServerSocketChannel类定义在java.nio.channels包中。 ServerSocketChannel是一个可以监听新进来的TCP连接的通道，就像标准IO中的Serve...
NioServerSocketChannel
qq_44587855的博客
12-27 1065
在netty Bootstrap启动之后会执行 channel，此时将NioServerSocketChannel的Class对象加入到BootStrap 的ChannelFactory之中，这个ChannelFactory是ReflectiveChannelFactory类型的 但是什么时候真正使用该Channel呢？ 这里调用ReflectiveChannelFactory的 首先执行 newSocket方法 ......
Java-IO系列：Netty中NioServerSocketChannel
少年不识愁滋味
12-17 623
NioServerSocketChannel 类图 pipeline：DefaultChannelPipeline 创建NioServerSocketChannel的时候，会初始化pipeline属性，创建一个DefaultChannelPipeline(this)。 看源码：AbstractChannel.java protected DefaultChannelPipeline newChannelPipeline() { return new DefaultChannelPi
Netty4.0源码解析：NioServerSocketChannel
APlus
10-28 1538
一、引言 Netty的Channel在JDK NIO的Channel基础上做了一层封装，提供了更多的功能。Netty的中的Channel实现类主要有：NioServerSocketChannel（用于服务端非阻塞地接收TCP连接）、NioSocketChannel（用于维持非阻塞的TCP连接）、NioDatagramChannel（用于非阻塞地处理UDP连接）、OioServerSocketCha...
无涯教程-Java NIO - ServerSocketChannel
无涯教程
12-30 950
Server Socket Channel可以通过调用其静态open()方法来创建，然后通过调用 bind()方法进行绑定。通过ServerSocketChannel.accept()方法来侦听服务器Socket通道的传入连接。当accept()方法返回时，它将返回带有传入连接的SocketChannel。因此，accept()方法将阻塞直到传入连接到达为止。就像Socket通道服务器一样，Socket通道可以使用 read()方法读取数据。
Netty源码解析-NioServerSocketChannel
恐龙弟旺仔的博客
12-27 940
前言： 通过之前那么多的分拆知识点讲解，终于到了最重要的阶段了。无论之前的EventLoop还是ByteBufAllocate，终归都是为Channel服务的。Channel的实现类才是最终连接、读写事件的执行者。 本文主要聚焦于NioServerSocketChannel，作为Server端，主要用于接收客户端连接，并为该连接注册事件，我们通过源码的角度来分析下连接的整个过程。 1.NioServerSocketChannel构造图 分析类的时候，尤其Netty框架这种结构层特别多的关键类时，要学
Java NIO深入理解ServerSocketChannel
云大牛的博客
07-02 862
Java NIO 简介 JAVA NIO有两种解释：一种叫非阻塞IO（Non-blocking I/O），另一种也叫新的IO（New I/O），其实是同一个概念。它是一种同步非阻塞的I/O模型，也是I/O多路复用的基础，已经被越来越多地应用到大型应用服务器，成为解决高并发与大量连接、I/O处理问题的有效方式。 NIO是一种基于通道和缓冲区的I/O方式，它可以使用Native函数库直接分配堆外内存（...
netty NioServerSocketChannel解析
Donald_Draper的专栏
09-16 1674
l]http://donald-draper.iteye.com/blog/2392801[/url] netty 抽象Unsafe定义：[url]http://donald-draper.iteye.com/blog/2393053[/url] netty 通道Outbound缓冲区：[url]http://donald-draper.iteye.com/blog/2393098[/url] netty 抽象通道后续：[url]http://donald-draper.iteye.com/blog/
SpringBoot集成netty4.1 demo，基于NioServerSocketChannel
飞得更高
05-28 956
需要注意的是： writeAndFlush(Object msg) msg虽然是Object类型，却并不是什么类型都可以直接传，仅支持ByteBuf 和 FileRegion 类型 以下为demo源码: 引入依赖： <dependency> <groupId>io.netty</groupId> <artifactId>netty-all</artifactId> </dependency> 服务端.
netty源码分析
最新发布
03-11
### Netty 源码分析文章汇总 对于希望深入了解Netty源码的读者来说，一系列深入浅出的文章能够提供极大的帮助。以下是按照不同主题整理的一系列关于Netty源码解析的文章列表[^1]： #### 1. 初识Netty - **Netty...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值