1、 Channel与ChannelHandlerContext

Channel与ChannelHandlerContext都实现了AttributeMap，可以让用户附加一个或多个用户定义的属性，有时令用户干到疑惑，一个Channel与一个ChannelHandlerContext拥有各种的用户自定义的存储
Netty4.1的版本解决了Attr方法的改变，减少ChannelHandlerContext对Map的创建，从而减少了内存的使用(版本改良点)

New and noteworthy in 4.1 请截图

ChannelHandlerContext

2、初始化流程

ServerBootstrap类的init方法在初始化流程很重要
NioEventLoopGroup继承MutiEventLoopGroup类

服务端初始化的步骤
1、创建ServerBootstrap启动辅助类，通过Builder模式进行参数配置；
2、创建并绑定Reactor线程池EventLoopGroup；
4、设置并绑定服务端Channel通道类型；
5、绑定服务端通道数据处理器责任链Handler；

3、ServerBootstrap初始化

ServerBootstrap是netty启动辅助类，通过Builder模式进行参数设置初始化；ServerBootstrap继承AbstracBootstrap类，需要对EventLoopGroup，Channel和ChannelHandler等参数进行配置；

public class ServerBootstrap extends AbstractBootstrap {
    private final Map, Object> childOptions = new LinkedHashMap();
    private final Map, Object> childAttrs = new LinkedHashMap();
    private final ServerBootstrapConfig config = new ServerBootstrapConfig(this);
    private volatile EventLoopGroup childGroup;
    private volatile ChannelHandler childHandler;
}

image.png

EventLoop线程池初始化
EventLoopGroup初始化是创建创建两个NioEventLoopGroup类型的Reactor线程池bossGroup和workGroup分别用来处理客户端的连接请求和通道IO事件；

EventLoopGroup bossGroup = new NioEventLoopGroup();
EventLoopGroup workerGroup = new NioEventLoopGroup();
ServerBootstrap b= new ServerBootstrap();
b.group(boosGroup,workGroup)

通过group()方法设置EventLoop将bossGroup传入到AbstractBootstrap中设置到group属性上，将workGroup设置到ServerBootstrap的childGroup属性上；如果只传入了一个EventLoopGroup则最后传入两个相同的group；


public ServerBootstrap group(EventLoopGroup group) {
    return this.group(group, group);
}

public ServerBootstrap group(EventLoopGroup parentGroup, EventLoopGroup childGroup) {
    super.group(parentGroup);
    if(childGroup == null) {
        throw new NullPointerException("childGroup");
    } else if(this.childGroup != null) {
        throw new IllegalStateException("childGroup set already");
    } else {
        this.childGroup = childGroup;
        return this;
    }
}

super.group(parentGroup)方法对AbstractBootstrap的group属性进行设置

public B group(EventLoopGroup group) {
    if(group == null) {
        throw new NullPointerException("group");
    } else if(this.group != null) {
        throw new IllegalStateException("group set already");
    } else {
        this.group = group;
        return this;
    }
}

4、Channel通道初始化

Channel初始化主要是指对通道类型进行设置，常见的通道类型主要有NioServerSocktChannel异步非阻塞服务端TCP通道，NioSocketChannel异步非阻塞客户端通道，OioServerSocketChannel同步阻塞服务端通道，OioSocketChannel同步阻塞客户端通道，NioDatagramChannel异步非阻塞UDP通道，OioDatagramChannel同步阻塞UDP通道等；
ChannelFactory通道工程类设置，在serverBootstrap初始化过程中通过调用channel()方法进行通道类型设置

public B channel(Class channelClass) {
    if(channelClass == null) {
        throw new NullPointerException("channelClass");
    } else {
        return this.channelFactory((io.netty.channel.ChannelFactory)(new ReflectiveChannelFactory(channelClass)));
    }
}

根据传入的Channe类型初始化一个ChannelFactory类型的工厂类，工厂类中通过newChannel()方法创建Channel实例


private final Class clazz;

public ReflectiveChannelFactory(Class clazz) {
    if(clazz == null) {
        throw new NullPointerException("clazz");
    } else {
        this.clazz = clazz;
    }
}

public T newChannel() {
    try {
        return (Channel)this.clazz.newInstance();
    } catch (Throwable var2) {
        throw new ChannelException("Unable to create Channel from class " + this.clazz, var2);
    }
}

通过channelFactory()方法将创建工厂类实例指向AbstractoryBootstrap的channelFactory属性

public B channelFactory(ChannelFactory channelFactory) {
    if(channelFactory == null) {
        throw new NullPointerException("channelFactory");
    } else if(this.channelFactory != null) {
        throw new IllegalStateException("channelFactory set already");
    } else {
        this.channelFactory = channelFactory;
        return this;
    }
}

