java IO编程详解
一、Socket
1. Sock概述
Socket，套接字就是两台主机之间逻辑连接的端点。TCP/IP协议是传输层协议，主要解决数据如何在网络中传输，而HTTP协议是应用层协议，主要解决如何包装数据。Socket是通信的基石，是支持TCP/IP协议网络通信的基本单元。他是网络通信过程中端点的抽象表示，包含进行网络通信必须的五种信息：连接使用的协议、本地主机的IP地址、本地进程的协议端口、远程主机的IP地址、远程进程的协议端口。
2. Socket整体流程
Socket主要涉及到客户端和服务器端两个方面，首先是在服务器端创建一个服务器套接字（ServerSocket），并把它附加到一个端口上，服务器从这个端口监听连接。端口号的范围是0-65535，但是0-1024是特权服务的保留端口号，可以选择任意一个当前没有被其他进程使用的端口。
客户端请求与服务器进行连接的时候，根据服务器的域名或者IP地址，加上端口号打开一个套接字。当服务器接收连接后，服务器和客户端之间的连接就像输入输出流一样进行操作。
3. 服务端实现
package com.myf.socket;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* @Author myf
* @Date 2021/3/23 21:15
* @Version 1.0
*/
public class serverSocket {
public static void main(String[] args) throws IOException {
// 创建一个线程池，如果有客户端与服务器连接就与其建立连接
final ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
final ServerSocket serverSocket = new ServerSocket(9999);
System.out.println("服务器已经启动");
while (true){
final Socket accept = serverSocket.accept();
System.out.println("有客户端连接");
cachedThreadPool.execute(new Runnable() {
@Override
public void run() {
hadler(accept);
}
});
}
}
private static void hadler(Socket accept) {
try {
System.out.println("线程ID："+Thread.currentThread().getId()+"线程名称："+Thread.currentThread().getName());
final InputStream inputStream = accept.getInputStream();
byte[] bytes = new byte[1024];
final int read = inputStream.read(bytes);
final String s = new String(bytes, 0, read);
System.out.println("客户端消息："+s);
final OutputStream outputStream = accept.getOutputStream();
outputStream.write("hello".getBytes());
outputStream.flush();
}catch (IOException e){
e.printStackTrace();
}finally {
try {
accept.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
4. 客户端实现
package com.myf.socket;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
/**
* @Author myf
* @Date 2021/3/24 13:34
* @Version 1.0
*/
public class ClientSocket {
public static void main(String[] args) {
try {
while (true){
Socket socket = new Socket("127.0.0.1",9999);
final OutputStream outputStream = socket.getOutputStream();
outputStream.write("你好".getBytes());
final InputStream inputStream = socket.getInputStream();
byte[] bytes = new byte[1024];
final int read = inputStream.read(bytes);
final String s = new String(bytes, 0, read);
System.out.println(s);
socket.close();
Thread.sleep(1000);
}
} catch (IOException | InterruptedException e) {
e.printStackTrace();
}
}
}
二、IO模型
- IO模型简单的理解：就是用什么样的通道进行数据的发送和接收，很大程度上决定了程序通信的性能。
- java共支持三种网络IO模型：BIO（同步阻塞）、NIO（同步非阻塞）、AIO（异步非阻塞）
阻塞与非阻塞
主要是访问IO的线程是否会阻塞（或处于等待）线程访问资源，该资源是否准备就绪的一种处理方式（主要是在未就绪的情况下的处理方式）
同步和异步
主要是指数据的请求方式同步和异步是指访问数据的一种机制
1. BIO（同步并阻塞）
java BIO就是传统的Socket编程。
BIO（blocking IO）：同步阻塞，服务器实现模式为一个连接一个线程，即客户端有一个连接请求时，服务端就需要启动一个线程进行处理，如果这个线程不做任何事情会造成不必要的线程开销，可以通过线程池机制改善。
BIO问题分析
- 每个请求都需要创建独立的线程，与对应的客户端进行数据Read，业务处理，数据Write。
- 并发数较大时，需要建立大量的线程来处理连接，系统资源占用较大。
- 连接建立后，如果当前线程暂时没有数据可读，线程就回阻塞在Read上，造成线程资源浪费。
2. NIO（同步非阻塞）
同步非阻塞，服务器实现模式为一个线程处理多个请求（连接），即客户端发送的连接请求都会注册到多路复用器上，多路复用器轮询到连接有IO请求就进行处理。
3. AIO（异步非阻塞）
AIO引入异步通道的概念，采用了Proactor模式，简化了程序编写，有效的请求才启动线程。它的特点是先由操作系统完成后才通知服务器程序启动线程去处理，一般适用于连接较多且连接时间较长的应用。
Proactor模式是一个消息异步通知的设计模式，Proactor通知的不是就绪事件，而是操作完成事件，这也就是操作系统异步IO的主要模型。
4. BIO、NIO、AIO适用场景分析
- BIO(同步并阻塞)方式适用于连接数目较小且固定的架构，这种方式对服务器资源要求较高，并发局限于应用中，JDK1.4之前的唯一选择，但程序简单易理解。
- NIO(同步非阻塞)方式适用于连接比较多且连接比较短的架构，比如聊天服务器、弹幕系统、服务器间通信等。编程比较复杂，JDK1.4开始支持。
- AIO(异步非阻塞)方式适用于连接比较多且连接比较长的架构，比如相册服务器，充分调用OS参与并发操作，编程比较复杂，JDK1.7开始支持。
三、NIO编程
1. NIO介绍
java NIO全称java non-blocking IO，是指java提供的新的API。从JDK1.4开始，java提供了一系列改进的输入\输出的新特性，被统称为NIO(New IO)，是同步非阻塞的。
- NIO有三大核心部件：Channel（通道），Buffer（缓冲区），Selector（选择器）。
- NIO是面向缓冲区编程的。数据读取到一个缓冲区中，需要时可在缓冲区前后移动，这就增加了处理过程的灵活性，使用它可以提供非阻塞式的高伸缩网络。
- java NIO的非阻塞模式，使一个线程从某通道发送请求或者读取数据，但是他仅能得到目前可用的数据，如果目前没有数据可用时，就什么都不会获取，而不是保持线程阻塞，所以直至数据变的可以读取之前，该线程可以做其他的事情。非阻塞写也是这样，一个线程请求写入一些数据到某个通道，但不需要等待他完全写入，这个线程同时可以去做别的事情。通俗理解：NIO可以做到用一个线程来处理多个操作。假设有10000个请求过来，可以分配50或者100个线程来处理。不想之前的阻塞IO那样非得分配10000个线程。
2. NIO和BIO的比较
- BIO是以流的方式处理数据，而NIO是以缓冲区的方式处理数据，缓冲区IO的效率比流IO的效率高很多。
- BIO是阻塞的，NIO是非阻塞的。
- BIO是基于字节流和字符流进行操作的，而NIO基于Channel（通道）和Buffer（缓冲区）进行操作，数据总是从通道读取到缓冲区中，或者从缓冲区写入到通道中。Selector（选择器）用于监听多个通道事件（比如：连接请求，数据到达等），因此使用单个线程就可以监听多个客户端通道。
3. NIO三大核心原理示意图
一张图描述NIO的Selector、Channel和Buffer的关系
- 每个Channel都会对应一个Buffer。
- Selector对应一个线程，一个线程对应多个channel。
- 每个channel都注册到Selector选择器上。
- Selector不断轮询查看channel上的事件，事件是通道channel非常重要的概念。
- Selector会根据不同的事件，完成不同的处理操作。
- Buffer就是一个内存块，底层就是一个数组。
- 数据的读取写入是通过Buffer，这个和BIO不同，BIO要么是输入流，或者是输出流，不能双向。但是NIO的Buffer是可以读也可以写，channel是双向的。
4. 缓冲区（Buffer）
4.1 基本介绍
缓冲区（Buffer）：本质上是一个可以读写数据的内存块。可以理解成一个数组，该对象提供了一组方法，可以轻松的使用内存块。缓冲区内置了一些机制，能够跟踪和记录缓冲区的状态变化情况，Channel提供从网络读取数据的通道，但是读取和写入数据都必须经过Buffer。
4.2 Buffer常用API介绍
- Buffer类及其子类
在NIO中，Buffer是一个顶层父类，他是一个抽象类，以上是类的层次关系图，常见的缓冲区分别对应7中基本数据类型，byte、short、int、long、float、double、char。
缓冲区对象的创建
方法名 说明 static ByteBuffer allocate(长度) 创建byte类型的指定长度的缓冲区 static ByteBuffer wrap(byte[] array) 创建一个有内容的byte类型缓冲区 示例代码：
public class CreateBufferDemo { public static void main(String[] args) { // 创建指定长度的缓冲区 ByteBuffer为例 final ByteBuffer allocate = ByteBuffer.allocate(5); for (int i = 0; i < 5; i++) { System.out.println(allocate.get()); } //System.out.println(allocate.get()); // 创建一个有内容的缓冲区 final ByteBuffer wrap = ByteBuffer.wrap("myfff".getBytes()); for (int i = 0; i < 5; i++) { System.out.println(wrap.get()); } } }缓冲区对象添加数据
方法名 说明 int position()/position(int newPosition) 获取当前要操作的索引/修改当前要操作索引的位置 int limit()/limit(int newLimit) 最多能操作到哪个索引/修改最多能够操作的索引位置 int capacity() 返回缓冲区总长度 int remaining()/boolean hasRemaining() 还有多少能够操作索引的个数/是否还能操作 put(byte b)/put(byte[] src) 添加一个字节/添加字节数组 图解：
示例代码：
/**
* 向缓冲区添加数据
* @Author myf
* @Date 2021/3/31 1:17
* @Version 1.0
*/
public class PutBufferDemo {
public static void main(String[] args) {
// 创建一个缓冲区
final ByteBuffer allocate = ByteBuffer.allocate(10);
// 当前索引的位置
System.out.println(allocate.position());
// 最多能操作到哪个索引
System.out.println(allocate.limit());
// 返回缓冲区总长度
System.out.println(allocate.capacity());
// 还有多少能操作的个数
System.out.println(allocate.remaining());
// 修改当前索引所在的位置
allocate.position(1);
// 修改最多能够操作的索引的位置
allocate.limit(9);
System.out.println("======================");
// 当前索引的位置
System.out.println(allocate.position());
// 最多能操作到哪个索引
System.out.println(allocate.limit());
// 返回缓冲区总长度
System.out.println(allocate.capacity());
// 还有多少能操作的个数
System.out.println(allocate.remaining());
// 添加一个字节
allocate.put((byte) 97);
System.out.println("======================");
// 当前索引的位置
System.out.println(allocate.position());
// 最多能操作到哪个索引
System.out.println(allocate.limit());
// 返回缓冲区总长度
System.out.println(allocate.capacity());
// 还有多少能操作的个数
System.out.println(allocate.remaining());
// 添加一个数组
allocate.put("myf".getBytes());
System.out.println("======================");
// 当前索引的位置
System.out.println(allocate.position());
// 最多能操作到哪个索引
System.out.println(allocate.limit());
// 返回缓冲区总长度
System.out.println(allocate.capacity());
// 还有多少能操作的个数
System.out.println(allocate.remaining());
// 如果缓冲区满了，可以调整position位置，就可以重复写了，会覆盖之前索引位置的值
allocate.position(0);
allocate.put("myf".getBytes());
System.out.println("======================");
// 当前索引的位置
System.out.println(allocate.position());
// 最多能操作到哪个索引
System.out.println(allocate.limit());
// 返回缓冲区总长度
System.out.println(allocate.capacity());
// 还有多少能操作的个数
System.out.println(allocate.remaining());
}
}缓冲区对象读取数据
方法名 介绍 flip() 写切换读模式 limit设置position位置, position设置0 get() 读一个字节 get(byte[] dst) 读多个字节 get(int index) 读指定索引的字节 rewind() 将position设置为0，可以重复读 clear() 切换写模式 position设置为0 , limit 设置为 capacity array() 将缓冲区转换成字节数组返回 图解:flip()方法
图解:clear()方法
实例代码：
/**
* 从缓冲区读取数据
* @Author myf
* @Date 2021/3/31 2:03
* @Version 1.0
*/
public class GetBufferDemo {
public static void main(String[] args) {
// 创建指定长度的缓冲区
final ByteBuffer allocate = ByteBuffer.allocate(10);
allocate.put("0123".getBytes());
System.out.println(allocate.position());
System.out.println(allocate.limit());
System.out.println(allocate.capacity());
System.out.println(allocate.remaining());
// 切换读模式
System.out.println("=======================");
allocate.flip();
System.out.println(allocate.position());
System.out.println(allocate.limit());
for (int i = 0; i < allocate.limit(); i++) {
System.out.println(allocate.get());
}
System.out.println("读取指定位置数据");
System.out.println(allocate.get(1));
System.out.println("读取多个字节数据");
// 重复读取
allocate.rewind();
byte[] bytes = new byte[4];
System.out.println(allocate.get(bytes));
for (byte aByte : bytes) {
System.out.println(aByte);
}
System.out.println("将缓冲区转换成字节数组返回");
final byte[] array = allocate.array();
System.out.println(new String(array));
// 切换写模式
allocate.clear();
System.out.println(allocate.position());
System.out.println(allocate.limit());
allocate.put("987".getBytes());
final byte[] array2 = allocate.array();
System.out.println(new String(array2));
}
}
- capacity：容量（长度）limit：界限（最多能读/写到哪里）position：位置（读/写哪个索引）
- 读取缓冲区里面数据之前，需要调用flip方法
- 再次写数据之前，需要调用clear方法，但是数据还未消失，等再次写入数据，被覆盖了才会消失。
5.通道（Channel）
5.1 基本介绍
通常来说NIO中所有IO都是从Channel（通道）开始的。NIO通道类似于流，但有些区别如下：
- 通道可以读也可以写，流一般是单向的（只能读或写）
- 通道可以异步读写
- 通道总是基于缓冲区Buffer来读写
5.2 Channel常用类介绍
- Channel接口
常用的Channel实现类有：FileChannel，DatagramChannel，ServerSocketChannel和SocketChannel。FileChannel用于文件数据的读写，DatagremChannel用于UDP数据的读写，ServerSocketChannel和SocketChannel用于TCP数据的读写
- SocketChannel与ServerSocketChannel
类似Socket与ServerSocket可以完成客户端与服务器端数据的通信工作。
5.3 ServerSocketChannel
服务端实现步骤：
- 打开一个服务端通道。
- 绑定对应的端口号。
- 通道默认为阻塞的，设置为非阻塞。
- 检查是否有客户端连接，有客户端连接会返回对应的通道。
- 获取客户端传递过来的数据，并把数据放在ByteBuffer这个缓冲区中。
- 给客户端回写数据。
- 释放资源。
代码实现：
public class NioServer {
public static void main(String[] args) throws IOException, InterruptedException {
//1. 打开一个服务端通道。
ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
//2. 绑定对应的端口号。
serverSocketChannel.bind(new InetSocketAddress(9999));
//3. 通道默认为阻塞的，设置为非阻塞。
serverSocketChannel.configureBlocking(false);
System.out.println("服务端启动成功。。。。");
//4. 检查是否有客户端连接，有客户端连接会返回对应的通道。
while (true){
// 不会阻塞在这里
final SocketChannel socketChannel = serverSocketChannel.accept();
if (socketChannel==null){
System.out.println("没有客户端连接。。。我去做别的事情");
Thread.sleep(1000);
continue;
}
//5. 获取客户端传递过来的数据，并把数据放在ByteBuffer这个缓冲区中。
ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
// 返回值
// 正数：表示本次读到的字节数
// 0:表示本次没有读到数据
// 1:表示读到末尾
final int read = socketChannel.read(byteBuffer);
System.out.println("客户端消息" + new String(byteBuffer.array(),0,read, StandardCharsets.UTF_8));
//6. 给客户端回写数据。
socketChannel.write(ByteBuffer.wrap("没钱".getBytes(StandardCharsets.UTF_8)));
//7. 释放资源。
socketChannel.close();
}
}
}5.4 SocketChannel
客户端实现步骤：
- 打开通道
- 设置连接IP和端口号
- 写出数据
- 读取服务器写回的数据
- 释放资源
代码实现：
public class NioClient {
public static void main(String[] args) throws IOException {
//1. 打开通道
final SocketChannel socketChannel = SocketChannel.open();
//2. 设置连接IP和端口号
socketChannel.connect(new InetSocketAddress("127.0.0.1",9999));
//3. 写出数据
socketChannel.write(ByteBuffer.wrap("老板还钱吧".getBytes(StandardCharsets.UTF_8)));
//4. 读取服务器写回的数据
ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
final int read = socketChannel.read(byteBuffer);
System.out.println("服务端消息:" + new String(byteBuffer.array(),0,read,StandardCharsets.UTF_8));
//5. 释放资源
socketChannel.close();
}
}
6.选择器（Selector）
可以用一个线程，处理多个的客户端连接，就会使用到NIO的Selector(选择器). Selector 能够检测多个注册的服务端通道上是否有事件发生，如果有事件发生，便获取事件然后针对每个事件进行相应的处理。这样就可以只用一个单线程去管理多个通道，也就是管理多个连接和请求。
在这种没有选择器的情况下，每个连接对应一个处理线程，但是线程并不会马上发出消息，会造成资源浪费
只有在通道读写事件真正发生时，才会进行读写，就大大减少了系统开销，并且不必为每个连接都创建一个连接，不用去维护多个线程，避免了多线程之间上下文切换造成的开销
6.1 常用API介绍
Selecter类是一个抽象类
常用方法
- Selector.open() : //得到一个选择器对象
- selector.select() : //阻塞 监控所有注册的通道,当有对应的事件操作时, 会将SelectionKey放入集合内部并返回事件数量
- selector.select(1000): //阻塞 1000 毫秒，监控所有注册的通道,当有对应的事件操作时, 会将SelectionKey放入集合内部并返回
- selector.selectedKeys() : // 返回存有SelectionKey的集合
SelectionKey
常用方法
- SelectionKey.isAcceptable(): 是否是连接继续事件
- SelectionKey.isConnectable(): 是否是连接就绪事件
- SelectionKey.isReadable(): 是否是读就绪事件
- SelectionKey.isWritable(): 是否是写就绪事件
SelectionKey中定义的4种事件:
- SelectionKey.OP_ACCEPT —— 接收连接继续事件，表示服务器监听到了客户连接，服务器可以接收这个连接了
- SelectionKey.OP_CONNECT —— 连接就绪事件，表示客户端与服务器的连接已经建立成功
- SelectionKey.OP_READ —— 读就绪事件，表示通道中已经有了可读的数据，可以执行读操作了（通道目前有数据，可以进行读操作了）
- SelectionKey.OP_WRITE —— 写就绪事件，表示已经可以向通道写数据了（通道目前可以用于写操作）
6.2 Selecter编码
服务端实现步骤
- 打开一个服务端通道
- 绑定对应的端口号
- 通道默认是阻塞的，需要设置为非阻塞
- 创建选择器
- 将服务端通道注册到选择器上,并指定注册监听的事件为OP_ACCEPT
- 检查选择器是否有事件
- 获取事件集合
- 判断事件是否是客户端连接事件SelectionKey.isAcceptable()
- 得到客户端通道,并将通道注册到选择器上, 并指定监听事件为OP_READ
- 判断是否是客户端读就绪事件SelectionKey.isReadable()
- 得到客户端通道,读取数据到缓冲区
- 给客户端回写数据
- 从集合中删除对应的事件, 因为防止二次处理
代码实现：
public class NIOSelectorServer {
public static void main(String[] args) throws IOException {
// 1. 打开一个服务端通道
ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
// 2. 绑定对应的端口号
serverSocketChannel.bind(new InetSocketAddress(9999));
// 3. 通道默认是阻塞的，需要设置为非阻塞
serverSocketChannel.configureBlocking(false);
// 4. 创建选择器
Selector selector = Selector.open();
// 5. 将服务端通道注册到选择器上,并指定注册监听的事件为OP_ACCEPT
serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
System.out.printf("服务端启动成功");
while (true){
// 6. 检查选择器是否有事件
int select = selector.select(2000);
if (select==0){
System.out.println("没有事件发生");
continue;
}
// 7. 获取事件集合
Set<SelectionKey> selectionKeys = selector.selectedKeys();
// 8. 判断事件是否是客户端连接事件SelectionKey.isAcceptable()
for (SelectionKey selectionKey : selectionKeys) {
if (selectionKey.isAcceptable()){
// 9. 得到客户端通道,并将通道注册到选择器上, 并指定监听事件为OP_READ
SocketChannel socketChannel = serverSocketChannel.accept();
System.out.println("有客户端连接");
// 将通道设置未非阻塞的状态，因为Selector需要轮训监听每个通道
socketChannel.configureBlocking(false);
socketChannel.register(selector,SelectionKey.OP_READ);
}
// 10. 判断是否是客户端读就绪事件SelectionKey.isReadable()
if (selectionKey.isReadable()){
SocketChannel socketChannel = (SocketChannel) selectionKey.channel();
ByteBuffer allocate = ByteBuffer.allocate(1024);
// 11. 得到客户端通道,读取数据到缓冲区
int read = socketChannel.read(allocate);
if (read>0){
System.out.printf("客户端消息："+new String(allocate.array(),0,read));
// 12. 给客户端回写数据
socketChannel.write(ByteBuffer.wrap("没钱".getBytes(StandardCharsets.UTF_8)));
socketChannel.close();
}
}
// 13. 从集合中删除对应的事件, 因为防止二次处理
selectionKeys.remove(selectionKey);
}
}
}
}public class NIOClient {
public static void main(String[] args) throws IOException {
// 打开通道
SocketChannel socketChannel = SocketChannel.open();
// 绑定端口
socketChannel.connect(new InetSocketAddress("127.0.0.1",9999));
// 发送数据
socketChannel.write(ByteBuffer.wrap("老板还钱".getBytes(StandardCharsets.UTF_8)));
// 读取服务端数据
ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
int read = socketChannel.read(byteBuffer);
System.out.println("服务端返回数据" + new String(byteBuffer.array(),0,read));
socketChannel.close();
}
}