Netty源码分析第1章(Netty启动流程)——–>第2节: NioServerSocketChannel的创建

第一章:  Server启动流程

第二节:服务端初始化

我们如果熟悉Nio, 则对channel的概念则不会陌生, channel在相当于一个通道, 用于数据的传输

Netty将jdk的channel进行了包装, 并为其扩展了更多的功能

在netty中也分为服务端channel和客户端channel, 在Nio模式下, 服务端channel对应的类为NioServerSocketChannel, 包装的jdk的ServerSocketChannel

客户端channel对应的类为NioSocketChannel, 所包装的jdk的类为SocketChannel

最简单的继承关系如下(经简化):

1-2-1

我们继续看第一小节demo:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
1//创建boss和worker线程(1)

2EventLoopGroup bossGroup = new NioEventLoopGroup(1);

3EventLoopGroup workerGroup = new NioEventLoopGroup();

4//创建ServerBootstrap(2)

5ServerBootstrap b = new ServerBootstrap();

6//初始化boss和work线程化两个线程(3)

7b.group(bossGroup, workerGroup)

8        //声明NioServerSocketChannel(4)

9        .channel(NioServerSocketChannel.class)

10        //初始化客户端Handler(5)

11        .childHandler(new ChannelInitializer<SocketChannel>() {

12            @Override

13            public void initChannel(SocketChannel ch) {

14                ch.pipeline().addLast(new StringDecoder());

15                ch.pipeline().addLast(new StringEncoder());

16                ch.pipeline().addLast(new ServerHandler());

17            }

18        });

19//绑定端口(6)

20ChannelFuture f = b.bind(8888).sync();

21f.channel().closeFuture().sync();

22

我们继续看第六步, 绑定端口:

ChannelFuture f = b.bind(8888).sync();

在此, 我们看到绑定了8888端口, 我们跟到bind(8888)方法中:

1
2
3
4
1public ChannelFuture bind(int inetPort) {

2    return bind(new InetSocketAddress(inetPort));

3}

4

端口封装成socket地址对象, 继续跟:

1
2
3
4
5
1public ChannelFuture bind(SocketAddress localAddress) {

2    validate();

3    return doBind(localAddress);

4}

5

validate()做了一些属性验证, 我们继续跟到doBind(localAddress)方法:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
1private ChannelFuture doBind(final SocketAddress localAddress) {

2    //初始化并注册(1)

3    final ChannelFuture regFuture = initAndRegister();

4    //获得channel(2)

5    final Channel channel = regFuture.channel();

6    if (regFuture.cause() != null) {

7        return regFuture;

8    }

9    if (regFuture.isDone()) {

10        ChannelPromise promise = channel.newPromise();

11        //绑定(3) 

12        doBind0(regFuture, channel, localAddress, promise);

13        return promise;

14    } else {

15        //去除非关键代码

16        return promise;

17    }

18}

19

去除了一些非关键的代码, 重点关注注释标注的第一步, 初始化并注册:

1
2
1final ChannelFuture regFuture = initAndRegister();

2

我们跟进initAndRegister()方法:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
1final ChannelFuture initAndRegister() {

2    Channel channel = null;

3    try {

4        //创建channel

5        channel = channelFactory.newChannel();

6        init(channel);

7    } catch (Throwable t) {

8        //忽略非关键代码

9    }

10    ChannelFuture regFuture = config().group().register(channel);

11    //忽略非关键代码

12    return regFuture;

13}

14

关注添加注释的步骤, 创建channel, 这一点也是我们这节需要讲明白的内容

看着一步:

1
2
1channel = channelFactory.newChannel();

2

这里channelFactory调用了newChannel()的这个方法, 这个方法从名字就不难理解, 是新建一个channel, 回顾下上一小节, 这个channelFactory是在哪里初始化呢?

根据上一小节代码, channelFactory是在Bootstrap的channelFactory ()方法初始化的:

1
2
3
4
5
1public B channelFactory(ChannelFactory<? extends C> channelFactory) {

2    this.channelFactory = channelFactory;

3    return (B) this;

4}

5

而这个方法又是channel()方法中调用的:

1
2
3
4
1public B channel(Class<? extends C> channelClass) {

2    return channelFactory(new ReflectiveChannelFactory<C>(channelClass));

3}

4

这里传入ReflectiveChannelFactory对象就是初始化的channelFactory对象

所以newChannel()是调用ReflectiveChannelFactory对象的newChannel方法:

1
2
3
4
5
6
7
8
9
1@Override

2public T newChannel() {

3    try { 

4        return clazz.newInstance();

5    } catch (Throwable t) {

6        throw new ChannelException("Unable to create Channel from class " + clazz, t);

7    }

8}

9

我们看到这个clazz对象通过反射创建了channel, 这个clazz对象, 就是我们上一节提到过的, 初始化的NioServerSocketChannel的class对象

这里通过反射调用, 会创建一个NioServerSokectChannel

