第一个 Netty 程序

Bootstrap、EventLoop(Group) 、Channel

事件和 ChannelHandler、ChannelPipeline

         Netty 使用不同的事件来通知我们状态的改变或者是操作的状态。这使得我们能够基于

已经发生的事件来触发适当的动作。

        Netty 事件是按照它们与 入站 或 出站 数据流的相关性进行分类的。

        可能由入站数据或者相关的状态更改而触发的事件包括： 连接已被激活或者连接失活；

数据读取；用户事件；错误事件。

        出站事件是未来将会触发的某个动作的操作结果，这些动作包括： 打开或者关闭到远程

节点的连接；将数据写到或者冲刷到套接字。

         每个事件都可以被分发给 ChannelHandler 类中的某个用户实现的方法，既然事件分为

入站和出站，用来处理事件的 ChannelHandler 也被分为可以处理入站事件的 Handler 和出站

事件的 Handler，当然有些 Handler 既可以处理入站也可以处理出站。

         Netty 提供了大量预定义的可以开箱即用的 ChannelHandler 实现，包括用于各种协议

（如 HTTP 和 SSL/TLS）的 ChannelHandler。

        基于 Netty 的网络应用程序中根据业务需求会使用 Netty 已经提供的 ChannelHandler 或

者自行开发 ChannelHandler，这些 ChannelHandler 都放在 ChannelPipeline 中统一管理，事件

就会在 ChannelPipeline 中流动，并被其中一个或者多个 ChannelHandler 处理。

public class EchoServerHandler extends ChannelInboundHandlerAdapter {

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        ByteBuf in = (ByteBuf)msg;
        System.out.println("server accept :" + in.toString(CharsetUtil.UTF_8));
        ctx.writeAndFlush(in);

        //ctx.close();
    }

    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        System.out.println("连接已建立");
        super.channelActive(ctx);
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        cause.printStackTrace();
        ctx.close();
    }
}

客户端：

public class EchoClient {

    private final int port;
    private final String host;

    public EchoClient(int port, String host) {
        this.port = port;
        this.host = host;
    }

    public void start() throws InterruptedException {

        /*线程组*/
        EventLoopGroup group  = new NioEventLoopGroup();
        try {
            /*客户端启动必备，和服务器的不同点*/
            Bootstrap b = new Bootstrap();
            b.group(group)
                    .channel(NioSocketChannel.class)/*指定使用NIO的通信模式*/
                    /*指定服务器的IP地址和端口，和服务器的不同点*/
                    .remoteAddress(new InetSocketAddress(host,port))
                    /*和服务器的不同点*/
                    .handler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            ch.pipeline().addLast(new EchoClientHandler());

                        }
                    });
            /*异步连接到服务器，sync()会阻塞到完成，和服务器的不同点*/
            ChannelFuture f = b.connect().sync();
            f.channel().closeFuture().sync();/*阻塞当前线程，直到客户端的Channel被关闭*/
        } finally {
            group.shutdownGracefully().sync();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        new EchoClient(9999,"127.0.0.1").start();
    }
}

客户端处理：

public class EchoClientHandler extends SimpleChannelInboundHandler<ByteBuf> {

    /*读取到网络数据后进行业务处理,并关闭连接*/
    @Override
    protected void channelRead0(ChannelHandlerContext ctx, ByteBuf msg) throws Exception {
        System.out.println("client Accept"+msg.toString(CharsetUtil.UTF_8));
        //关闭连接
        ///ctx.close();
    }

    /*channel活跃后，做业务处理*/
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        ctx.writeAndFlush(Unpooled.copiedBuffer(
                "Hello,Netty",CharsetUtil.UTF_8));
//        ctx.pipeline().write()
//        ctx.channel().write()
        ctx.alloc().buffer();
    }
}