Hello Netty 25 Mar 2014

public class NettyEchoServer {
    private static Logger log = LoggerFactory.getLogger(NettyEchoServer.class);
    public void serve(int port) throws InterruptedException {
        NioEventLoopGroup group = new NioEventLoopGroup();
        ServerBootstrap bootstrap = new ServerBootstrap();  // 1. 新建一个bootstrap用来配置Server并启动
        bootstrap.group(group)                              // 2. 设置NioEventLoopGroup处理新连接以及消息
                 .channel(NioServerSocketChannel.class)     // 2
                 .localAddress(new InetSocketAddress(port))  // 2. 指定Server绑定的端口来接受新连接
                 .childHandler(new ChannelInitializer<SocketChannel>() {     // 3. 设置一个ChannelHandler来处理一个新连接
                     @Override
                     protected void initChannel(SocketChannel sc) throws Exception {
                         sc.pipeline().addLast(new EchoServerHandler());   // 4
                     }
                 });
        try {
            ChannelFuture f = bootstrap.bind().sync();   // 5. 绑定端口并启动Server
            log.info(NettyEchoServer.class.getSimpleName() + " started and listened on " + f.channel().localAddress());
            f.channel().closeFuture().sync();         // 6. 阻塞当前线程，直到ServerChannel关闭
        } catch (InterruptedException e) {
            log.error("Error", e);
        } finally {
            group.shutdownGracefully().sync();     // 7
        }
    }
}

@ChannelHandler.Sharable           // 在handler在channels间共享
public class EchoServerHandler extends ChannelInboundHandlerAdapter {
    private Logger log = LoggerFactory.getLogger(EchoServerHandler.class);
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        log.info("Server Read:" + msg);
        ctx.write(msg);     // 将接收到的消息发送回给客户端，这里并没有flush
    }
    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        // flush所有前面（pending）的消息，在所有操作完成后，关闭远程channel
        ctx.writeAndFlush(Unpooled.EMPTY_BUFFER).addListener(ChannelFutureListener.CLOSE);
    }
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        log.error("Server Error:", cause);
        ctx.close();    // 发生异常后，关闭远程channel
    }
}

public class NettyEchoClient {
    private final String host;
    private final int port;
    public NettyEchoClient(String host, int port) {
        this.host = host;
        this.port = port;
    }
    public void start() throws InterruptedException {
        NioEventLoopGroup group = new NioEventLoopGroup();
        Bootstrap bootstrap = new Bootstrap();    // 为client创建一个Bootstrap实例
        bootstrap.group(group)    // 由于使用NIO transport，所以使用NioEventLoopGroup
                 .channel(NioSocketChannel.class)  // 指定channel类型为NIO transport
                 .remoteAddress(new InetSocketAddress(host, port))  // 指定客户端连接到的服务端地址
                 .handler(new ChannelInitializer<SocketChannel>() {  // 使用ChannelInitializer指定ChannelHandler
                     @Override
                     protected void initChannel(SocketChannel ch) throws Exception {
                         ch.pipeline().addLast(new EchoClientHandler());
                     }
                 });
        try {
            ChannelFuture future = bootstrap.connect().sync();  // 启动客户端，连接到server; 调用sync方法阻塞线程直到成功连接到server
            future.channel().closeFuture().sync();   // 阻塞当前线程直到客户端连接关闭
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            group.shutdownGracefully().sync(); // 释放所有资源，以及所有创建的线程
        }
    }
}

@ChannelHandler.Sharable
public class EchoClientHandler extends SimpleChannelInboundHandler<ByteBuf> {
    private static Logger log = LoggerFactory.getLogger(EchoClientHandler.class);
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        // 当该客户端连接建立并连接到server后，发送消息到Server
        ctx.writeAndFlush(Unpooled.copiedBuffer("Hello, Netty", CharsetUtil.UTF_8));
    }
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        cause.printStackTrace();  
        ctx.close();   // 当异常发生时，打印堆栈信息并关闭连接
    }
    @Override
    protected void channelRead0(ChannelHandlerContext ctx, ByteBuf msg) throws Exception {
        // 接收并打印来自服务端的消息
        log.info("Client Read: {}", ByteBufUtil.hexDump(msg.readBytes(msg.readableBytes())));
    }
}