Netty中ctx.writeAndFlush与ctx.channel().writeAndFlush的区别

最近在写netty相关代码，发现writeAndFlush这个方法既可以在ctx上调用，也可以在channel上调用，这两者有什么区别呢，于是就做了一个小实验。具体的代码在最后

Client端

client的handler

这次我们主要在服务端进行实验，因此client端就简单构造一个handler用来接收发来的信息并传送回去，以形成和server通信的态势。

public class C_I_1 extends ChannelInboundHandlerAdapter{
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        Number n = (Number)msg;
        System.out.println("C in 111 get num = " + n.getNum());
        n.add();
        ctx.writeAndFlush(n);
    }
}

这里构建了一个Number实体类，就是存一个数而已。add方法就是让类的数加一。client的handler就是这个了。

client构建

这就是日常的netty客户端的构建方法，具体的怎么绑定什么的不讲了。然后我们在连接服务端之后向服务端发出一个数字1

public class Client {
    static String host = "127.0.0.1";
    static int port = 10010;
    public static void main(String[] args) {
        EventLoopGroup group = new NioEventLoopGroup();
        Bootstrap b = new Bootstrap();
        b.group(group)
                .channel(NioSocketChannel.class)
                .option(ChannelOption.TCP_NODELAY,true)
                .handler(new ChannelInitializer<SocketChannel>() {
                    @Override
                    protected void initChannel(SocketChannel ch) throws Exception {
                        //这里一定要加入这两个类，是用来给object编解码的，如果没有就无法传送对象
                        //并且，实体类要实现Serializable接口，否则也无法传输
                        ch.pipeline().addLast(new ObjectEncoder());
                        ch.pipeline().addLast(new ObjectDecoder(Integer.MAX_VALUE,
                                ClassResolvers.weakCachingConcurrentResolver(null))); // 最大长度
                        ch.pipeline().addLast(new C_I_1());
                    }
                });
        try {
            Number n = new Number();
            n.setNum(1);
            ChannelFuture f =b.connect(host,port).sync();
            f.channel().writeAndFlush(n);
            f.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            group.shutdownGracefully();
        }
    }
}

Server端

Server的handler就稍微多一点，为了验证ctx和channel的writeAndFlush到底有什么不同，我们决定建立四个Handler，两个out,两个In，然后交换它们的顺序来看效果。

handler

这里的handler就是接受一个Number类，然后让这个数加一再进行下一步操作。

inboundhandler

public class S_I_1 extends ChannelInboundHandlerAdapter{
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        Number n = (Number)msg;
        System.out.println("S in 111 get num = " + n.getNum());
        n.add();
        ctx.fireChannelRead(n);
        //ctx.channel().writeAndFlush(n);
    }
}

outboundhandler

public class S_O_1 extends ChannelOutboundHandlerAdapter {

    @Override
    public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception {
        Number n = (Number)msg;
        System.out.println("S out 111 get num = " + n.getNum());
        n.add();
        ctx.writeAndFlush(n);
    }
}

服务器构建

public class Server {
    public static void main(String[] args) {
        EventLoopGroup bossGroup = new NioEventLoopGroup(),workerGroup = new NioEventLoopGroup();
        ServerBootstrap b = new ServerBootstrap();
        b.group(bossGroup,workerGroup)
                .channel(NioServerSocketChannel.class)
                .option(ChannelOption.SO_BACKLOG,1024)
                .childOption(ChannelOption.SO_KEEPALIVE,true)
                .childHandler(new ChannelInitializer<SocketChannel>() {
                    @Override
                    protected void initChannel(SocketChannel ch) throws Exception {
                        //这个object转换的如果不放在前面会在发送的时候找不到out
                        ch.pipeline().addLast(new ObjectEncoder());
                        ch.pipeline().addLast(new ObjectDecoder(Integer.MAX_VALUE,
                                ClassResolvers.weakCachingConcurrentResolver(null))); // 最大长度
                        ch.pipeline().addLast(new S_I_1());
                        ch.pipeline().addLast(new S_O_1());
                        ch.pipeline().addLast(new S_I_2());
                        ch.pipeline().addLast(new S_O_2());
                    }
                });
        try {
            ChannelFuture f = b.bind(10010).sync();
            f.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }
}

实验

先说实验结论就是ctx的writeAndFlush是从当前handler直接发出这个消息，而channel的writeAndFlush是从整个pipline最后一个outhandler发出。怎么样，是不是很抽象，下面画图来看一看：

啊，首先解释一下这个图，黑色的是inhandler，红色的是outhandler，前面圆形的是编解码器，必须放在pipline的最前头，否则会让信息发不出去。然后，连接建立之后，in接收到一个数1，选择ctx的writeAndFlush，那么这个数，就会直接从圆形的out出去，因为我们的结论说了，就是从当前的handler直接发出去这个消息。如果使用ctx.channel().writeAndFlush()呢，就会让这个数从红色的2开始发送，经过红色1，再发出去。

让我们看一看另一种情况：

这种情况下，我们让黑色1接收到信息之后fire到黑色2，然后让黑色2把信息writeAndFlush出去，如果使用ctx.writeAndFlush()，那么这个信息就会经过红色1而不经过红色2，如果使用ctx.channel().writeAndFlush()就会从pipline的尾部，也就是红色2开始，经过红色1发出去。

下午写代码的时候突然想到了这种情况，就是在红色的2里，如果用channel的writeAndFlush会有什么样的结果。实验之后发现，是一个死循环，2通过channel的writeAndFlush把消息送回pipline尾部，然后自己获得这个消息，再送回尾部，这样永远都发不出了，这一定要注意哦

好的，就是这样了。

这里是资源(为啥不让免费了)