高清思维导图原件(xmind/pdf/jpg)能够关注公众号：一枝花算不算浪漫 回复nio即可。

前言

道歉好久没更原创文章了，看了下上篇更新工夫，曾经拖更一个多月了。

这段时间也始终在学习Netty相干常识，因为波及知识点比拟多，也走了不少弯路。目前网上对于Netty学习材料玲琅满目，不知如何下手，其实大家都是一样的，学习办法和技巧都是总结进去的，咱们在没有找到很好的办法之前不如循序渐进先从根底开始，个别从总分总的渐进形式，既观森林，又见草木。

之前凑巧跟杭州一个敌人小飞也提到过，两者在这方面的初衷是统一的，也心愿更多的敌人可能退出一起学习和探讨。（PS：本篇文章是和小飞一起学习整顿所得~）

Netty是一款提供异步的、事件驱动的网络应用程序框架和工具，是基于NIO客户端、服务器端的编程框架。所以这里咱们先以NIO和依赖相干的根底铺垫来进行分析解说，从而作为Netty学习之旅的一个开始。

一、网络编程根底回顾

1. Socket

Socket自身有“插座”的意思，不是Java中特有的概念，而是一个语言无关的规范，任何能够实现网络编程的编程语言都有Socket。在Linux环境下，用于示意过程间网络通信的非凡文件类型，其本质为内核借助缓冲区造成的伪文件。既然是文件，那么天经地义的，咱们能够应用文件描述符援用套接字。

与管道相似的，Linux零碎将其封装成文件的目标是为了对立接口，使得读写套接字和读写文件的操作统一。区别是管道次要利用于本地过程间通信，而套接字多利用于网络过程间数据的传递。

能够这么了解：Socket就是网络上的两个应用程序通过一个双向通信连贯实现数据交换的编程接口API。

Socket通信的根本流程具体步骤如下所示:

（1）服务端通过Listen开启监听，期待客户端接入。

（2）客户端的套接字通过Connect连贯服务器端的套接字，服务端通过Accept接管客户端连贯。在connect-accept过程中，操作系统将会进行三次握手。

（3）客户端和服务端通过write和read发送和接收数据，操作系统将会实现TCP数据的确认、重发等步骤。

（4）通过close敞开连贯，操作系统会进行四次挥手。

针对Java编程语言，java.net包是网络编程的根底类库。其中ServerSocket和Socket是网络编程的根底类型。

SeverSocket是服务端利用类型。Socket是建设连贯的类型。当连贯建设胜利后，服务器和客户端都会有一个Socket对象示例，能够通过这个Socket对象示例，实现会话的所有操作。对于一个残缺的网络连接来说，Socket是平等的，没有服务器客户端分级状况。

2. IO模型介绍

对于一次IO操作，数据会先拷贝到内核空间中，而后再从内核空间拷贝到用户空间中，所以一次read操作，会经验两个阶段：

（1）期待数据筹备

（2）数据从内核空间拷贝到用户空间

基于以上两个阶段就产生了五种不同的IO模式。

  1. 阻塞IO：从过程发动IO操作，始终期待上述两个阶段实现，此时两阶段一起阻塞。
  2. 非阻塞IO：过程始终询问IO筹备好了没有，筹备好了再发动读取操作，这时才把数据从内核空间拷贝到用户空间。第一阶段不阻塞但要轮询，第二阶段阻塞。
  3. 多路复用IO：多个连贯应用同一个select去询问IO筹备好了没有，如果有筹备好了的，就返回有数据筹备好了，而后对应的连贯再发动读取操作，把数据从内核空间拷贝到用户空间。两阶段离开阻塞。
  4. 信号驱动IO：过程发动读取操作会立刻返回，当数据筹备好了会以告诉的模式通知过程，过程再发动读取操作，把数据从内核空间拷贝到用户空间。第一阶段不阻塞，第二阶段阻塞。
  5. 异步IO：过程发动读取操作会立刻返回，等到数据筹备好且曾经拷贝到用户空间了再告诉过程拿数据。两个阶段都不阻塞。

