本文共 10488 字，大约阅读时间需要 34 分钟。

转：https://blog.csdn.net/qq_18860653/article/details/53406723

Netty的使用或许我们看着官网user guide还是很容易入门的。因为java nio使用非常的繁琐，netty对java nio进行了大量的封装。对于Netty的理解，我们首先需要了解NIO的原理和使用。所以，我也特别渴望去了解NIO这种通信模式。

官方的定义是：nio 是non-blocking的简称，在jdk1.4 里提供的新api 。Sun 官方标榜的特性如下： 为所有的原始类型提供(Buffer)缓存支持。字符集编码解码解决方案。 Channel ：一个新的原始I/O 抽象。 支持锁和内存映射文件的文件访问接口。 提供多路(non-bloking) 非阻塞式的高伸缩性网络I/O 。是不是很抽象？

在阅读这篇技术文档之后，收获了很多。包括对Java NIO的理解和使用，所以也特别的感谢作者。

首先，还是来回顾以下从这篇文档中学到的要点。

为什么要使用 NIO?

NIO 的创建目的是为了让 Java 程序员可以实现高速 I/O 而无需编写自定义的本机代码。NIO 将最耗时的 I/O 操作(即填充和提取缓冲区)转移回操作系统，因而可以极大地提高速度。

NIO最重要的组成部分

通道 Channels

缓冲区 Buffers选择器 Selectors

Buffer 是一个对象， 它包含一些要写入或者刚读出的数据。

在 NIO 库中，所有数据都是用缓冲区处理的。在读取数据时，它是直接读到缓冲区中的。在写入数据时，它是写入到缓冲区中的。任何时候访问 NIO 中的数据，您都是将它放到缓冲区中。

缓冲区实质上是一个数组。通常它是一个字节数组，但是也可以使用其他种类的数组。但是一个缓冲区不 仅仅 是一个数组。缓冲区提供了对数据的结构化访问，而且还可以跟踪系统的读/写进程。

Channel是一个对象，可以通过它读取和写入数据

看完下面这个例子，基本上就理解buffer和channel的作用了

1. package yyf.java.nio.ibm;
3. import java.io.*;
4. import java.nio.*;
5. import java.nio.channels.*;
7. public

   class CopyFile {
8. static public void main(String args[]) throws Exception {
10. String infile =

    "c://test/nio_copy.txt";
11. String outfile =

    "c://test/result.txt";
13. FileInputStream fin =

    new FileInputStream(infile);
14. FileOutputStream fout =

    new FileOutputStream(outfile);
15. // 获取读的通道
16. FileChannel fcin = fin.getChannel();
17. // 获取写的通道
18. FileChannel fcout = fout.getChannel();
19. // 定义缓冲区，并指定大小
20. ByteBuffer buffer = ByteBuffer.allocate(

    1024);
22. while (

    true) {
23. // 清空缓冲区
24. buffer.clear();
25. //从通道读取一个数据到缓冲区
26. int r = fcin.read(buffer);
27. //判断是否有从通道读到数据
28. if (r == -

    1) {
29. break;
30. }
31. //将buffer指针指向头部
32. buffer.flip();
33. //把缓冲区数据写入通道
34. fcout.write(buffer);
35. }
36. }
37. }

缓冲区主要是三个变量

position

limitcapacity这三个变量一起可以跟踪缓冲区的状态和它所包含的数据。我们将在下面的小节中详细分析每一个变量，还要介绍它们如何适应典型的读/写(输入/输出)进程。在这个例子中，我们假定要将数据从一个输入通道拷贝到一个输出通道。Position您可以回想一下，缓冲区实际上就是美化了的数组。在从通道读取时，您将所读取的数据放到底层的数组中。 position 变量跟踪已经写了多少数据。更准确地说，它指定了下一个字节将放到数组的哪一个元素中。因此，如果您从通道中读三个字节到缓冲区中，那么缓冲区的 position 将会设置为3，指向数组中第四个元素。同样，在写入通道时，您是从缓冲区中获取数据。 position 值跟踪从缓冲区中获取了多少数据。更准确地说，它指定下一个字节来自数组的哪一个元素。因此如果从缓冲区写了5个字节到通道中，那么缓冲区的 position 将被设置为5，指向数组的第六个元素。Limitlimit 变量表明还有多少数据需要取出(在从缓冲区写入通道时)，或者还有多少空间可以放入数据(在从通道读入缓冲区时)。position 总是小于或者等于 limit。Capacity缓冲区的 capacity 表明可以储存在缓冲区中的最大数据容量。实际上，它指定了底层数组的大小 ― 或者至少是指定了准许我们使用的底层数组的容量。limit 决不能大于 capacity。

