第一章 BIO、NIO、AIO课程介绍

1.1 课程说明

  在java的软件设计开发中，通信架构是不可避免的，我们在进行不同系统或者不同进程之间的数据交互，或者在高并发下的通信场景下都需要用到网络通信相关的技术，对于一些经验丰富的程序员来说，Java早期的网络通 信架构存在一些缺陷，其中最令人恼火的是基于性能低下的同步阻塞式的I/O通信（BIO)，随着互联网开发下通 信性能的高要求，Java在2002年开始支持了非阴塞式的I/O通信技术（NIO)。
  大多数读者在学习网络通信相关技术的 时候，都只是接触到零碎的通信技术点，没有完整的技术体系架构，以至于对Java的通信场景总是没有清晰的解决方案。本次课程将通过大量清晰直接的案例从最基础的BlO式通信开始介绍到NIO、AIO，读者可以清晰的了解到阻塞、同步、异步的现象、概念和特征以及优缺点。本课程结合了大量的案例让读者可以快速了解每种通信架构的使用。

1.2 本课程学习要求

• 本课程不太适合完全0基础学员
• 至少需要掌握：java SE基础编程，如java多线程，java IO流编程，java网络基础知识（如：IP，端口，协议），常用的Java设计模式要有一定的了解。
• 能熟练掌握Java OOP编程，有一定的编程思维。

1.3 通信技术整体解决的问题

• 局域网内的通信要求
• 多系统间的底层消息传递机制
• 高并发下，大数据量的通信场景需要，如netty
• 游戏行业，无论是手游服务端，还是大型的网络游戏，java语言都得到越来越广泛的应用

第二章 Java的I/O演进之路

2.1 I/O模型基本说明

I/O模型：就是用什么样的通道或者说是通信模式和架构进行数据的传输和接收，很大程度上决定了程序通信的性能 , Java共支持3种网络编程的I/O模型：BlO. NIO. AlO
实际通信需求下，要根据不同的业务场景和性能需求决定选择不同的I/O模型

2.2 I/O模型

Java BIO
同步并阻塞（传统阻塞型），服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销【简单示意图 】

java NIO
Java NIO：同步非阻塞，服务器实现模式为一个线程处理多个请求（连接），即客户端发送的连接请求都会注册到多路复用器上，多路复用器轮询到连接有I/O请求就进行处理【简单示意图】

java AIO
java AIO(NIO.2)：异步异步非阻塞，服务器实现模式为一个有效请求一个线程，客户端的I/O请求都是由OS先完 成了再通知服务器应用去启动线程进行处理，一般适用于连接数较多且连接时间较长的应用

2.3 BIO、NIO、AIO适用场景分析

1、 BIO方式适用于连接数目比小且固定的架构，这种方式对服务器资源要求比较高，并发局限于应用
中， jDK1.4以前的唯一选择，但程序简单易理解。
2、 NIO方式适用于连接数目多且连接比较短（轻操作）的架构，比如聊天服务器，弹幕系统，服务器
间通讯等。 编程比较复杂，jDK1 .4开始支持。
3、 AIO方式使用于连接数目多且连接比较长（重操作）的架构，比如相册服务器，充分调用OS参与并
发操作， 编程比较复杂，JDK7开始支持。

第三章 JAVA BIO深入剖析

3.1 Java BIO基本介绍

• Java BlO就是传统的Java IO编程，其相关的类和接口在Java.io 包中
• BIO(blocking I/O)同步阻塞，服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销，可以通过线程池机制改善（实现多个客户连接服务器）.

3.2 java BIO工作机制

#3.3 传统的BIO编程实例回顾

  网络编程的基本模型是Client/Server模型，也就是两个进程之间进行相互通信，其中服务端提供位置信息（绑定IP地址和端口），客户端通过连接操作向服务端监听的端口地址发起连接请求，基于TCP协议下进行三次握手连接，连接成功后，双方通过网络套接字（Socket）进行通信。
  传统的同步阻塞模型开发中，服务端ServerSocket负责绑定IP地址，启动监听端口；客户端Socket负责发起连接操作。连接成功后，双方通过输入和输出流进行同步阻塞式通信。
  基于BIO模式下的通信，客户端-服务端是完全同步，完全藕合的。
