在Reactor经典模型中，反应器查询到IO事件后会分发到Handler业务处理器，由Handler完成IO操作和业务处理。

1、Handler处理流程

整个IO操作环节大致包括从通道读取数据包（Netty底层负责），数据包解码，业务处理，目标数据编码，把数据包写到通道，然后由通道发到对端（Netty底层负责）。

前文提到Netty的Handler分为两类，ChannelInboundHandler 入站处理器，ChannelOutboundHandler 出站处理器
数据包解码，业务处理 两个环节属于入站处理器工作
目标数据编码，把数据包写到通道 两个环节属于出站处理器工作

2、入站处理器

当对端数据入站到Netty通道时，Netty将触发ChannelInboundHandler 所对应的入站API，进行入站操作处理

ChannelInboundHandler核心方法：

3、出站处理器

当业务处理完成后，需要操作java NIO通道时，通过一系列的ChannelOutboundHandler出站处理器完成Netty通道到底层通道的操作，比如建立底层连接，断开底层连接，写入底层Java NIO通道等。

ChannelOutboundHandler核心方法

4、ChannelInitalizer

每个Netty通道拥有一条Handler业务处理流水线，负责装配自己的Handler业务处理器。那么如何向流水线装配业务处理器呢？这就需要借助通道的初始化处理器
ChannelInitalizer。

在通道初始化时，会调用提前注册的初始化处理器的initChannel()方法

 .childHandler(new ChannelInitializer<NioSocketChannel>() {
                    @Override
                           //有连接到达时会创建一个通道的子通道
                    protected void initChannel(NioSocketChannel ch) throws Exception {
                                               //向子通道的流水线添加Handler业务处理器
                        ch.pipeline().addLast(new ChannelInboundHandlerAdapter(){
                            @Override
                            public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
                                ByteBuf byteBuf = (ByteBuf) msg;
                                log.info(byteBuf.toString(Charset.defaultCharset()));
                                //将消息传递到流水线的下一个Handler
                                ctx.fireChannelRead(msg);
                            }
                        }).addLast(longTimeHandleGroup,"longTimeHandler",new ChannelInboundHandlerAdapter(){
                            @Override
                            public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
                                ByteBuf byteBuf = (ByteBuf) msg;
                                log.info("longTimeHandler" + byteBuf.toString(Charset.defaultCharset()));
                            }
                        });
                    }
                })

5、ChannelInboundHandler生命周期

执行顺序：

• 通道创建和绑定时： handlerAdded() -> channelRegistered() -> channelActive()
• 数据传输时： channelRead() -> channelReadComplete()
• 通道关闭时：channelInactive() -> channelUnregistered() -> handlerRemoved()

@Slf4j
public class TestHandlerLife {
    public static void main(String[] args) {
        new ServerBootstrap()
                //boos只负责NioServerSocketChannel的accept  worker负责NioSocketChannel上的读写
                .group(new NioEventLoopGroup(),new NioEventLoopGroup(2))
                .channel(NioServerSocketChannel.class)
                .childHandler(new ChannelInitializer<NioSocketChannel>() {
                    @Override
                    protected void initChannel(NioSocketChannel ch) throws Exception {
                        ch.pipeline().addLast(new ChannelInboundHandlerAdapter(){
                            @Override
                            public void channelRegistered(ChannelHandlerContext ctx) throws Exception {
                                log.info("调用： channelRegistered");
                                super.channelRegistered(ctx);
                            }
                            @Override
                            public void channelUnregistered(ChannelHandlerContext ctx) throws Exception {
                                log.info("调用： channelUnregistered");
                                super.channelUnregistered(ctx);
                            }
                            @Override
                            public void channelActive(ChannelHandlerContext ctx) throws Exception {
                                log.info("调用： channelActive");
                                super.channelActive(ctx);
                            }
                            @Override
                            public void channelInactive(ChannelHandlerContext ctx) throws Exception {
                                log.info("调用： channelInactive");
                                super.channelInactive(ctx);
                            }
                            @Override
                            public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
                                log.info("调用： channelReadComplete");
                                super.channelReadComplete(ctx);
                            }
                            @Override
                            public void channelWritabilityChanged(ChannelHandlerContext ctx) throws Exception {
                                log.info("调用： channelWritabilityChanged");
                                super.channelWritabilityChanged(ctx);
                            }
                            @Override
                            public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
                                log.info("调用： handlerAdded");
                                super.handlerAdded(ctx);
                            }
                            @Override
                            public void handlerRemoved(ChannelHandlerContext ctx) throws Exception {
                                log.info("调用： handlerRemoved");
                                super.handlerRemoved(ctx);
                            }
                            @Override
                            public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
                                log.info("调用： channelRead");
                                ByteBuf byteBuf = (ByteBuf) msg;
                                log.info(byteBuf.toString(Charset.defaultCharset()));
                                //将消息传递到流水线的下一个Handler
                                ctx.fireChannelRead(msg);
                            }
                        });
                    }
                })
                .bind(8989);
    }
}

public class BootStrapClient {
    public static void main(String[] args) throws InterruptedException {
        Channel channel = new Bootstrap()
                .group(new NioEventLoopGroup())
                .channel(NioSocketChannel.class)
                .handler(new ChannelInitializer<NioSocketChannel>() {
                    //连接建立后调用
                    @Override
                    protected void initChannel(NioSocketChannel sc) throws Exception {
                        sc.pipeline().addLast(new StringEncoder());
                    }
                })
                .connect(new InetSocketAddress("localhost", 8989))
                //阻塞方法，直至连接建立
                .sync()
                //代表连接对象
                .channel();
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()) {
            String str = scanner.next();
            if(!"quit".equals(str)){
                channel.writeAndFlush(str);
            }else {
                channel.close().sync();
                log.info("客户端断开");
            }
        }
    }
}