缓冲区作为一个数组，这三个变量就是其中数据的标记，也很好理解。

Selector（选择器）是Java NIO中能够检测一到多个NIO通道，并能够知晓通道是否为诸如读写事件做好准备的组件。这样，一个单独的线程可以管理多个channel，从而管理多个网络连接。

接下来来看看具体的使用把，我创建了一个直接收消息的服务器（一边接收一边写数据可能对于新手不好理解）

服务端：

1. package yyf.java.nio.test;
3. import java.net.InetSocketAddress;
4. import java.net.ServerSocket;
5. import java.nio.ByteBuffer;
6. import java.nio.channels.SelectionKey;
7. import java.nio.channels.Selector;
8. import java.nio.channels.ServerSocketChannel;
9. import java.nio.channels.SocketChannel;
10. import java.util.Iterator;
11. import java.util.Set;
13. public

    class NioReceiver {
14. @SuppressWarnings(

    "null")
15. public static void main(String[] args) throws Exception {
16. ByteBuffer echoBuffer = ByteBuffer.allocate(

    8);
17. ServerSocketChannel ssc = ServerSocketChannel.open();
18. Selector selector = Selector.open();
19. ssc.configureBlocking(

    false);
20. ServerSocket ss = ssc.socket();
21. InetSocketAddress address =

    new InetSocketAddress(

    8080);
22. ss.bind(address);
23. SelectionKey key = ssc.register(selector, SelectionKey.OP_ACCEPT);
24. System.out.println(

    "开始监听……");
25. while (

    true) {
26. int num = selector.select();
27. Set selectedKeys = selector.selectedKeys();
28. Iterator it = selectedKeys.iterator();
29. while (it.hasNext()) {
30. SelectionKey sKey = (SelectionKey) it.next();
31. SocketChannel channel =

    null;
32. if (sKey.isAcceptable()) {
33. ServerSocketChannel sc = (ServerSocketChannel) key.channel();
34. channel = sc.accept();

    // 接受连接请求
35. channel.configureBlocking(

    false);
36. channel.register(selector, SelectionKey.OP_READ);
37. it.remove();
38. }

    else

    if (sKey.isReadable()) {
39. channel = (SocketChannel) sKey.channel();
40. while (

    true) {
41. echoBuffer.clear();
42. int r = channel.read(echoBuffer);
43. if (r <=

    0) {
44. channel.close();
45. System.out.println(

    "接收完毕，断开连接");
46. break;
47. }
48. System.out.println(

    "##" + r +

    " " +

    new String(echoBuffer.array(),

    0, echoBuffer.position()));
49. echoBuffer.flip();
50. }
51. it.remove();
52. }

    else {
53. channel.close();
54. }
55. }
56. }
58. }
60. }

客户端（NIO）：

1. package yyf.java.nio.test;
3. import java.net.InetSocketAddress;
4. import java.nio.ByteBuffer;
5. import java.nio.channels.SelectionKey;
6. import java.nio.channels.Selector;
7. import java.nio.channels.SocketChannel;
8. import java.util.Iterator;
9. import java.util.Set;
11. public

    class NioTest {
12. public static void main(String[] args) throws Exception {
13. ByteBuffer echoBuffer = ByteBuffer.allocate(

    1024);
14. SocketChannel channel =

    null;
15. Selector selector =

    null;
16. channel = SocketChannel.open();
17. channel.configureBlocking(

    false);
18. // 请求连接
19. channel.connect(

    new InetSocketAddress(

    "localhost",

    8080));
20. selector = Selector.open();
21. channel.register(selector, SelectionKey.OP_CONNECT);
22. int num = selector.select();
23. Set selectedKeys = selector.selectedKeys();
24. Iterator it = selectedKeys.iterator();
25. while (it.hasNext()) {
26. SelectionKey key = (SelectionKey) it.next();
27. it.remove();
28. if (key.isConnectable()) {
29. if (channel.isConnectionPending()) {
30. if (channel.finishConnect()) {
31. // 只有当连接成功后才能注册OP_READ事件
32. key.interestOps(SelectionKey.OP_READ);
33. echoBuffer.put(

    "123456789abcdefghijklmnopq".getBytes());
34. echoBuffer.flip();
35. System.out.println(

    "##" +

    new String(echoBuffer.array()));
36. channel.write(echoBuffer);
37. System.out.println(

    "写入完毕");
38. }

    else {
39. key.cancel();
40. }
41. }
42. }
43. }
45. }
46. }