服务端案例如下:

/**
 * 目标：客户端发送消息，服务端接收消息
 */
public class Server {
	public static void main(String[] args) {
		try {
			System.out.println("===服务端启动===");
			//1.定义一个ServerSocket对象进行服务端的端口注册
			ServerSocket ss = new ServerSocket(9999);
			//2. 监听客户端的Socket连接请求
			Socket socket = ss.accept();
			//3.从socket管道中得到一个字节输入流对象
			InputStream is = socket.getInputStream();
			//4.把字节输入流包装成一个缓存字符输入流
			BufferedReader br = new BufferedReader(new InputStreamReader(is));
			String msg;
			/*while ((msg = br.readLine()) != null){
				System.out.println("服务端接收到：" + msg);
			}*/
			if ((msg = br.readLine()) != null){
				System.out.println("服务端接收到：" + msg);
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

客户端案例如下：

/**
* 客户端
*/
public class Client {
	public static void main(String[] args) {
		try {
			//1.创建Socket对象请求服务端的连接
			Socket socket = new Socket("127.0.0.1",9999);
			//2.从Socket对象中获取一个字节输出流
			OutputStream os = socket.getOutputStream();
			//3.把字节输出流包装成一个打印流
			PrintStream ps = new PrintStream(os);
			//ps.print("hello World! 服务端，你好");
			ps.println("hello World! 服务端，你好");
			ps.flush();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

输出:

===服务端启动===
服务端接收到：hello World! 服务端，你好

小结

• 在以上通信中，服务端会一直等待客户端的消息，如果客户端没有进行消息的发送，服务端将一直进入阻塞状态
• 同时服务端是按照行获取消息的，这意味着客户端也必须按照行进行消息的发送，否则服务端将进入等待消息的阻塞状态！

3.4 BIO模式下多发和多收消息

在上面的案例中，只能实现客户端发送消息，服务端接收消息，并不能实现反复的收消息和反复的发消息，我们只需要在客户端案例中，加上反复按照行发送消息的逻辑即可！ 案例代码如下：
服务端代码如下

/**
* 目标：服务端可以反复的接收消息，客户端可以反复的发送消息
*/
public class Server {
	public static void main(String[] args) {
		try {
			System.out.println("===服务端启动===");
			//1.定义一个ServerSocket对象进行服务端的端口注册
			ServerSocket ss = new ServerSocket(9999);
			//2. 监听客户端的Socket连接请求
			Socket socket = ss.accept();
			//3.从socket管道中得到一个字节输入流对象
			InputStream is = socket.getInputStream();
			//4.把字节输入流包装成一个缓存字符输入流
			BufferedReader br = new BufferedReader(new InputStreamReader(is));
			String msg;
			while ((msg = br.readLine()) != null){
				System.out.println("服务端接收到：" + msg);
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

客户端代码如下

/**
* 客户端
*/
public class Client {
	public static void main(String[] args) {
		try {
			//1.创建Socket对象请求服务端的连接
			Socket socket = new Socket("127.0.0.1",9999);
			//2.从Socket对象中获取一个字节输出流
			OutputStream os = socket.getOutputStream();
			//3.把字节输出流包装成一个打印流
			PrintStream ps = new PrintStream(os);
			Scanner sc = new Scanner(System.in);
			while (true){
				System.out.print("请说：");
				String msg = sc.nextLine();
				ps.println(msg);
				ps.flush();
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

输入输出：

客户端：
请说：hello
请说：what are you doing?
请说：
服务端：
===服务端启动===
服务端接收到：hello
服务端接收到：what are you doing?

3.5 BIO模式下接收多个客户端

概述
在上述的案例中，一个服务端只能接收一个客户端的通信请求，那么如果服务端需要处理很多个客户端的消息通信请求应该如何处理呢，此时我们就需要在服务端引入线程了，也就是说客户端每发起一个请求，服务端就创建一个新的线程来处理这个客户端的请求，这样就实现了一个客户端一个线程的模型，图解模式如下：

客户端案例代码

/**
* 客户端
*/
public class Client {
	public static void main(String[] args) {
		try {
			//1.请求与服务端的Socket对象连接
			Socket socket = new Socket("127.0.0.1",9999);
			//2. 得到一个打印流
			PrintStream ps = new PrintStream(socket.getOutputStream());
			//3. 使用循环不断的发送消息给服务端接收
			Scanner sc = new Scanner(System.in);
			while (true){
				System.out.println("请说：");
				String msg =sc.nextLine();
				ps.println(msg);
				ps.flush();
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

服务端案例代码

/**
* 目标：服务端可以实现同时接收多个客户端的Socket通信需求
* 思路：服务端没接收到一个客户端socket请求对象之后都交给一个独立的线程来处理客户端的数据交互需求
*/
public class Server {
	public static void main(String[] args) {
		try {
			//1.注册端口
			ServerSocket ss = new ServerSocket(9999);
			//2.定义一个死循环，负责不断的接收客户端的Socket的连接请求
			while(true){
				Socket socket = ss.accept();
				//3.创建一个独立的线程来处理与这个客户端的socket通信需求
				new ServerThreadReader(socket).start();
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

线程类

public class ServerThreadReader extends Thread {
	private Socket socket;
	public ServerThreadReader(Socket socket){
		this.socket = socket;
	}
	@Override
	public void run() {
		try {
			//从socket对象中得到一个字节输入流
			InputStream is = socket.getInputStream();
			//使用缓存字符输入流包装字节输入流
			BufferedReader br = new BufferedReader(new InputStreamReader(is));
			String msg;
			while ((msg = br.readLine()) != null){
				System.out.println(msg);
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

输入输出

===client1:
请说：
ppp
请说：
你在干嘛？
请说：
我是第一个client
请说：
===client2:
请说：
lll
请说：
还钱！！！
请说：
我是第二个client
请说：
===client3:
请说：
我是第三个client
请说：
===server:
lll
ppp
你在干嘛？
还钱！！！
我是第二个client
我是第一个client
我是第三个client

小结

• 每个Socket接收到，都会创建一个线程，线程的竞争、切换上下文影响性能； ・
• 每个线程都会占用栈空间和CPU资源；
• 并不是每个socket都进行lO操作，无意义的线程处理；
• 客户端的并发访问增加时。服务端将呈现1:1的线程开销，访问量越大，系统将发生线程栈溢出，
• 线程创建失败，最终导致进程宕机或者僵死，从而不能对外提供服务。

3.6 伪异步I/O编程

概述
  在上述案例中：客户端的并发访问增加时。服务端将呈现1:1的线程开销，访问量越大，系统将发生线程栈溢出，线程创建失败，最终导致进程宕机或者僵死，从而不能对外提供服务。接下来我们采用一个伪异步I/O的通信框架，采用线程池和任务队列实现，当客户端接入时，将客户端的Socket封装成一个Task(该任务实现Java. lang. Runnable(线程任务接口）交给后端的线程池中进行处理。JDK的线程池维护一个消息队列和N个活跃的线程，对消息队列中Socket任务进行处理，由于线程池可以设置消息队列的大小和最大线程数，因此，它的资源占用是可控的，无论多少个客户端并发访问，都不会导致资源的耗尽和宕(dang)机。
如下图所示：

线程池处理类

public class HandlerSocketServerPool {
	//1. 创建一个线程池的成员变量用于存储一个线程池对象
	private ExecutorService executorService;
	/**
	* 2.创建这个类的的对象的时候就需要初始化线程池对象
	* public ThreadPoolExecutor(int corePoolSize,
	* int maximumPoolSize,
	* * long keepAliveTime,
	* TimeUnit unit,
	* BlockingQueue<Runnable> workQueue)
	*/
	public HandlerSocketServerPool(int maxThreadNum, int queueSize){
		executorService = new ThreadPoolExecutor(3,maxThreadNum,120,
		TimeUnit.SECONDS,new ArrayBlockingQueue<Runnable>(queueSize));
	}
	/**
	* 3.提供一个方法来提交任务给线程池的任务队列来暂存，等待线程池来处理
	*/
	public void execute(Runnable target){
		executorService.execute(target);
	}
}

Socket任务类

public class ServerRunnableTarget implements Runnable {
	private Socket socket;
	public ServerRunnableTarget(Socket socket){
	this.socket = socket;
	}
	@Override
	public void run() {
		//处理接收到的客户端socket通信需求
		try {
			//1.从socket管道中得到一个字节输入流对象
			InputStream is = socket.getInputStream();
			//2.把字节输入流包装成一个缓存字符输入流
			BufferedReader br = new BufferedReader(new InputStreamReader(is));
			String msg;
			while((msg = br.readLine()) != null){
				System.out.println("服务端收到：" + msg);
			}
		}catch (Exception e){
			e.printStackTrace();
		}
	}
}

服务端源码分析

/**
* 目标：开发实现伪异步通讯架构
* 思路：服务端没接收到一个客户端socket请求对象之后都交给一个独立的线程来处理客户端的数据交互需
求
*/
public class Server {
	public static void main(String[] args) {
		try {
			//1.注册端口
			ServerSocket ss = new ServerSocket(9999);
			//2.定义一个死循环，负责不断的接收客户端的Socket的连接请求
			//初始化一个线程池对象
			HandlerSocketServerPool pool = new HandlerSocketServerPool(3,10);
			while(true){
				Socket socket = ss.accept();
				//3.把socket对象交给一个线程池进行处理
				//把socket封装成一个任务对象交给线程池处理
				Runnable target = new ServerRunnableTarget(socket);
				pool.execute(target);
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

输出：

服务端收到：client1
服务端收到：client2
服务端收到：client3
服务端收到：client4
服务端收到：client5

小结

• 伪异步旧采用了线程池实现，因此避免了为每个请求创建一个独立线程造成线程资源耗尽的问题，但由于底层依然是采用的同步阻塞模型，因此无法从根采上解决问题。
• 如果单个消息处理的缓慢，或者服务器线程池中的全部线程都被阻塞，那么后续socket的I/O消息都将在队列中排队。新的Socket请求将被拒绝，客户端会发生大量连接超时。

3.7 基于BIO形式下的文件上传

客户端开发

/**
* 目标：实现客户端上传任意类型的文件数据给服务端保存起来
*/
public class Client {
	public static void main(String[] args) {
			try(InputStream is = new FileInputStream("C:\\Users\\Lenovo\\Desktop\\1.jpg");){
			//1.请求与服务端的Socket连接
			Socket socket = new Socket("127.0.0.1", 8888);
			//2.把字节输出流包装成一个数据输出流(DataOutputStream可以做分段数据发送)
			DataOutputStream dos = new
			DataOutputStream(socket.getOutputStream());
			//3.先发送上传文件的后缀给服务器
			dos.writeUTF(".jpg");
			//4.把文件数据发送给服务端进行接收
			//InputStream is = new
			FileInputStream("C:\\Users\\Lenovo\\Desktop\\1.jpg");
			byte[] buffer = new byte[1024];
			int len;
			while ((len = is.read(buffer)) > 0){
				dos.write(buffer,0,len);
			}
			dos.flush();
			socket.shutdownOutput();//通知服务端，我客户端这边的数据已经发送完毕了
		}catch (Exception e){
			e.printStackTrace();
		}
	}
}

服务端开发

/**
* 目标：服务端开发，可以实现接收客户端的任意类型文件，并保存到服务器端磁盘
*/
public class Server {
	public static void main(String[] args) {
		try {
			ServerSocket ss = new ServerSocket(8888);
			while(true){
			Socket socket = ss.accept();
				//交给一个独立的线程来处理与这个客户端的文件通信需求
				new ServerReadThread(socket).start();
			}
		}catch (Exception e){
			e.printStackTrace();
		}
	}
}

Socket线程处理类

public class ServerReadThread extends Thread {
	private Socket socket;
	public ServerReadThread(Socket socket){
		this.socket = socket;
	}
	@Override
	public void run() {
		try {
			//1.得到一个数据输入流来读取客户端发送过来的数据
			DataInputStream dis = new DataInputStream(socket.getInputStream());
			//2.读取客户端发送过来的文件类型
			String suffix = dis.readUTF();
			System.out.println("服务端已经成功接收到了文件类型：" + suffix);
			//3.定义一个字节输出管道，负责把客户端发来的文件数据写出去
			OutputStream os = new
			FileOutputStream("C:\\Users\\Lenovo\\Desktop\\server\\" + UUID.randomUUID().toString() + suffix);
			//4.从数据输入流中读取文件数据，写出到字节输出流中去
			byte[] buffer = new byte[1024];
			int len;
			while ((len = dis.read(buffer)) > 0){
				os.write(buffer,0,len);
			}
			os.close();
			System.out.println("服务端接收文件保存成功！");
		}catch (Exception e){
			e.printStackTrace();
		}
	}
}

输出

服务端已经成功接收到了文件类型：.jpg
服务端接收文件保存成功！

小结

• 同步阻塞模式下（BIO)，客户端怎么发，服务端就必须对应的怎么收。如客户端用的是DataOutputStream，那么服务端就该用DataInputStream，客户端dos.writeUTF(“.jpg”);服务端就该String suffix = dis.readUTF();
• 客户端发完数据后必须通知服务端自己已经发完socket.shutdownOutput()，否则服务端会一直等待。

3.8 Java BIO模式下的端口转发思想

需求：需要实现一个客户端的消息可以发送给所有的客户端去接收。
客户端开发

public class Client {
	public static void main(String[] args){
		try {
			//1.请求与服务端的Socket对象连接
			Socket socket = new Socket("127.0.0.1", 9999);
			//收消息
			Thread clientThread = new ClientReaderThread(socket);
			clientThread.start();
			while (true){
				//发消息
				OutputStream os = socket.getOutputStream();
				PrintStream ps = new PrintStream(os);
				//3. 使用循环不断的发送消息给服务端接收
				Scanner sc = new Scanner(System.in);
				//System.out.print("client send message：");
				String msg =sc.nextLine();
				ps.println(msg);
				ps.flush();
			}
		}catch (Exception e){
			e.printStackTrace();
		}
	}
}

客户端线程处理类

public class ClientReaderThread extends Thread {
	private Socket socket;
	public ClientReaderThread(Socket socket) {
		this.socket = socket;
	}
	@Override
	public void run() {
		try{
			while (true){
				InputStream is = socket.getInputStream();
				//4.把字节输入流包装成一个缓存字符输入流
				BufferedReader br = new BufferedReader(new
				InputStreamReader(is));
				String msg;
				if((msg = br.readLine()) != null){
					System.out.println(msg);
				}
			}
		}catch (Exception e){
			e.printStackTrace();
		}
	}
}

服务端开发

/**
* 目标：BIO模式下的端口转发思想-服务端实现
* 服务端实现需求：
* 1.注册端口
* 2.接收客户端的socket连接，交给一个独立的线程来处理
* 3.把当前连接的客户端socket存入到一个所谓的在线socket集合中保存
* 4.接收客户端的消息，然后推动给当前所有的在线socket接收
*/
public class Server {
	//定义一个静态集合
	public static List<Socket> allSocketOnLine = new ArrayList<>();
	public static void main(String[] args) {
		try {
			ServerSocket ss = new ServerSocket(9999);
			while (true){
				Socket socket = ss.accept();
				//把登录的客户端socket存入到一个在线集合中去
				allSocketOnLine.add(socket);
				//为当前登录成功的socket分配一个独立的线程来处理与之通信
				new ServerReaderThread(socket).start();
			}
		}catch (Exception e){
			e.printStackTrace();
		}
	}
}

服务端线程处理类

public class ServerReaderThread extends Thread{
	private Socket socket;
	public ServerReaderThread(Socket socket) {
	this.socket = socket;
	}
	@Override
	public void run() {
		try {
			//1.从socket中去获取当前客户端的输入流
			BufferedReader br = new BufferedReader(new
			InputStreamReader(socket.getInputStream()));
			String msg;
			while ((msg = br.readLine()) != null){
				System.out.println("服务器收到消息：" + msg);
				//2.服务端接收到了客户端的消息后，需要推送给所有的当前在线的socket
				sendMsgToAllClient(msg,socket);
			}
		}catch (Exception e){
			e.printStackTrace();
			System.out.println("当前有人下线了！");
			//从在线socket集合中移除本socket
			Server.allSocketOnLine.remove(socket);
		}
	}
	/**
	* 把当前客户端发送来的消息推送给全部在线的socket
	* @param msg
	*/
	private void sendMsgToAllClient(String msg,Socket socket) throws Exception {
		for(Socket sk : Server.allSocketOnLine){
			//只发送给除自己以外的其他客户端
			if(socket != sk){
				PrintStream ps = new PrintStream(sk.getOutputStream());
				ps.println(msg);
				ps.flush();
			}
		}
	}
}

第四章 JAVA NIO深入剖析

在讲解利用NIO实现通信架构之前，我们需要先来了解一下NIO的基本特点和使用

4.1 java NIO基本介绍

• java NlO (New lO）也有人称之为java non-blocking IO是Java 1.4版本开始引入的一个新的IOAPI，可以替代标准的ava lO API。 NIO与原来的IO有同样的作用和目的，但是使用的方式完全不同，NIO支持面向缓冲区的、基于通道的IO操作。NIO将以更加高效的方式进行文件的读写操作。NIO可以理解为非阻塞IO，传统的IO 的read和write只能阻塞执行，线程在读写期间不能干其他事情，比如调用socket. read(）时，如果服务器一 直没有数据传输过来，线程就一直阻塞，而NIO中可以配置socket为非阻塞模式。
• NIO相关类都被放在java.nio包及子包下，并且对原Java.io包中的很多类进行改写。
• NIO有三大核心部分：Channel（通道）,Buffer(缓冲区）,Selector（选择器）
• Java NIO的非阻塞模式，使一个线程从某通道发送请求或者读取数据，但是它仅能得到目前可用的数据；如果目前没有数据可用时，就什么都不会获取，而不是保持线程阻塞，所以直至数据变的可以读取之前，该线程可以继续做其他的事情。非阻塞写也是如此，一个线程请求写入一些数据到某通道，但不需要等待它完全写入，这个线程同时可以去做别的事情。
• 通俗理解：NIO是可以做到用一个线程来处理多个操作的。假设有1000个请求过来，根据实际情况，可以分配20或者80个线程来处理。不像之前的阻塞IO那样，非得分配1000个。

4.2 NIO和BIO的比较

• BlO以流的方式处理数据，而NIO以块的方式处理数据，块I/O的效率比流I/O高很多
• BlO是阻塞的，NIO则是非阴塞的
• BlO基于字节流和字符流进行操作，而NIO基于Channel(通道）和Buffer(缓冲区）进行操作，数据总是从通道读取到缓冲区中，或者从缓冲区写入到通道中。Selector(选择器）用于监听多个通道的事件（比如：连接请求，数据到达等），因此使用单个线程就可以监听多个客户端通道
  

4.3 NIO三大核心原理示意图

NIO有三大核心部分：Channel(通道)，Buufer(缓存区)，Selector(选择器)
Buffer缓存区
缓冲区本质上是一块可以写入数据，然后可以从中读取数据的内存。这块内存被包装成NIO Buffer对象，并提供了 一组方法，用来方便的访问该块内存。相比较直接对数组的操作，Buffer API更加容易操作和管理。
Channel通道
Java NIO的通道类似流，但又有些不同：既可以从通道中读取数据，又可以写数据到通道。但流的(input或 output)读写通常是单向的。通道可以非阻塞读取和写入通道，通道可以支持读取或写入缓冲区，也支持异步地读写。
Selector选择器
Selector是一个Java NIO组件，可以能够检查一个或多个NIO通道，并确定哪些通道已经准备好进行读取或写 入。这样，一个单独的线程可以管理多个channel，从而管理多个网络连接，提高效率。

• 每个channel都会对应一个Buffer
• 一个线程对应Selector，一个Selector对应多个channel（连接）
• 程序切换到哪个channel是由事件决定的
• Selector会根据不同的事件，在各个通道上切换
• Buffer就是一个内存块，底层是一个数组
• 数据的读取写入是通过Buffer完成的，BIO中要么是输入流，或者是输出流，不能双向，但是NIO的Buffer是可以读也可以写。
• Java NIO系统的核心在于：通道（Channel）和缓存区（Buffer)。通道表示打开到IO设备（例如：文件、套接字） 的连接。若需要使用NlO系统，需要获取用于连接IO设备的通道以及用于容纳数据的缓冲区。然后操作缓 冲区，对数据进行处理。简而言之，Channel负责传输，Buffer负责存取数据

4.4 NIO核心一：缓存区（Buffer)

缓存区（Buffer）
一个用于特定基本数据类型的容器。由Java.nio包定义的，所有缓冲区都是Buffer抽象类的子类．JavaNIO中 的Buffer主要用于与NIO通道进行交互，数据是从通道读入缓冲区，从缓冲区写入通道中的

Buffer类及其子类
Buffer就像一个数组，可以保存多个相同类型的数据。根据数据类型不同，有以下Buffer常用子类：

• ByteBuffer
• CharBuffer
• ShortBuffer
• IntBuffer
• LongBuffer
• FloatBuffer
• DoubleBuffer
  上述Buffer类 他们都采用相似的方法进行管理数据，只是各自管理的数据类型不同而已。都是通过如下
  方法获取一个Buffer对象：

static XxxBuffer allocate(int capacity):创建一个容量为capacity的XxxBuffer对象

缓存区的基本属性
Buffer中的重要概念：

• capacity（容量)：作为一个内存块，Buffer具有一定的固定大小，也称为”容量”，缓冲区容量不能为负，并且创建后不能更改。
• limit（限制)：表示缓冲区中可以操作数据的大小（limit后数据不能进行读写）。缓冲区的限制不能为负，并且不能大于其容量。写入模式，limit等于buffer的容量。读取模式下，limit等于写入的数据量。
• position(位置)：下一个要读取或写入的数据的索引。缓冲区的位置不能为负，并且不能大于其限制
• mark（标记）与reset（重置)：mark是一个索弓l，通过Buffer中的mark(）方法指定Buffer中一个特定的 position，之后可以通过调用reset(）方法恢复到这个position。标记、位置、限制、容量遵守不变式：0<=<=position<=limit<=capacity
  
  Buffer常见方法

	Buffer clear()清空缓冲区并返回对缓冲区的引用
	Buffer flip()为将缓冲区的界限设置为当前位置，并将当前位置重置为0
	int capacity()返回Buffer的capacity大小
	boolean hasRemaining()判断缓冲区中是否还有元素
	int limit()返回Buffer的界限（limit）的位置
	Buffer limit(int n)将设置缓冲区界限为n，并返回一个具有新limit的缓冲区对象
	Buffer mark()对缓冲区设置标记
	int position()返回缓冲区的当前位置position
	Buffer position(int n)将设置缓冲区的当前位置为n，并返回修改后的Buffer对象
	int remaining()返回position和limit之间的元素个数
	Buffer reset()将位置position转到以前设置的mark所在的位置
	Buffer rewind();将位置设为为0．取消设置的mark

缓存区的数据操作

	Buffer 所有子类提供了两个用于数据操作的方法：get() put()方法
	取获取Buffer中的数据
	get()：读取单个字节
	get(byte[] dst)：批量读取多个字节到dst中
	get(int index)：读取指定索引位置的字节（不会移动position)
	放到 入数据到Buffer中
	put(byte b):将给定单个字节写入缓冲区的当前位置
	put(byte[] src):将src中的字节写入缓存区的当前位置
	put(int index,byte b):将指定字节写入缓存区的索引位置（不会移动position）

使用Buffer读写数据一般遵循以下四个步骤：
1.写入数据到Buffer
2.调用flip()方法，转换为读取模式
3.从Buffer中读取数据
4.调用buffer.clear()方法或则buffer.compact()方法清除缓存区
案例演示

/**
* 目标：对缓存区Buffer的常用API进行案例实现
*/
public class BufferTest {
	@Test
	public void test01(){
		//1.分配一个缓存区，容量设置为10
		ByteBuffer buffer = ByteBuffer.allocate(10);
		System.out.println(buffer.position());//0
		System.out.println(buffer.limit());//10
		System.out.println(buffer.capacity());//10
		System.out.println("-----------------------");
		//put 往缓存区中添加数据
		String name = "itheima";
		buffer.put(name.getBytes());
		System.out.println(buffer.position());//7
		System.out.println(buffer.limit());//10
		System.out.println(buffer.capacity());//10
		System.out.println("-----------------------");
		//3.flip() 为 将缓存区的界限设置为当前位置，并将当前位置设置为 0 可读模式
		buffer.flip();
		System.out.println(buffer.position());//0
		System.out.println(buffer.limit());//7
		System.out.println(buffer.capacity());//10
		System.out.println("-----------------------");
		//4. get数据的读取
		char ch = (char) buffer.get();
		System.out.println(ch);//i
		System.out.println(buffer.position());//1
		System.out.println(buffer.limit());//7
		System.out.println(buffer.capacity());//10
	}
	@Test
	public void test02(){
		//1.分配一个缓存区，容量设置为10
		ByteBuffer buffer = ByteBuffer.allocate(10);
		System.out.println(buffer.position());//0
		System.out.println(buffer.limit());//10
		System.out.println(buffer.capacity());//10
		System.out.println("-----------------------");
		String name = "itheima";
		buffer.put(name.getBytes());
		System.out.println(buffer.position());//7
		System.out.println(buffer.limit());//10
		System.out.println(buffer.capacity());//10
		System.out.println("-----------------------");
		//2.clear 清楚缓存区中的数据
		buffer.clear();
		System.out.println(buffer.position());//0
		System.out.println(buffer.limit());//10
		System.out.println(buffer.capacity());//10
		System.out.println((char)buffer.get());//i 表明数据并没有清除 只是恢复了
		position的位置
		System.out.println("-----------------------");
		//3.定义一个缓存区
		ByteBuffer buf = ByteBuffer.allocate(10);
		String n = "itheima";
		buf.put(n.getBytes());
		buf.flip();
		//读取数据
		byte[] b = new byte[2];
		buf.get(b);
		String rs = new String(b);
		System.out.println(rs);//it
		System.out.println(buf.position());//2
		System.out.println(buf.limit());//7
		System.out.println(buf.capacity());//10
		System.out.println("-----------------------");
		buf.mark();//标记此刻这个位置：2
		byte[] b2 = new byte[3];
		buf.get(b2);
		System.out.println(new String(b2));//hei
		System.out.println(buf.position());//5
		System.out.println(buf.limit());//7
		System.out.println(buf.capacity());//10
		System.out.println("-----------------------");
		buf.reset();//回到标记位置 2
		if(buf.hasRemaining()){
			System.out.println(buf.remaining());//5
		}
	}
}

直接与非直接缓存区
什么是直接内存与非直接内存
根据官方文档的描述：
byte buffer。可以是两种类型，一种是基于直接内存（也就是非堆内存）；另一种是非直接内存（也就是堆内 存）。对于直接内存来说，JVM将会在IO操作上具有更高的性能，因为它直接作用于本地系统的IO操作。而非直接 内存，也就是堆内存中的数据，如果要作IO操作，会先从本进程内存复制到直接内存，再利用本地IO处理。
从数据流的角度，非直接内存是下面这样的作用链：

本地IO--->直接内存--->非直接内存--->直接内存--->本地IO

而直接内存是：

本地IO--->直接内存--->本地IO

很明显，在做IO处理时，比如网络发送大量数据时，直接内存会具有更高的效率。直接内存使用allocateDirect创建，但是它比申请普通的堆内存需要耗费更高的性能。不过，这部分的数据是在JVM之外的，因此它不会占用应用的内存。所以呢，当你有很大的数据要缓存，并且它的生命周期又很长，那么就比较适合使用直接内存。只是一般来说，如果不是能带来很明显的性能提升，还是推荐直接使用堆内存。字节缓冲区是直接缓冲区还是非直接缓冲区可通过调用其isDirect()方法来确定。

@Test
public void test03(){
	//创建一个非直接内存的缓存区
	ByteBuffer buffer = ByteBuffer.allocate(1024);
	//buffer.isDirect()用于判断是否为直接内存
	System.out.println(buffer.isDirect());
	System.out.println("----------------");
	//创建一个直接内存的缓存区
	ByteBuffer buffer2 = ByteBuffer.allocateDirect(1024);
	System.out.println(buffer2.isDirect());
}
输出：
false
----------------
true

使用场景

• 1 有很大的数据需要存储，他的生命周期又很长
• 2 适合频繁的IO操作，比如网络并发场景

未完待续