这五种IO模式不难发现存在这两对关系：同步和异步、阻塞和非阻塞。那么略微解释一下：

同步和异步

  • 同步： 同步就是发动一个调用后，被调用者未解决完申请之前，调用不返回。
  • 异步： 异步就是发动一个调用后，立即失去被调用者的回应示意已接管到申请，然而被调用者并没有返回后果，此时咱们能够解决其余的申请，被调用者通常依附事件，回调等机制来告诉调用者其返回后果。

同步和异步的区别最大在于异步的话调用者不须要期待处理结果，被调用者会通过回调等机制来告诉调用者其返回后果。

阻塞和非阻塞

  • 阻塞： 阻塞就是发动一个申请，调用者始终期待申请后果返回，也就是以后线程会被挂起，无奈从事其余工作，只有当条件就绪能力持续。
  • 非阻塞： 非阻塞就是发动一个申请，调用者不必始终等着后果返回，能够先去干其余事件。

阻塞和非阻塞是针对过程在拜访数据的时候，依据IO操作的就绪状态来采取的不同形式，说白了是一种读取或者写入操作方法的实现形式，阻塞形式下读取或者写入函数将始终期待，而非阻塞形式下，读取或者写入办法会立刻返回一个状态值。

如果组合后的同步阻塞(blocking-IO)简称BIO、同步非阻塞(non-blocking-IO)简称NIO和异步非阻塞(asynchronous-non-blocking-IO)简称AIO又代表什么意思呢？

  • BIO (同步阻塞I/O模式): 数据的读取写入必须阻塞在一个线程内期待其实现。这里应用那个经典的烧开水例子，这里假如一个烧开水的场景，有一排水壶在烧开水，BIO的工作模式就是， 叫一个线程停留在一个水壶那，直到这个水壶烧开，才去解决下一个水壶。然而实际上线程在期待水壶烧开的时间段什么都没有做。
  • NIO(同步非阻塞): 同时反对阻塞与非阻塞模式，但这里咱们以其同步非阻塞I/O模式来阐明，那么什么叫做同步非阻塞？如果还拿烧开水来说，NIO的做法是叫一个线程一直的轮询每个水壶的状态，看看是否有水壶的状态产生了扭转，从而进行下一步的操作。
  • AIO(异步非阻塞I/O模型): 异步非阻塞与同步非阻塞的区别在哪里？异步非阻塞无需一个线程去轮询所有IO操作的状态扭转，在相应的状态扭转后，零碎会告诉对应的线程来解决。对应到烧开水中就是，为每个水壶下面装了一个开关，水烧开之后，水壶会主动告诉我水烧开了。

java 中的 BIO、NIO和AIO了解为是 Java 语言在操作系统层面对这三种 IO 模型的封装。程序员在应用这些 封装API 的时候，不须要关怀操作系统层面的常识，也不须要依据不同操作系统编写不同的代码，只须要应用Java的API就能够了。由此，为了使读者对这三种模型有个比拟具体和递推式的理解，并且和本文主题NIO有个清晰的比照，上面持续延长。

Java BIO

BIO编程形式通常是是Java的上古产品，自JDK 1.0-JDK1.4就有的货色。编程实现过程为：首先在服务端启动一个ServerSocket来监听网络申请，客户端启动Socket发动网络申请，默认状况下SeverSocket会建设一个线程来解决此申请，如果服务端没有线程可用，客户端则会阻塞期待或受到回绝。服务器实现模式为一个连贯一个线程，即客户端有连贯申请时服务器端就须要启动一个线程进行解决。大抵构造如下：

如果要让 BIO 通信模型可能同时解决多个客户端申请，就必须应用多线程（次要起因是 socket.accept()、socket.read()、 socket.write() 波及的三个次要函数都是同步阻塞的），也就是说它在接管到客户端连贯申请之后为每个客户端创立一个新的线程进行链路解决，解决实现之后，通过输入流返回应答给客户端，线程销毁。这就是典型的 一申请一应答通信模型 。咱们能够构想一下如果这个连贯不做任何事件的话就会造成不必要的线程开销，不过能够通过线程池机制改善，线程池还能够让线程的创立和回收老本绝对较低。应用线程池机制改善后的 BIO 模型图如下:

BIO形式实用于连贯数目比拟小且固定的架构，这种形式对服务器资源要求比拟高，并发局限于利用中，是JDK1.4以前的惟一抉择，但程序直观简略易懂。Java BIO编程示例网上很多，这里就不进行coding举例了，毕竟前面NIO才是重点。

Java NIO

NIO（New IO或者No-Blocking IO），从JDK1.4 开始引入的非阻塞IO，是一种非阻塞+ 同步的通信模式。这里的No Blocking IO用于辨别下面的BIO。

NIO自身想解决 BIO的并发问题，通过Reactor模式的事件驱动机制来达到Non Blocking的。当 socket 有流可读或可写入 socket 时，操作系统会相应的告诉应用程序进行解决，利用再将流读取到缓冲区或写入操作系统。

也就是说，这个时候，曾经不是一个连贯就 要对应一个解决线程了，而是无效的申请，对应一个线程，当连贯没有数据时，是没有工作线程来解决的。

当一个连贯创立后，不须要对应一个线程，这个连贯会被注册到 多路复用器下面，所以所有的连贯只须要一个线程就能够搞定，当这个线程中的多路复用器 进行轮询的时候，发现连贯上有申请的话，才开启一个线程进行解决，也就是一个申请一个线程模式。

NIO提供了与传统BIO模型中的Socket和ServerSocket绝对应的SocketChannel和ServerSocketChannel两种不同的套接字通道实现，如下图构造所示。这里波及的Reactor设计模式、多路复用Selector、Buffer等临时不必管，前面会讲到。

NIO 形式实用于连贯数目多且连贯比拟短(轻操作)的架构，比方聊天服务器，并发局 限于利用中，编程简单，JDK1.4 开始反对。同时，NIO和一般IO的区别次要能够从存储数据的载体、是否阻塞等来辨别：

Java AIO

与 NIO 不同，当进行读写操作时，只须间接调用 API 的 read 或 write 办法即可。这两种办法均为异步的，对于读操作而言，当有流可读取时，操作系统会将可读的流传入 read 方 法的缓冲区，并告诉应用程序；对于写操作而言，当操作系统将 write 办法传递的流写入结束时，操作系统被动告诉应用程序。即能够了解为，read/write 办法都是异步的，实现后会被动调用回调函数。在 JDK7 中，提供了异步文件通道和异步套接字通道的实现，这部分内容被称作 NIO.

AIO 形式应用于连贯数目多且连贯比拟长(重操作)的架构，比方相册服务器，充沛调用 OS 参加并发操作，编程比较复杂，JDK7 开始反对。

目前来说 AIO 的利用还不是很宽泛，Netty 之前也尝试应用过 AIO，不过又放弃了。

二、NIO外围组件介绍

1. Channel

在NIO中，根本所有的IO操作都是从Channel开始的，Channel通过Buffer(缓冲区)进行读写操作。

read()示意读取通道中数据到缓冲区，write()示意把缓冲区数据写入到通道。

Channel有好多实现类，这里有三个最罕用：

  • SocketChannel：一个客户端发动TCP连贯的Channel
  • ServerSocketChannel：一个服务端监听新连贯的TCP Channel，对于每一个新的Client连贯，都会建设一个对应的SocketChannel
  • FileChannel：从文件中读写数据

其中SocketChannel和ServerSocketChannel是网络编程中最罕用的，一会在最初的示例代码中会有解说到具体用法。

2. Buffer

概念

Buffer也被成为内存缓冲区，实质上就是内存中的一块，咱们能够将数据写入这块内存，之后从这块内存中读取数据。也能够将这块内存封装成NIO Buffer对象，并提供一组罕用的办法，不便咱们对该块内存进行读写操作。

Buffer在java.nio中被定义为抽象类：

咱们能够将Buffer了解为一个数组的封装，咱们最罕用的ByteBuffer对应的数据结构就是byte[]