运行结果：

1. 开始监听……
2. ##

   8

   12345678
3. ##

   8

   9abcdefg
4. ##

   8 hijklmno
5. ##

   2 pq
6. 接收完毕，断开连接

当然，BIO的客户端也可以，开启10个BIO客户端线程

1. package yyf.java.nio.test;
3. import java.io.ByteArrayOutputStream;
4. import java.io.IOException;
5. import java.io.InputStream;
6. import java.io.OutputStream;
7. import java.net.InetAddress;
8. import java.net.InetSocketAddress;
9. import java.net.Socket;
10. import java.net.UnknownHostException;
11. import java.util.Random;
13. import yyf.java.test.Main;
15. public

    class BioClientTest {
16. public static void main(String[] args) throws Exception {
17. BioClient n =

    new BioClient();
18. for (

    int i =

    0; i <

    10; i++) {
19. Thread t1 =

    new Thread(n);
20. t1.start();
21. }
22. }
23. }
25. class BioClient implements Runnable {
26. @Override
27. public void run() {
29. try {
30. Socket socket =

    new Socket(

    "127.0.0.1",

    8080);
31. OutputStream os = socket.getOutputStream();
32. InputStream is = socket.getInputStream();
33. ByteArrayOutputStream bos =

    new ByteArrayOutputStream();
34. String str = Thread.currentThread().getName() +

    "...........sadsadasJava";
35. os.write(str.getBytes());
36. StringBuffer sb =

    new StringBuffer();
37. byte[] b =

    new

    byte[

    1024];
38. int len;
39. while ((len = is.read(b)) != -

    1) {
40. bos.write(b,

    0, len);
41. }
42. is.close();
43. os.close();
44. socket.close();
45. System.out.println(Thread.currentThread().getName() +

    " 写入完毕 " +

    new String(bos.toByteArray()));
46. }

    catch (Exception e) {
47. e.printStackTrace();
48. }
49. }
51. }

运行结果：

1. ##

   8 Thread-

   4
2. ##

   8 ........
3. ##

   8 ...sadsa
4. ##

   7 dasJava
5. 接收完毕，断开连接
6. ##

   8 Thread-

   3
7. ##

   8 ........
8. ##

   8 ...sadsa
9. ##

   7 dasJava
10. 接收完毕，断开连接
11. ##

    8 Thread-

    9
12. ##

    8 ........
13. ##

    8 ...sadsa
14. ##

    7 dasJava
15. 接收完毕，断开连接
16. ##

    8 Thread-

    7
17. ##

    8 ........
18. ##

    8 ...sadsa
19. ##

    7 dasJava
20. 接收完毕，断开连接
21. ##

    8 Thread-

    0
22. ##

    8 ........
23. ##

    8 ...sadsa
24. ##

    7 dasJava
25. 接收完毕，断开连接
26. ##

    8 Thread-

    5
27. ##

    8 ........
28. ##

    8 ...sadsa
29. ##

    7 dasJava
30. 接收完毕，断开连接
31. ##

    8 Thread-

    2
32. ##

    8 ........
33. ##

    8 ...sadsa
34. ##

    7 dasJava
35. 接收完毕，断开连接
36. ##

    8 Thread-

    8
37. ##

    8 ........
38. ##

    8 ...sadsa
39. ##

    7 dasJava
40. 接收完毕，断开连接
41. ##

    8 Thread-

    1
42. ##

    8 ........
43. ##

    8 ...sadsa
44. ##

    7 dasJava
45. 接收完毕，断开连接
46. ##

    8 Thread-

    6
47. ##

    8 ........
48. ##

    8 ...sadsa
49. ##

    7 dasJava
50. 接收完毕，断开连接

当然，这只是一个测试，对于一个服务器，是有读取，也有写出的，这是文档给的一个服务端例子

