Netty是由JBOSS提供的一个java开源框架。Netty提供异步的、事件驱动的网络应用程序框架和工具，用以快速开发高性能、高可靠性的网络服务器和客户端程序。
也就是说，Netty 是一个基于NIO的客户、服务器端编程框架，使用Netty 可以确保你快速和简单的开发出一个网络应用，例如实现了某种协议的客户，服务端应用。Netty相当简化和流线化了网络应用的编程开发过程，例如，TCP和UDP的socket服务开发。
“快速”和“简单”并不用产生维护性或性能上的问题。Netty 是一个吸收了多种协议的实现经验，这些协议包括FTP,SMTP,HTTP，各种二进制，文本协议，并经过相当精心设计的项目，最终，Netty 成功的找到了一种方式，在保证易于开发的同时还保证了其应用的性能，稳定性和伸缩性。

1. Netty 之传输

OIO——阻塞传输
NIO——异步传输
Local——JVM内部异步传输
Embedded——测试ChannelHander

流经网络的数据总是具有相同的类型——字节。这些字节是如何流动的主要取决于我们所说的网络传输(一个帮助我们抽象底层数据传输机制的概念)。用户并不关心这些细节，他们只是想确保他们的字节数据被可靠的发送和接受。

如果你有 Java 网络编程的经验，那么你可能已经发现，在某些时候，你需要支撑比预期多
很多的并发连接。

然而，Netty 为它所有的传输实现提供了一个通用 API，这使得这种转换比你直接使用 JDK
所能够达到的简单得多。

1.1 传统的OIO和NIO

先看看不使用Netty,仅使用传统的JDK API的阻塞（OIO）版本和异步（NIO）版本.