属性

Buffer中有4个十分重要的属性：capacity、limit、position、mark

  • capacity属性：容量，Buffer可能包容的数据元素的最大值，在Buffer初始化创立的时候被赋值，而且不能被批改。

上图中，初始化Buffer的容量为8（图中从0~7，共8个元素），所以capacity = 8

  • limit属性：代表Buffer可读可写的下限。

    • 写模式下：limit 代表能写入数据的下限地位，这个时候limit = capacity

读模式下：在Buffer实现所有数据写入后，通过调用flip()办法，切换到读模式，此时limit等于Buffer中理论曾经写入的数据大小。因为Buffer可能没有被写满，所以limit<=capacity

  • position属性：代表读取或者写入Buffer的地位。默认为0。

    • 写模式下：每往Buffer中写入一个值，position就会主动加1，代表下一次写入的地位。
    • 读模式下：每往Buffer中读取一个值，position就主动加1，代表下一次读取的地位。

从上图就能很清晰看出，读写模式下capacity、limit、position的关系了。

  • mark属性：代表标记，通过mark()办法，记录以后position值，将position值赋值给mark，在后续的写入或读取过程中，能够通过reset()办法复原以后position为mark记录的值。

这几个重要属性讲完，咱们能够再来回顾下：

0 <= mark <= position <= limit <= capacity

当初应该很清晰这几个属性的关系了~

Buffer常见操作

创立Buffer
  • allocate(int capacity)
ByteBuffer buffer = ByteBuffer.allocate(1024);int count = channel.read(buffer);

例子中创立的ByteBuffer是基于堆内存的一个对象。

  • wrap(array)

wrap办法能够将数组包装成一个Buffer对象:

ByteBuffer buffer = ByteBuffer.wrap("hello world".getBytes());channel.write(buffer);
  • allocateDirect(int capacity)

通过allocateDirect办法也能够疾速实例化一个Buffer对象，和allocate很类似，这里区别的是allocateDirect创立的是基于堆外内存的对象。

堆外内存不在JVM堆上，不受GC的治理。堆外内存进行一些底层零碎的IO操作时，效率会更高。

Buffer写操作

Buffer写入能够通过put()和channel.read(buffer)两种形式写入。

通常咱们NIO的读操作的时候，都是从Channel中读取数据写入Buffer，这个对应的是Buffer的写操作。

Buffer读操作

Buffer读取能够通过get()和channel.write(buffer)两种形式读入。

还是同上，咱们对Buffer的读入操作，反过来说就是对Channel的写操作。读取Buffer中的数据而后写入Channel中。

其余常见办法
  • rewind()：重置position地位为0，能够从新读取和写入buffer，个别该办法实用于读操作，能够了解为对buffer的反复读。
public final Buffer rewind() {    position = 0;    mark = -1;    return this;}
  • flip()：很罕用的一个办法，个别在写模式切换到读模式的时候会常常用到。也会将position设置为0，而后设置limit等于原来写入的position。
public final Buffer flip() {    limit = position;    position = 0;    mark = -1;    return this;}
  • clear()：重置buffer中的数据，该办法次要是针对于写模式，因为limit设置为了capacity，读模式下会出问题。
public final Buffer clear() {    position = 0;    limit = capacity;    mark = -1;    return this;}
  • mark()&reset(): mark()办法是保留以后position到变量markz中，而后通过reset()办法复原以后position为mark，实现代码很简略，如下：
public final Buffer mark() {    mark = position;    return this;}public final Buffer reset() {    int m = mark;    if (m < 0)        throw new InvalidMarkException();    position = m;    return this;}

罕用的读写办法能够用一张图总结一下：

3. Selector

概念

Selector是NIO中最为重要的组件之一，咱们经常说的多路复用器就是指的Selector组件。
Selector组件用于轮询一个或多个NIO Channel的状态是否处于可读、可写。通过轮询的机制就能够治理多个Channel，也就是说能够治理多个网络连接。