1. package yyf.java.nio.ibm;
3. import java.io.*;
4. import java.net.*;
5. import java.nio.*;
6. import java.nio.channels.*;
7. import java.util.*;
9. public

   class MultiPortEcho {
10. private

    int ports[];
11. private ByteBuffer echoBuffer = ByteBuffer.allocate(

    5);
13. public MultiPortEcho(int ports[]) throws IOException {
14. this.ports = ports;
15. go();
16. }
18. private void go() throws IOException {
19. Selector selector = Selector.open();
20. for (

    int i =

    0; i < ports.length; ++i) {
21. ServerSocketChannel ssc = ServerSocketChannel.open();
22. ssc.configureBlocking(

    false);
23. ServerSocket ss = ssc.socket();
24. InetSocketAddress address =

    new InetSocketAddress(ports[i]);
25. ss.bind(address);
26. SelectionKey key = ssc.register(selector, SelectionKey.OP_ACCEPT);
27. System.out.println(

    "Going to listen on " + ports[i]);
28. }
30. while (

    true) {
31. int num = selector.select();
32. Set selectedKeys = selector.selectedKeys();
33. Iterator it = selectedKeys.iterator();
34. while (it.hasNext()) {
35. SelectionKey key = (SelectionKey) it.next();
36. if ((key.readyOps() & SelectionKey.OP_ACCEPT) == SelectionKey.OP_ACCEPT) {
37. ServerSocketChannel ssc = (ServerSocketChannel) key.channel();
38. SocketChannel sc = ssc.accept();
39. sc.configureBlocking(

    false);
40. SelectionKey newKey = sc.register(selector, SelectionKey.OP_READ);
41. it.remove();
42. System.out.println(

    "Got connection from " + sc);
43. }

    else

    if ((key.readyOps() & SelectionKey.OP_READ) == SelectionKey.OP_READ) {
44. SocketChannel sc = (SocketChannel) key.channel();
45. int bytesEchoed =

    0;
46. while (

    true) {
47. echoBuffer.clear();
48. int r = sc.read(echoBuffer);
49. if (r <=

    0) {
50. sc.close();
51. break;
52. }
53. echoBuffer.flip();
54. sc.write(echoBuffer);
55. bytesEchoed += r;
56. }
57. System.out.println(

    "Echoed " + bytesEchoed +

    " from " + sc);
58. it.remove();
59. }
61. }
62. // System.out.println( "going to clear" );
63. // selectedKeys.clear();
64. // System.out.println( "cleared" );
65. }
66. }
68. static public void main(String args[]) throws Exception {
69. int ports[] =

    new

    int[] {

    8080 };
70. for (

    int i =

    0; i < args.length; ++i) {
71. ports[i] = Integer.parseInt(args[i]);
72. }
73. new MultiPortEcho(ports);
74. }
75. }

现在，我们就写个客户端去跟服务器通信，把发过去的返回来：

1. package yyf.java.nio;
3. import java.io.IOException;
4. import java.net.InetSocketAddress;
5. import java.net.SocketAddress;
6. import java.nio.ByteBuffer;
7. import java.nio.channels.SocketChannel;
9. import javax.swing.ButtonGroup;
11. public

    class NioClient {
12. public static void main(String[] args) throws IOException {
13. SocketChannel socketChannel = SocketChannel.open();
14. SocketAddress socketAddress =

    new InetSocketAddress(

    "127.0.0.1",

    8080);
15. socketChannel.connect(socketAddress);
16. String str =

    "你好a";
17. ByteBuffer buffer = ByteBuffer.wrap(str.getBytes());
18. socketChannel.write(buffer);
19. socketChannel.socket().shutdownOutput();
21. buffer.clear();
22. byte[] bytes;
23. int count =

    0;
24. while ((count = socketChannel.read(buffer)) >

    0) {
25. buffer.flip();
26. bytes =

    new

    byte[count];
27. buffer.get(bytes);
28. System.out.println(

    new String(buffer.array()));
29. buffer.clear();
30. }
31. socketChannel.socket().shutdownInput();
32. socketChannel.socket().close();
33. socketChannel.close();
34. }
35. }

运行结果

server：

1. Going to listen on

   8080
2. Got connection from java.nio.channels.SocketChannel[connected local=/

   127.0.0.1:

   8080 remote=/

   127.0.0.1:

   63584]
3. Echoed

   7 from java.nio.channels.SocketChannel[closed]

client：

你好a

对于NIO的入门就先到这里。