Netty 学习笔记（3） ------ ChannelPipeline 和 ChannelHandler

ChannelPipeline通过责任链设计模式组织逻辑代码（ChannelHandler）,ChannelHander就如同Servlet的Filter一样一层层处理Channel的读写数据。

ChannelPipeline和ChannelHander的构成

1. Channel Netty框架中，一个连接对应一个Channel
2. ChannelPipeline 一个Channel绑定一条ChannelPipeline，ChannelPipeline以双向链表的结构组织所属Channel的所有逻辑处理器ChannelHandler
3. ChannelHandler 逻辑处理器，ChannelHandler分为ChannelInboundHandler入站处理器（处理读请求）和ChannelOutboundHandler出站处理器（处理写请求）。一个ChannelHander可以添加到多条ChannelPipeline上。
4. ChannelHanderContext ChannelHandler添加到一条ChannelPipeline后，该Channelpipeline将创建一个ChannelHandlerContext与ChannelHandler绑定。ChannelHandlerContext能够拿到Channel相关的上下文信息。

ChannelInboundHandler 和 ChannelOutboundHandler

1. ChannelInboundHandler 入站处理器，主要处理读请求的逻辑，它将按照它被添加的顺序处理数据。
2. ChannelOutboundHandler 出站处理器，主要处理写请求的逻辑，它将按照被添加的反顺序处理数据。
3. ChannelInboundHandlerAdapter和ChannelOutboundHandlerAdapter 实现了两大接口的所有功能，默认将事件提交给下一个处理器。

代码例子

入站处理器inboundHandler打印接受数据然后提交给下一个处理器，而出站处理器outboundHander打印写出数据然后提交给下一个处理器，writerHander在有客户端连接成功时写出helloClinet。

    public class HanderServerDemo {

        public static void main(String[] args) {
            HanderServerDemo server = new HanderServerDemo();
            server.init();
        }
    
        public void init(){
            NioEventLoopGroup bossGroup = new NioEventLoopGroup();
            NioEventLoopGroup workerGroup = new NioEventLoopGroup();
    
            ServerBootstrap serverBootstrap = new ServerBootstrap();
            serverBootstrap.group(bossGroup, workerGroup)
                    .localAddress(8000)
                    .channel(NioServerSocketChannel.class)
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel socketChannel) throws Exception {
                            // inBound，处理读数据的逻辑链
                            socketChannel.pipeline().addLast(new InBoundHandlerA());
                            socketChannel.pipeline().addLast(new InBoundHandlerB());
                            socketChannel.pipeline().addLast(new InBoundHandlerC());
    
                            //channel连接成功，返回hello client
                            socketChannel.pipeline().addLast(new WriteHandler());
    
                            // outBound，处理写数据的逻辑链
                            socketChannel.pipeline().addLast(new OutBoundHandlerA());
                            socketChannel.pipeline().addLast(new OutBoundHandlerB());
                            socketChannel.pipeline().addLast(new OutBoundHandlerC());
                        }
                    });
            serverBootstrap.bind().addListener((future)->{
                if(future.isSuccess()){
                    System.out.println("端口绑定成功");
                }else{
                    System.out.println("端口绑定失败:"+future.cause());
                }
            });
        }
    
        public class InBoundHandlerA extends ChannelInboundHandlerAdapter {
            @Override
            public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
                System.out.println("InBoundHandlerA: " + msg);
                super.channelRead(ctx, msg);
            }
        }
    
        public class InBoundHandlerB extends ChannelInboundHandlerAdapter {
            @Override
            public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
                System.out.println("InBoundHandlerB: " + msg);
                super.channelRead(ctx, msg);
            }
        }
    
        public class InBoundHandlerC extends ChannelInboundHandlerAdapter {
            @Override
            public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
                System.out.println("InBoundHandlerC: " + msg);
                super.channelRead(ctx, msg);
            }
        }
    
        public class WriteHandler extends ChannelInboundHandlerAdapter {
            @Override
            public void channelActive(ChannelHandlerContext ctx) throws Exception {
                ctx.channel().writeAndFlush(Unpooled.copiedBuffer("hello client".getBytes()));
            }
        }
    
        public class OutBoundHandlerA extends ChannelOutboundHandlerAdapter {
            @Override
            public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception {
                System.out.println("OutBoundHandlerA: " + msg);
                super.write(ctx, msg, promise);
            }
        }
    
        public class OutBoundHandlerB extends ChannelOutboundHandlerAdapter {
            @Override
            public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception {
                System.out.println("OutBoundHandlerB: " + msg);
                super.write(ctx, msg, promise);
            }
        }
    
        public class OutBoundHandlerC extends ChannelOutboundHandlerAdapter {
            public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception {
                System.out.println("OutBoundHandlerC: " + msg);
                super.write(ctx, msg, promise);
            }
        }   
    }

可以看读请求的数据时顺handler添加的顺序处理的，A-->B-->C
而写请求的处理是逆着添加顺序的，C-->B-->A

参考资料

netty in action
Netty 入门与实战：仿写微信 IM 即时通讯系统

转载于:https://www.cnblogs.com/wuweishuo/p/10891708.html