轮询机制

  1. 首先，须要将Channel注册到Selector上，这样Selector才晓得须要治理哪些Channel
  2. 接着Selector会一直轮询其上注册的Channel，如果某个Channel产生了读或写的工夫，这个Channel就会被Selector轮询进去，而后通过SelectionKey能够获取就绪的Channel汇合，进行后续的IO操作。

属性操作

  1. 创立Selector

通过open()办法，咱们能够创立一个Selector对象。

Selector selector = Selector.open();
  1. 注册Channel到Selector中

咱们须要将Channel注册到Selector中，才可能被Selector治理。

channel.configureBlocking(false);SelectionKey key = channel.register(selector, SelectionKey.OP_READ);

某个Channel要注册到Selector中，那么该Channel必须是非阻塞，所有下面代码中有个configureBlocking()的配置操作。

在register(Selector selector, int interestSet)办法的第二个参数，标识一个interest汇合，意思是Selector对哪些事件感兴趣，能够监听四种不同类型的事件：

public static final int OP_READ = 1 << 0;public static final int OP_WRITE = 1 << ;public static final int OP_CONNECT = 1 << 3;public static final int OP_ACCEPT = 1 << 4;
  • Connect事件 ：连贯实现事件( TCP 连贯 )，仅实用于客户端，对应 SelectionKey.OP_CONNECT。
  • Accept事件 ：承受新连贯事件，仅实用于服务端，对应 SelectionKey.OP_ACCEPT 。
  • Read事件 ：读事件，实用于两端，对应 SelectionKey.OP_READ ，示意 Buffer 可读。
  • Write事件 ：写工夫，实用于两端，对应 SelectionKey.OP_WRITE ，示意 Buffer 可写。

Channel触发了一个事件，表明该工夫曾经准备就绪：

  • 一个Client Channel胜利连贯到另一个服务器，成为“连贯就绪”
  • 一个Server Socket筹备好接管新进入的接，称为“接管就绪”
  • 一个有数据可读的Channel，称为“读就绪”
  • 一个期待写数据的Channel，称为”写就绪“

当然，Selector是能够同时对多个事件感兴趣的，咱们应用或运算即可组合多个事件：

int interestSet = SelectionKey.OP_READ | SelectionKey.OP_WRITE;

Selector其余一些操作

抉择Channel
public abstract int select() throws IOException;public abstract int select(long timeout) throws IOException;public abstract int selectNow() throws IOException;

当Selector执行select()办法就会产生阻塞，等到注册在其上的Channel准备就绪就会立刻返回，返回准备就绪的数量。

select(long timeout)则是在select()的根底上减少了超时机制。
selectNow()立刻返回，不产生阻塞。

有一点十分须要留神： select 办法返回的 int 值，示意有多少 Channel 曾经就绪。

自上次调用select 办法后有多少 Channel 变成就绪状态。如果调用 select 办法，因为有一个 Channel 变成就绪状态则返回了 1 ；

若再次调用 select 办法，如果另一个 Channel 就绪了，它会再次返回1。

获取可操作的Channel
Set selectedKeys = selector.selectedKeys();

当有新增就绪的Channel，调用select()办法，就会将key增加到Set汇合中。

三、代码示例

后面铺垫了这么多，次要是想让大家可能看懂NIO代码示例，也不便后续大家来本人手写NIO 网络编程的程序。创立NIO服务端的次要步骤如下：

1. 关上ServerSocketChannel，监听客户端连贯2. 绑定监听端口，设置连贯为非阻塞模式3. 创立Reactor线程，创立多路复用器并启动线程4. 将ServerSocketChannel注册到Reactor线程中的Selector上，监听ACCEPT事件5. Selector轮询准备就绪的key6. Selector监听到新的客户端接入，解决新的接入申请，实现TCP三次握手，建设物理链路7. 设置客户端链路为非阻塞模式8. 将新接入的客户端连贯注册到Reactor线程的Selector上，监听读操作，读取客户端发送的网络音讯9. 异步读取客户端音讯到缓冲区10.对Buffer编解码，解决半包音讯，将解码胜利的音讯封装成Task11.将应答音讯编码为Buffer，调用SocketChannel的write将音讯异步发送给客户端