public class PlainOioServer {
        public void serve(int port) throws IOException {
            final ServerSocket socket = new ServerSocket(port);
            try {
                for (;;) {
                    final Socket clientSocket = socket.accept();
                    System.out.println(
                            "Accepted connection from " + clientSocket);
                    new Thread(new Runnable() {
                        @Override
                        public void run() {
                            OutputStream out;
                            try {
                                out = clientSocket.getOutputStream();
                                out.write("Hi!\r\n".getBytes(
                                        Charset.forName("UTF-8")));
                                out.flush();
                                clientSocket.close();
                            }
                            catch (IOException e) {
                                e.printStackTrace();
                            }
                            finally {
                                try {
                                    clientSocket.close();
                                }
                                catch (IOException ex) {
                                }
                            }
                        }
                    }).start();
                }
            }
            catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

这段代码完全可以处理中等数量的并发客户端。但是随着应用程序变得流行起来，你会发现
它并不能很好地伸缩到支撑成千上万的并发连入连接。你决定改用异步网络编程，但是很快就发
现异步 API 是完全不同的，以至于现在你不得不重写你的应用程序。

public class PlainNioServer {
        public void serve(int port) throws IOException {
            ServerSocketChannel serverChannel = ServerSocketChannel.open();
            serverChannel.configureBlocking(false);
            ServerSocket ssocket = serverChannel.socket();
            InetSocketAddress address = new InetSocketAddress(port);
            ssocket.bind(address);
            Selector selector = Selector.open();
            serverChannel.register(selector, SelectionKey.OP_ACCEPT);
            final ByteBuffer msg = ByteBuffer.wrap("Hi!\r\n".getBytes());
            for (;;) {
                try {
                    selector.select();
                } catch (IOException ex) {
                    ex.printStackTrace();
// handle exception
                    break;
                }
                Set<SelectionKey> readyKeys = selector.selectedKeys();
                Iterator<SelectionKey> iterator = readyKeys.iterator();
                while (iterator.hasNext()) {
                    SelectionKey key = iterator.next();
                    iterator.remove();
                    try {
                        if (key.isAcceptable()) {
                            ServerSocketChannel server =
                                    (ServerSocketChannel)key.channel();
                            SocketChannel client = server.accept();
                            client.configureBlocking(false);
                            client.register(selector, SelectionKey.OP_WRITE |
                                    SelectionKey.OP_READ, msg.duplicate());
                            System.out.println(
                                    "Accepted connection from " + client);
                        }
                        if (key.isWritable()) {
                            SocketChannel client =
                                    (SocketChannel)key.channel();
                            ByteBuffer buffer =
                                    (ByteBuffer)key.attachment();
                            while (buffer.hasRemaining()) {
                                if (client.write(buffer) == 0) {
                                    break;
                                }
                            }
                            client.close();
                        }
                    } catch (IOException ex) {
                        key.cancel();
                        try {
                            key.channel().close();

                        } catch (IOException cex) {
// ignore on close
                        }
                    }
                }
            }
        }
    }

如同你所看到的，虽然这段代码所做的事情与之前的版本完全相同，但是代码却截然不同。
如果为了用于非阻塞 I/O 而重新实现这个简单的应用程序，都需要一次完全的重写的话，那么不
难想象，移植真正复杂的应用程序需要付出什么样的努力。
鉴于此，让我们来看看使用 Netty 实现该应用程序将会是什么样子吧。

1.2 Netty实现的OIO 和NIO

先来看看使用Netty实现OIO:

public class NettyOioServer {
       public void server(int port) throws Exception {
           final ByteBuf buf = Unpooled.unreleasableBuffer(
                   Unpooled.copiedBuffer("Hi!\r\n", Charset.forName("UTF-8")));
           EventLoopGroup group = new OioEventLoopGroup();
           try {
               ServerBootstrap b = new ServerBootstrap();
               b.group(group)
                       .channel(OioServerSocketChannel.class)
                       .localAddress(new InetSocketAddress(port))
                       .childHandler(new ChannelInitializer<SocketChannel>() {
                           @Override
                           public void initChannel(SocketChannel ch)
                                   throws Exception {
                               ch.pipeline().addLast(
                                       new ChannelInboundHandlerAdapter() {
                                           @Override
                                           public void channelActive(
                                                   ChannelHandlerContext ctx)
                                                   throws Exception {
                                               ctx.writeAndFlush(buf.duplicate())
                                                       .addListener(
                                                               ChannelFutureListener.CLOSE);
                                           }
                                       });
                           }
                       });
               ChannelFuture f = b.bind().sync();
               f.channel().closeFuture().sync();
           } finally {
               group.shutdownGracefully().sync();
           }
       }
   }

接下来，我们使用 Netty 和非阻塞 I/O 来实现同样的逻辑。你会发现Netty 为我们处理两者之间的差异,只需要改动一点点就可以从OIO 转换到NIO.

public class NettyNioServer {
        public void server(int port) throws Exception {
            final ByteBuf buf = Unpooled.copiedBuffer("Hi!\r\n",
                    Charset.forName("UTF-8"));
            EventLoopGroup group = new NioEventLoopGroup();
            try {
                ServerBootstrap b = new ServerBootstrap();
                b.group(group).channel(NioServerSocketChannel.class)
                        .localAddress(new InetSocketAddress(port))
                        .childHandler(new ChannelInitializer<SocketChannel>() {
                            @Override
                            public void initChannel(SocketChannel ch)
                                    throws Exception{
                                ch.pipeline().addLast(
                                        new ChannelInboundHandlerAdapter() {
                                            @Override
                                            public void channelActive(
                                                    ChannelHandlerContext ctx) throws Exception {
                                                ctx.writeAndFlush(buf.duplicate())
                                                        .addListener(
                                                                ChannelFutureListener.CLOSE);
                                            }
                                        });
                            }
                        });
                ChannelFuture f = b.bind().sync();
                f.channel().closeFuture().sync();
            } finally {
                group.shutdownGracefully().sync();
            }
        }
    }

因为 Netty 为每种传输的实现都暴露了相同的API，所以无论选用哪一种传输的实现，你的
代码都仍然几乎不受影响。在所有的情况下，传输的实现都依赖于 interface Channel、ChannelPipeline 和 ChannelHandler。在看过一些使用基于 Netty的传输的这些优点之后，让我们仔细看看传输 API 本身。