学习过nio的小伙伴都知道jdk的ServerSocketChannel, 用于接受链接事件, 而netty的NioServerSocketChannel是和jdk的channel有什么关系呢?

实际上netty的channel和jdk的channel的含义一样, 也是一个通道, 只是netty为其做了扩展, 而channel的事件处理, 也是通过jdk的channel去做的, 我们跟随着NioServerSocketChannel的创建过程, 来了解他们之间的关联关系

clazz.newInstance()通过反射创建一个NioServerSocketChannel对象, 首先会走到NioServerSocketChannel的构造方法, 我们跟到他的构造方法, 查看NioServerSocketChannel的创建过程

首先会调用它的无参构造方法:

1
2
3
4
1public NioServerSocketChannel() {

2    this(newSocket(DEFAULT_SELECTOR_PROVIDER));

3}

4

我们看到这个构造方法调用了另一个有参的构造方法, 传入参数是newSocket(DEFAULT_SELECTOR_PROVIDER)

我们首先看DEFAULT_SELECTOR_PROVIDER这个这变量

1
2
1private static final SelectorProvider DEFAULT_SELECTOR_PROVIDER = SelectorProvider.provider();

2

看到这初始化了一个SelectorProvider对象, 而这个对象是通过静态方法provider()创建的, SelectorProvider对象可以用于创建jdk底层的ServerSocketChannel

我们继续跟到newSocket(DEFAULT_SELECTOR_PROVIDER)中:

1
2
3
4
1private static ServerSocketChannel newSocket(SelectorProvider provider) {

2    return provider.openServerSocketChannel();

3}

4

去掉try-catch块, 发现这个方法是通过SelectorProvider对象的openServerSocketChannel()方法创建一个jdk底层的ServerSocketChannel, 至此我们可以知道, 与NioServerSokectChannel绑定的jdk底层的ServerSocketChannel就是这么创建的

那么创建之后如何与netty的channel绑定?继续跟代码, 跟到this(newSocket(DEFAULT_SELECTOR_PROVIDER))中:

1
2
3
4
5
1public NioServerSocketChannel(ServerSocketChannel channel) {

2    super(null, channel, SelectionKey.OP_ACCEPT);

3    config = new NioServerSocketChannelConfig(this, javaChannel().socket());

4}

5

我们看到这里调用了父类的构造方法, 继续往里跟:

1
2
3
4
1protected AbstractNioMessageChannel(Channel parent, SelectableChannel ch, int readInterestOp) {

2    super(parent, ch, readInterestOp);

3}

4

这里调用了其父类AbstractNioMessageChannel类的构造方法, AbstractNioMessageChannel这个类同学们请记住, 有关是NioServerSocketChannel的父类, 代表着服务端channel的相关属性和操作, 之后有关服务端channel的一些事件会在这个类中完成

我们看到这个类的构造方法中又调用了它的父类的构造方法, 我们继续跟:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
1protected AbstractNioChannel(Channel parent, SelectableChannel ch, int readInterestOp) {

2    super(parent);

3    //保存channel

4    this.ch = ch;

5    //绑定事件

6    this.readInterestOp = readInterestOp;

7    try {

8        //设置为非阻塞

9        ch.configureBlocking(false);

10    } catch (IOException e) {

11        //去掉非关键代码

12    }

13}

14

这里又调用了其父类AbstractChannel的构造方法, 跟进去这个方法之前, 我们先往下看

首先看这一步:

1
2
1this.ch = ch;

2

这步就是绑定jdk底层的ServerSocketChannel, 至此我们知道, jdk的channel和netty定义的channel是组合关系, netty的channel中有个jdk的channel的成员变量, 而这个成员变量就定义在AbstractNioChannel这个类当中, 希望同学们将这个结论牢牢记住, 对以后的学习很有帮助

我们看到后面的这一步:

1
2
1ch.configureBlocking(false);

2

这一步, 就是将jdk的channel设置为非阻塞模式, 这里熟悉Nio的同学应该不会陌生, 这里不再赘述

我们继续跟到super(parent)中, 走到其父类AbstractChannel的构造方法:

1
2
3
4
5
6
7
1protected AbstractChannel(Channel parent) {

2    this.parent = parent;

3    id = newId();

4    unsafe = newUnsafe();

5    pipeline = newChannelPipeline();

6}

7

首先看下这个parent, 这个parent是NioServerSocketChannel调用其父类构造方法传入的, 传入的是null, 所以这一步AbstractChannel的属性parent也是null, 这个parent, 我们之后再讲客户端channel的时候会讲到

id = newId()是为每个channel创建一个唯一id

我们重点关注下后两步:

1
2
3
1unsafe = newUnsafe();

2pipeline = newChannelPipeline();

3

这里初始化了两个属性unsafe, 和pipeline, 目前我们只需要知道这两个属性是在这里初始化的, 至于这两个属性的概念, 后面的章节会讲到

以上就是创建NioServerSocketChannel的过程, 同学们可以课后跟进源码去熟悉巩固