NIOServer.java ：

public class NIOServer {    private static Selector selector;    public static void main(String[] args) {        init();        listen();    }    private static void init() {        ServerSocketChannel serverSocketChannel = null;        try {            selector = Selector.open();            serverSocketChannel = ServerSocketChannel.open();            serverSocketChannel.configureBlocking(false);            serverSocketChannel.socket().bind(new InetSocketAddress(9000));            serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);            System.out.println("NioServer 启动实现");        } catch (IOException e) {            e.printStackTrace();        }    }    private static void listen() {        while (true) {            try {                selector.select();                Iterator<SelectionKey> keysIterator = selector.selectedKeys().iterator();                while (keysIterator.hasNext()) {                    SelectionKey key = keysIterator.next();                    keysIterator.remove();                    handleRequest(key);                }            } catch (Throwable t) {                t.printStackTrace();            }        }    }    private static void handleRequest(SelectionKey key) throws IOException {        SocketChannel channel = null;        try {            if (key.isAcceptable()) {                ServerSocketChannel serverSocketChannel = (ServerSocketChannel) key.channel();                channel = serverSocketChannel.accept();                channel.configureBlocking(false);                System.out.println("承受新的 Channel");                channel.register(selector, SelectionKey.OP_READ);            }            if (key.isReadable()) {                channel = (SocketChannel) key.channel();                ByteBuffer buffer = ByteBuffer.allocate(1024);                int count = channel.read(buffer);                if (count > 0) {                    System.out.println("服务端接管申请：" + new String(buffer.array(), 0, count));                    channel.register(selector, SelectionKey.OP_WRITE);                }            }            if (key.isWritable()) {                ByteBuffer buffer = ByteBuffer.allocate(1024);                buffer.put("收到".getBytes());                buffer.flip();                channel = (SocketChannel) key.channel();                channel.write(buffer);                channel.register(selector, SelectionKey.OP_READ);            }        } catch (Throwable t) {            t.printStackTrace();            if (channel != null) {                channel.close();            }        }    }}

NIOClient.java：

public class NIOClient {    public static void main(String[] args) {        new Worker().start();    }    static class Worker extends Thread {        @Override        public void run() {            SocketChannel channel = null;            Selector selector = null;            try {                channel = SocketChannel.open();                channel.configureBlocking(false);                selector = Selector.open();                channel.register(selector, SelectionKey.OP_CONNECT);                channel.connect(new InetSocketAddress(9000));                while (true) {                    selector.select();                    Iterator<SelectionKey> keysIterator = selector.selectedKeys().iterator();                    while (keysIterator.hasNext()) {                        SelectionKey key = keysIterator.next();                        keysIterator.remove();                        if (key.isConnectable()) {                            System.out.println();                            channel = (SocketChannel) key.channel();                            if (channel.isConnectionPending()) {                                channel.finishConnect();                                ByteBuffer buffer = ByteBuffer.allocate(1024);                                buffer.put("你好".getBytes());                                buffer.flip();                                channel.write(buffer);                            }                            channel.register(selector, SelectionKey.OP_READ);                        }                        if (key.isReadable()) {                            channel = (SocketChannel) key.channel();                            ByteBuffer buffer = ByteBuffer.allocate(1024);                            int len = channel.read(buffer);                            if (len > 0) {                                System.out.println("[" + Thread.currentThread().getName()                                        + "]收到响应：" + new String(buffer.array(), 0, len));                                Thread.sleep(5000);                                channel.register(selector, SelectionKey.OP_WRITE);                            }                        }                        if(key.isWritable()) {                            ByteBuffer buffer = ByteBuffer.allocate(1024);                            buffer.put("你好".getBytes());                            buffer.flip();                            channel = (SocketChannel) key.channel();                            channel.write(buffer);                            channel.register(selector, SelectionKey.OP_READ);                        }                    }                }            } catch (Exception e) {                e.printStackTrace();            } finally{                if(channel != null){                    try {                        channel.close();                    } catch (IOException e) {                        e.printStackTrace();                    }                }                if(selector != null){                    try {                        selector.close();                    } catch (IOException e) {                        e.printStackTrace();                    }                }            }        }    }}