5、Channel通道实例化

配置好AbstractBootstrap的channelFactory工厂类，Channel的实例化通过ChannelFactory.newChannel()方法实现；具体的newChannel()方法的调用链是：

ServerBootstrap.bind() -> AbstractBootstrap.doBind() -> AbstractBootstrap.initAndRegister() -> ChannelFactory.newChannel();

public T newChannel() {
    try {
        return (Channel)this.clazz.newInstance();
    } catch (Throwable var2) {
        throw new ChannelException("Unable to create Channel from class " + this.clazz, var2);
    }
}

通过clazz.newInstance()方法调用构造器创建NioServerSocketChannel实例

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

调用newSocket()方法创建ServerSocketChannel实例，这里的ServerSocketChannel和NIO中的ServerSocketChannel是同一个东西，接下来会调用父类构造器对其进行外部封装和相关参数的配置；

public NioServerSocketChannel(java.nio.channels.ServerSocketChannel channel) {
    super((Channel)null, channel, 16);
    this.config = new NioServerSocketChannel.NioServerSocketChannelConfig(this, this.javaChannel().socket());
}

在 NioServerSocketChannsl 实例化过程中, 所需要做的工作
调用 NioServerSocketChannel.newSocket(DEFAULT_SELECTOR_PROVIDER) 打开一个新的 Java NIO ServerSocketChannel

AbstractNioChannel 中的属性:

SelectableChannel ch 被设置为 Java ServerSocketChannel, 即 NioServerSocketChannel#newSocket 返回的 Java NIO ServerSocketChannel.
readInterestOp 被设置为 SelectionKey.OP_ACCEPT
SelectableChannel ch 被配置为非阻塞的 ch.configureBlocking(false)=
AbstractChannel(Channel parent) 中初始化

AbstractChannel 的属性:

AbstractChannel 的属性parent 属性置为 null
unsafe 通过newUnsafe() 实例化一个unsafe对象, 它的类型是 AbstractNioMessageChannel#AbstractNioUnsafe 内部类
pipeline 是 new DefaultChannelPipeline(this) 新创建的绑定管道实例.

NioServerSocketChannel 中的属性:

ServerSocketChannelConfig config = new NioServerSocketChannelConfig(this, javaChannel().socket())

6、Channel通道注册

在channel通道创建和初始化完毕后，会通过group.register()方法将channel通道注册到EventLoop线程池中；

final ChannelFuture initAndRegister() {
    // 去掉非关键代码
    final Channel channel = channelFactory().newChannel();
    init(channel);
    ChannelFuture regFuture = group().register(channel);
}

通过一系列的注册方法调用：AbstractBootstrap.initAndRegister -> MultithreadEventLoopGroup.register -> SingleThreadEventLoop.register -> AbstractUnsafe.register，最终是通过Unsafe类的register0()方法

private void register0(ChannelPromise promise) {
    boolean firstRegistration = neverRegistered;
    doRegister();
    neverRegistered = false;
    registered = true;
    safeSetSuccess(promise);
    pipeline.fireChannelRegistered();
    // Only fire a channelActive if the channel has never been registered. This prevents firing
    // multiple channel actives if the channel is deregistered and re-registered.
    if (firstRegistration && isActive()) {
        pipeline.fireChannelActive();
    }
}

register0()方法调用了doRegister()方法实现通道注册到线程池中(EventLoop线程池会绑定一个selector选择器)

@Override
protected void doRegister() throws Exception {
    // 省略错误处理
    selectionKey = javaChannel().register(eventLoop().selector, 0, this);
}

7 handler处理器的添加过程

我们可以自定义Handler处理器并将其加入到pipeline管道中，进而像插件一样自由组合各种handler完成具体的业务逻辑；添加handler的过程是获取与channel通道绑定的管道pipeline然后将自定义的handler添加进pipeline内部维护的一个双向链表；

bootstrap.childHandler(new ChannelInitializer() {
                    @Override
 protected void initChannel(SocketChannel socketChannel) throws Exception {
    socketChannel.pipeline().addLast(new TimeServerHandler());
     }
});

Bootstrap.childerHandler方法接收一个 ChannelHandler, 而我们传递的是一个派生于ChannelInitializer的匿名类，它正好也实现了 ChannelHandler接口，因此将ChannelHandler实例赋值给ServerBootstrap的childHandler属性；

public ServerBootstrap childHandler(ChannelHandler childHandler) {
    if(childHandler == null) {
        throw new NullPointerException("childHandler");
    } else {
        this.childHandler = childHandler;
        return this;
    }
}

