Netty：初识Netty

前文总结了NIO的内容，有了NIO的一些基础以后，咱们就能够来看下Netty。Netty是Java领域的高性能网络传输框架，RPC的技术核心就是网络传输和序列化，因此Netty给予了RPC在网络传输领域巨大的支持。

一个简单的Netty代码实现
网络传输基于的是TCP协议，因此会有服务端和客户端之分，而Netty是网络传输框架，因此一个完整的Netty代码至少是有服务端和客户端的。本文代码基于Netty4.1.15。

服务端：

public class DemoServer {
        public static void main(String[] args) throws Exception {
                EventLoopGroup bossGroup = new NioEventLoopGroup();
                EventLoopGroup workerGroup = new NioEventLoopGroup(); 
                try {
                        ServerBootstrap serverBootstrap = new ServerBootstrap();
                        serverBootstrap.group(bossGroup,workerGroup).
                                        channel(NioServerSocketChannel.class).
                                        childHandler(new ChannelInitializer<SocketChannel>() {
                                                @Override
                                                protected void initChannel(SocketChannel ch) throws Exception {
                                                        ch.pipeline().addLast(new StringDecoder(CharsetUtil.UTF_8));
                                                        ch.pipeline().addLast(new StringEncoder(CharsetUtil.UTF_8));
                                                        ch.pipeline().addLast(new DemoServerHandler());
                                                }
                                        });

        ChannelFuture future = serverBootstrap.bind(8899).sync();
        future.channel().closeFuture().sync();
    }finally {
        bossGroup.shutdownGracefully();
        workerGroup.shutdownGracefully();
    }
}
}
public class DemoServerHandler extends SimpleChannelInboundHandler<String> {
        @Override
        protected void channelRead0(ChannelHandlerContext ctx, String msg) throws Exception {
                System.out.println("" + ctx.channel().remoteAddress() + "," + msg);
                ctx.channel().writeAndFlush("from server" + UUID.randomUUID());
        }

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

}
客户端：

public class DemoClient {
        public static void main(String[] args) throws Exception{
                EventLoopGroup eventLoopGroup = new NioEventLoopGroup();

    try{
        Bootstrap bootstrap = new Bootstrap();
        bootstrap.group(eventLoopGroup).channel(NioSocketChannel.class).handler(new ChannelInitializer<SocketChannel>() {
            @Override
            protected void initChannel(SocketChannel ch) throws Exception {
                ch.pipeline().addLast(new StringDecoder(CharsetUtil.UTF_8));
                ch.pipeline().addLast(new StringEncoder(CharsetUtil.UTF_8));
                ch.pipeline().addLast(new DemoClientHandler());
            }
        });

        ChannelFuture channelFuture = bootstrap.connect("localhost",8899).sync();
        channelFuture.channel().closeFuture().sync();

    }finally {
        eventLoopGroup.shutdownGracefully();
    }
}

}
public class DemoClientHandler extends SimpleChannelInboundHandler<String> {br/>@Override
protected void channelRead0(ChannelHandlerContext ctx, String msg) throws Exception {
System.out.println("" + ctx.channel().remoteAddress());
System.out.println("client output:" + msg);
ctx.writeAndFlush("from client" + LocalDateTime.now());
}

@Override
public void channelActive(ChannelHandlerContext ctx) throws Exception {
    String msg = "来自客户端的问候!";
    ctx.writeAndFlush(msg);
}

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

}
来看下这个简单的代码作了什么：

一、服务端启动后，客户端先向服务端发起链接创建；

二、链接创建后，触发客户端的channelActive方法，该方法向服务端发出了一条信息，这条信息默认在网络中是会转成字节的形式来传输的，由于TCP的数据传输都是基于字节的，这个过程也叫作编码；

三、服务端收到信息后，会被服务端的Handler，其实就是StringDecoder先作处理，从字节变成了字符，这个过程也叫作解码；