打印后果：

// Server端NioServer 启动实现承受新的 Channel服务端接管申请：你好服务端接管申请：你好服务端接管申请：你好// Client端[Thread-0]收到响应：收到[Thread-0]收到响应：收到[Thread-0]收到响应：收到

四、总结

回顾一下应用 NIO 开发服务端程序的步骤：

  1. 创立 ServerSocketChannel 和业务解决线程池。
  2. 绑定监听端口，并配置为非阻塞模式。
  3. 创立 Selector，将之前创立的 ServerSocketChannel 注册到 Selector 上，监听 SelectionKey.OP_ACCEPT。
  4. 循环执行 Selector.select()` 办法，轮询就绪的 Channel。
  5. 轮询就绪的 Channel 时，如果是处于 OP_ACCEPT 状态，阐明是新的客户端接入，调用 ServerSocketChannel.accept 接管新的客户端。
  6. 设置新接入的 SocketChannel 为非阻塞模式，并注册到 Selector 上，监听 OP_READ。
  7. 如果轮询的 Channel 状态是 OP_READ，阐明有新的就绪数据包须要读取，则结构 ByteBuffer 对象，读取数据。

那从这些步骤中根本晓得开发者须要相熟的知识点有：

  1. jdk-nio提供的几个要害类：Selector , SocketChannel , ServerSocketChannel , FileChannel ,ByteBuffer ,SelectionKey
  2. 须要晓得网络常识：tcp粘包拆包 、网络闪断、包体溢出及反复发送等
  3. 须要晓得linux底层实现，如何正确的敞开channel，如何退出登记selector ，如何防止selector太过于频繁
  4. 须要晓得如何让client端取得server端的返回值,而后才返回给前端，须要如何期待或在怎么作熔断机制
  5. 须要晓得对象序列化，及序列化算法
  6. 省略等等，因为我曾经有点不难受了，作为程序员的我习惯了舒舒服服简略的API，不必太晓得底层细节，就能写出比拟强壮和没有Bug的代码...

NIO 原生 API 的弊病 :

① NIO 组件简单 : 应用原生 NIO 开发服务器端与客户端 , 须要波及到 服务器套接字通道 ( ServerSocketChannel ) , 套接字通道 ( SocketChannel ) , 选择器 ( Selector ) , 缓冲区 ( ByteBuffer ) 等组件 , 这些组件的原理 和API 都要相熟 , 能力进行 NIO 的开发与调试 , 之后还须要针对利用进行调试优化

② NIO 开发根底 : NIO 门槛略高 , 须要开发者把握多线程、网络编程等能力开发并且优化 NIO 网络通信的应用程序

③ 原生 API 开发网络通信模块的根本的传输解决 : 网络传输不光是实现服务器端和客户端的数据传输性能 , 还要解决各种异常情况 , 如 连贯断开重连机制 , 网络梗塞解决 , 异样解决 , 粘包解决 , 拆包解决 , 缓存机制 等方面的问题 , 这是所有成熟的网络应用程序都要具备的性能 , 否则只能说是入门级的 Demo

④ NIO BUG : NIO 自身存在一些 BUG , 如 Epoll , 导致 选择器 ( Selector ) 空轮询 , 在 JDK 1.7 中还没有解决

Netty 在 NIO 的根底上 , 封装了 Java 原生的 NIO API , 解决了上述哪些问题呢 ？

相比 Java NIO，应用 Netty 开发程序，都简化了哪些步骤呢？...等等这系列问题也都是咱们要问的问题。不过因为这篇只是介绍NIO相干常识，没有介绍Netty API的应用，所以介绍Netty API应用简略开发门槛低等长处有点站不住脚。那么就留到前面跟大家一起开启Netty学习之旅，探讨人人说好的Netty到底是不是江湖传言的那么好。

一起期待后续的Netty之旅吧！