Netty服务端启动

源码

public final class Server {

    public static void main(String[] args) throws Exception {
        EventLoopGroup bossGroup = new NioEventLoopGroup(1);
        EventLoopGroup workerGroup = new NioEventLoopGroup();

        try {
            ServerBootstrap b = new ServerBootstrap();
            b.group(bossGroup, workerGroup)
                    .channel(NioServerSocketChannel.class)
                    .childOption(ChannelOption.TCP_NODELAY, true)  
                    //给每个客户端的连接设置一些基本的tcp属性
                    .childAttr(AttributeKey.newInstance("childAttr"), "childAttrValue") 
                    //创建每个客户端链接的时候绑定一些基本的属性
                    .handler(new ServerHandler())
                    //服务器启动过程中的一些逻辑
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        public void initChannel(SocketChannel ch) {
                            ch.pipeline().addLast(new AuthHandler());
                            //..

                        }
                    });

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

            f.channel().closeFuture().sync();
        } finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }
}

import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;

import java.util.concurrent.TimeUnit;

public class ServerHandler extends ChannelInboundHandlerAdapter {
    @Override
    public void channelActive(ChannelHandlerContext ctx) {
        System.out.println("channelActive");
    }

    @Override
    public void channelRegistered(ChannelHandlerContext ctx) {
        System.out.println("channelRegistered");
    }

    @Override
    public void handlerAdded(ChannelHandlerContext ctx) {
        System.out.println("handlerAdded");
    }

    @Override
    public void channelRead(final ChannelHandlerContext ctx, Object msg) throws Exception {
        super.channelRead(ctx, msg);

        new Thread(new Runnable() {
            public void run() {
                // 耗时的操作
                String result = loadFromDB();

                ctx.channel().writeAndFlush(result);
                ctx.executor().schedule(new Runnable() {
                    public void run() {
                        // ...
                    }
                }, 1, TimeUnit.SECONDS);

            }
        }).start();
    }

    private String loadFromDB() {
        return "hello world!";
    }
}

 

服务端Channel启动过程：

基本过程

1. 调jdk底层的api创建jdk的channel，netty将其包装成自己的channel，创建一些基本组件绑定在此channel上，比如pipeline
2. 基于此channel初始化一些基本属性，添加一些逻辑处理器
3. 将jdk底层的channel注册到事件轮训处理器上，并把netty的服务端channel绑定在jdk底层服务端channel上
4. 调jdk底层api，实现对本地端口的监听，绑定成功后，netty会重新向selector注册一个op_accept事件，netty就可以接收新的连接了 

 

创建channel

 

AbstractChannel是服务端channel和客户端channel的一个抽象

问题：

服务端的socket在哪初始化?

newSocket()[通过jdk来创建底层jdk channel]

 

 

初始化channel

 

add ServerBootstrapAcceptor给接收到的一个新连接分配一个nio的线程

注册selector

绑定线程：把对应的Nio线程和当前的chanel进行绑定, 后续所有I/O事件相关的操作都交给eventloop处理

实际注册：将jdk底层的channel注册到事件轮训处理器上

通过invkeHanderAddedIfNeeded()和fireChannelRegistered两个事件传播到用户方法中 

 

绑定端口

doBind()将端口实际绑定到本地

HeadContext.readIfIsAutoRead：将之前注册到selector的事件重新绑定为accept事件，有新连接进入，selector就会轮训到accept事件，将连接交给netty处理

问题：

在哪里accetp连接

绑定成功后，netty会重新向selector注册一个op_accept事件，netty就可以接收新的连接了