四、此时对于DemoServerHandler来讲，信息已经变成了符合本身的String类型，因此channelRead0方法会被调用，输出信息，同时向客户端发出信息，信息又会转成字节的信息传向客户端；

五、客户端收到信息后，会被客户端解码成字符，触发客户端的channelRead0方法，输出客户端地址和收到的信息，再向服务端发送时间戳；

六、循环往复上述3-5，死循环；

模块化
从上述这个简单的DEMO中，咱们能够提取出Netty的核心模块：

一、Channel、EventLoop、ChannelFuture

Channel接口：基本的IO操做（bind()/connect()/read()/write()）依赖于底层网络传输所提供的原语。在咱们这个DEMO中，能看到NioServerSocketChannel和NioSocketChannel，NioServerSocketChannel使用基于NIO选择器的实现来接受新链接，NioSocketChannel使用基于NIO选择器的实现来创建和处理新链接。

EventLoop接口：EventLoop定义了Netty的核心抽象，用于处理链接的生命周期中所发生的事件。EventLoop是协调设计的一部分，采用了两个基本的API：并发和网络编程。在咱们这个DEMO中，能看到NioEventLoop，NioEventLoop就是一个Reactor，是整个Netty的一个核心。

ChannelFuture接口：Netty中的全部的IO操做都是异步的，由于一个操做可能不会当即返回，因此咱们须要一种用于在以后某个时间点肯定其结果的方法。为此，Netty提供了ChannelFuture接口，其addListener()方法注册了一个ChannelFutureListener，以便在某个操做完成是获得通知。

二、ChannelHandler、ChannelPipeline

ChannelHandler接口：从应用程序开发人员的角度来看，ChannelHandler是Netty的主要组件，它充当了全部处理入站和出站数据的应用程序逻辑的容器，由于ChannelHandler的方法是由事件来触发的。在咱们这个DEMO中，DemoClientHandler、DemoServerHandler就是两个自定义的ChannelHandler，DemoClientHandler在链接一创建的时候，就触发了channelActive方法，而后DemoServerHandler在channelRead0方法中读取了其传输的信息。

ChannelPipeline接口：ChannelPipeline为ChannelHandler链提供了容器，并定义了用于该链上传播入站和出站事件流的API。当Channel被建立时，它会被自动的分配到它所专属的ChannelPipeline。在咱们的DEMO中，一个ChannelInitializer的实例被注册到ServerBootStrap或者BootStrap，当它的initChannel方法被调用的时候，ChannelInitializer将在ChannelPipeline中安装一组自定义的ChannelHandler，最后ChannelInitializer将它本身从ChannelPipeline中移除。

三、ByteBuf

网络数据的基本单位是字节，NIO提供了ByteBuffer做为网络数据的字节容器，可是ByteBuffer自己设计并不优雅，使用繁琐，Netty使用ByteBuf来替代ByteBuffer，在咱们的DEMO中，不能直接看到ByteBuf，可是在Netty提供的内置编解码器StringDecoder/StringEncoder中，操做的对象就是ByteBuf。

四、ServerBootStrap、BootStrap

ServerBootStrap和BootStrap是一个很是抽象的概念。ServerBootStrap是Netty建立服务器的辅助类，负责封装服务启动的一系列操做。和ServerBootStrap同样，Bootstrap也是封装客户端向服务端发送请求的一系列操做。

五、Codec

经过Netty发送和接收一个消息的时候，就会发生一次数据转换，入站消息会被解码，也就是从字节转换为本来的形式，若是是出站消息，就会从一种形式变成字节，这个就是编码，编解码的根本缘由就是由于网络数据就是一系列的字节。在咱们的DEMO中，StringEncoder和StringDecoder就是编解码器。

最后总结一下：

一、经过一个简单的DEMO，介绍了一下Netty，站在应用的角度看了下Netty是如何运行的；

二、从DEMO中提取出Netty的重要的模块，简单介绍一下各个模块，在后续的文章中将详细介绍每一个模块组件。