在启动服务端绑定端口时候最终通过调用initAndRegister()方法创建Channel实例，并将通过init()方法将系统定义的处理器ServerBootstrapAccptor添加到与channel绑定的pipeline通道中；

@Override
void init(Channel channel) throws Exception {
    ...
    ChannelPipeline p = channel.pipeline();

    final EventLoopGroup currentChildGroup = childGroup;
    final ChannelHandler currentChildHandler = childHandler;
    final Entry, Object>[] currentChildOptions;
    final Entry, Object>[] currentChildAttrs;

    p.addLast(new ChannelInitializer() {
        @Override
        public void initChannel(Channel ch) throws Exception {
            ChannelPipeline pipeline = ch.pipeline();
            ChannelHandler handler = handler();
            if (handler != null) {
                pipeline.addLast(handler);
            }
            pipeline.addLast(new ServerBootstrapAcceptor(
                    currentChildGroup, currentChildHandler, currentChildOptions, currentChildAttrs));
        }
    });
}

在ServerBootstrapAcceptor中重写了channelRead()方法，将自定义的handler处理器添加到管道中；

public void channelRead(ChannelHandlerContext ctx, Object msg) {
    final Channel child = (Channel) msg;
    child.pipeline().addLast(childHandler);
    ...
    childGroup.register(child).addListener(...);
}

服务器端的 handler 与 childHandler 的区别与联系:
服务器 NioServerSocketChannel 的 pipeline 中添加的是 handler 与 ServerBootstrapAcceptor.
当有新的客户端连接请求时, ServerBootstrapAcceptor.channelRead 中负责新建此连接的NioSocketChannel并添加 childHandler 到 NioSocketChannel 对应的pipeline中, 并将此channel绑定到workerGroup中的某个eventLoop中；
handler是在accept阶段起作用, 它处理客户端的连接请求，ServerBootstrap也能设置handler()方法添加ServerSocketChannel的自定义处理器；

8、 OIO（掌握点）

OIO是阻塞编程模型，一个连接过来服务端会启用一个线程专门服务这个连接，而客户端一直等待响应返回数据（有多少个就会创建多少个Thread）
OioServerSocketChannel同步阻塞服务端通道，OioSocketChannel同步阻塞客户端通道，NioDatagramChannel异步非阻塞UDP通道，OioDatagramChannel同步阻塞UDP通道等
OioServerSocketChannel与NioDatagramChannel类关系图

OioServerSocketChannel

NioDatagramChannel

9、 lsof命令

lsof -i ：8080 查看8080端口进程命令，lsof 代表list open file 打开列表文件的意思

10、总结

Netty服务端的初始化主要是创建初始化辅助类ServerBootstrap，并对辅助类的相关参数进行初始化包括EventLoop线程池，Channle通道类型和ChannleHandler通道处理器等；在调用bind()方法进行端口绑定时，会根据ServerBootsrap中的初始化参数启动服务端，具体的启动流程为：

创建ServerBootstrap启动辅助类实例，并对其Channel，EventLoopGroup，Handler等参数进行配置；
调用bootstrap.bind()方法时触发启动，会根据配置的Channle类型创建Channel实例，比如NioServerSocketChannel等
在实例化Channel时候会初始化Pipeline管道并与AbstractChannel绑定
将channel管道注册到EventLoopGroup线程池中，从线程池中轮询获取一个线程EventLoop并与之绑定；
启动线程，线程执行绑定的selector的select()方法监听注册的channel的状态，并执行定时任务
NioServerSocketChannel

【第15篇】netty服务端初始化流程详细分析

1、 Channel与ChannelHandlerContext

2、初始化流程

3、ServerBootstrap初始化

4、Channel通道初始化

5、Channel通道实例化

AbstractNioChannel 中的属性:

AbstractChannel 的属性:

NioServerSocketChannel 中的属性:

6、Channel通道注册

7 handler处理器的添加过程

8、 OIO（掌握点）

9、 lsof命令

10、总结

推荐学习博客

你可能感兴趣的:(【第15篇】netty服务端初始化流程详细分析)

【第15篇】netty服务端初始化流程详细分析

1、 Channel与ChannelHandlerContext

2、 初始化流程

3、ServerBootstrap初始化

4、Channel通道初始化

5、Channel通道实例化

AbstractNioChannel 中的属性:

AbstractChannel 的属性:

NioServerSocketChannel 中的属性:

6、Channel通道注册

7 handler处理器的添加过程

8、 OIO（掌握点）

9、 lsof命令

10、总结

推荐学习博客

你可能感兴趣的:(【第15篇】netty服务端初始化流程详细分析)

2、初始化流程