OSI网络七层模型
各层主要功能
低三层
- 物理层:使原始的数据比特流能在物理介质上传输
- 数据链路层:通过校验、确认和反馈重发等手段,形成稳定的数据链路
网络层:进行路由选择和流量控制(IP协议)
传输层:提供可靠的端口到端口的数据传输服务(TCP/UDP协议)
高三层
- 会话层:负责建立、管理和终止进程之间的会话与数据交换
- 表示层:负责数据格式转换、数据加密与解密、压缩和解压缩等
- 应用层:为用户的应用程序提供网络服务
传输控制协议TCP
TCP是Internet一个重要的传输层协议。TCP提供面向连接、可靠、有序、字节流传输服务。应用程序在使用TCP之前,必须先建立TCP连接。
TCP握手机制
用户数据报协议UDP
用户数据报协议UDP是Internet传输层协议。提供无连接、不可靠、数据报尽力传输服务。
在UDP协议上构建应用,关注以下几点:
- 数据报类型套接字SOCK_DGRAM(面向UDP接口)
- 流式套接字SOCK_STREAM(面向TCP接口)
- 原始套接字SOCK_RAM(面向网络层协议接口IP、ICMP等)
主要socket API及其调用过程:
Socket API函数定义:
listen()、accept()函数只能用于服务器端;
connect()函数只能用于客户端;
通用函数:socket()、bind()、send()、recv()、sendto()、recvfrom()、close()
BIO网络编程
- 实现:SocketServer和Socket
- 缺点:多个client同时访问服务器压力大
- 解决:使用线程池实现伪异步操作
服务器端代码:
public class BIOServer {
public static void main(String[] args) throws Exception{
ServerSocket serverSocket = new ServerSocket(8080);
System.out.println("服务器已启动。。。");
while (!serverSocket.isClosed()) {
Socket request = serverSocket.accept();// 阻塞,直到收到请求
System.out.println("收到新的请求:"+request.toString());
try {
InputStream inputStream = request.getInputStream();
BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));
String msg;
while((msg = reader.readLine()) != null){
if(msg.length()==0){
break;
}
System.out.println(msg);
}
System.out.println("收到数据,来自:"+ request.toString());
}catch (Exception e){
e.printStackTrace();
}finally {
try {
request.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
serverSocket.close();
}
}
客户端代码:
public class BIOClient {
private static Charset charset = Charset.forName("UTF-8");
public static void main(String[] args) throws Exception{
Socket socket = new Socket("localhost", 8080);
OutputStream outputStream = socket.getOutputStream();
Scanner scanner = new Scanner(System.in);
System.out.println("请输入:");
String msg = scanner.nextLine();
outputStream.write(msg.getBytes(charset)); // 阻塞,写完成
scanner.close();
socket.close();
}
}
单线程的服务器端一次只能处理一个请求,会阻塞等待,用多线程改造服务器端,使其能同时处理多个请求。
多线程版服务器端代码:
public class BIOServer1 {
private static ExecutorService threadPool = Executors.newCachedThreadPool();
public static void main(String[] args) throws Exception{
ServerSocket serverSocket = new ServerSocket(8080);
System.out.println("服务器已启动。。。");
while (!serverSocket.isClosed()) {
Socket request = serverSocket.accept();// 阻塞,直到收到请求
System.out.println("收到新的请求:"+request.toString());
threadPool.execute(()->{
try {
InputStream inputStream = request.getInputStream();
BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));
String msg;
while((msg = reader.readLine()) != null){
if(msg.length()==0){
break;
}
System.out.println(msg);
}
System.out.println("收到数据,来自:"+ request.toString());
}catch (Exception e){
e.printStackTrace();
}finally {
try {
request.close();
} catch (IOException e) {
e.printStackTrace();
}
}
});
}
serverSocket.close();
}
}
Http协议-请求数据包解析
- 第一部分: 请求行, 请求类型, 资源路径以及HTTP 版本。
- 第二部分: 请求头部, 紧接着请求行( 即第一行) 之后的部分, 用来说明服务器要使用的附加信息
- 第三部分: 空行, 请求头部后面的空行是必须的请求头部和数据主体之间必须有换行
-
Http协议-响应数据包解析
第一部分: 状态行。HTTP 版本、状态码、状态消息。
- 第二部分: 响应报头部, 紧接着请求行〈即第一行) 之后的部分, 用来说明服务器要使用的附加信息
- 第三部分: 空行, 头部后面的空行是必须的头部和数据主体之间必须有换行
- 第四部分: 响应正文。可以添加任意的数据。
以上的代码只支持了多线程访问,但是浏览器不能访问,在收到请求后,返回http响应数据包即可实现浏览器访问。
支持浏览器访问的服务器端代码:
public class BIOServer2 {
private static ExecutorService threadPool = Executors.newCachedThreadPool();
public static void main(String[] args) throws Exception {
ServerSocket serverSocket = new ServerSocket(8080);
System.out.println("服务器启动成功");
while (!serverSocket.isClosed()) {
Socket request = serverSocket.accept();
System.out.println("收到新连接 : " + request.toString());
threadPool.execute(() -> {
try {
// 接收数据、打印
InputStream inputStream = request.getInputStream();
BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream, "utf-8"));
String msg;
while ((msg = reader.readLine()) != null) {
if (msg.length() == 0) {
break;
}
System.out.println(msg);
}
System.out.println("收到数据,来自:"+ request.toString());
// 响应结果 200
OutputStream outputStream = request.getOutputStream();
outputStream.write("HTTP/1.1 200 OK\r\n".getBytes());
outputStream.write("Content-Length: 11\r\n\r\n".getBytes());
outputStream.write("Hello World".getBytes());
outputStream.flush();
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
request.close();
} catch (IOException e) {
e.printStackTrace();
}
}
});
}
serverSocket.close();
}
}
BIO-阻塞的含义
- 阻塞(blocking)IO: 资源不可用时,IO请求一直阻塞, 直到反馈结果( 有数据或超时)。
非阻塞(non-blocking)IO: 资源不可用时,IO请求离开返回, 返回数据标识资源不可用。
同步(synchronous)IO: 应用阻塞在发送或接收数据的状态, 直到数据成功传输或返回失败。
- 异步(asynchronous) IO: 应用发送或接收数据后立刻返回, 实际处理是异步执行的。
阻塞和非阻塞是获取资源的方式, 同步/ 异步是程序如何处理资源的逻辑设计。
代码中使用的API : ServerSocket#accept 、lnputStream#read 都是阻塞的API 。操作系统底层API中, 默认Socket 操作都是Blocking 型, send/recv 等接口都是阻塞的。
带来的问题: 阻塞致在处理网络I/O 时, 一个线程只能处理一个网络连接。
NIO网络编程
- NIO三个核心组件:Buffer(缓冲区)、Channel(通道)、Selector(选择器,多路复用器)
- 实现:SocketServerChannel、SocketChannel
Buffer缓冲区
缓冲区本质上是一个可以写入数据的内存块( 类似数组) , 然后可以再次读取。此内存块包含在NIO Buffer对象中, 该对象提供了一组方法, 可以更轻松地使用内存块。相比较直接对数组的操作, BufferAP | 更加容易操作和管理。
使用Buffer 进行数据写入与读取, 需要进行如下四个步骤:
- 将数据写入缓冲区
- 调用buffer.flip() , 转换为读取模式
- 缓冲区读取数据
- 调用buffer.clear() 或buffer.compact() 清除缓冲区
Buffer工作原理
Buffer三个重要属性:
- capacity容量:作为一个内存块,Buffer具有一定的固定大小,也称“容量”
- position位置:写入模式时代表写数据的位置,读取模式时代表读取数据的位置
- limit限制:写入模式,限制等于buffer的容量;读取模式,limit等于写入的数据量
public class BufferDemo {
public static void main(String[] args) {
// 构建一个byte字节缓冲区,容量是4
ByteBuffer byteBuffer = ByteBuffer.allocateDirect(4);
// 默认写入模式,查看三个重要的指标
System.out.println(String.format("初始化:capacity容量:%s, position位置:%s, limit限制:%s", byteBuffer.capacity(),
byteBuffer.position(), byteBuffer.limit()));
// 写入2字节的数据
byteBuffer.put((byte) 1);
byteBuffer.put((byte) 2);
byteBuffer.put((byte) 3);
// 再看数据
System.out.println(String.format("写入3字节后,capacity容量:%s, position位置:%s, limit限制:%s", byteBuffer.capacity(),
byteBuffer.position(), byteBuffer.limit()));
// 转换为读取模式(不调用flip方法,也是可以读取数据的,但是position记录读取的位置不对)
System.out.println("#######开始读取");
byteBuffer.flip();
byte a = byteBuffer.get();
System.out.println(a);
byte b = byteBuffer.get();
System.out.println(b);
System.out.println(String.format("读取2字节数据后,capacity容量:%s, position位置:%s, limit限制:%s", byteBuffer.capacity(),
byteBuffer.position(), byteBuffer.limit()));
// 继续写入3字节,此时读模式下,limit=3,position=2.继续写入只能覆盖写入一条数据
// clear()方法清除整个缓冲区。compact()方法仅清除已阅读的数据。转为写入模式
byteBuffer.compact(); // buffer : 剩1个数据 ,可写入 3个
byteBuffer.put((byte) 3);
byteBuffer.put((byte) 4);
byteBuffer.put((byte) 5);
System.out.println(String.format("最终的情况,capacity容量:%s, position位置:%s, limit限制:%s", byteBuffer.capacity(),
byteBuffer.position(), byteBuffer.limit()));
// rewind() 重置position为0
// mark() 标记position的位置
// reset() 重置position为上次mark()标记的位置
}
}
ByteBuffer内存类型
ByteBuffer 为性能关键型代码提供了直接内存( direct 堆外) 和非直接内存( heap 堆) 两种实现。
堆外内存获取的方式: ByteBuffer directByteBuffer = ByteBuffer.aIIocateDirect(noBytes);
好处:
- 进行网络IO或者文件IO时比heapBuffer 少一次拷贝。(file/socket —- OS memory —- jvm heap)
GC 会移动对象内存, 在写file或socket 的过程中,JVM 的实现中, 会先把数据复制到堆外, 再进行写入。
- GC 范围之外, 降低GC 压力, 但实现了自动管理。DirectByteBuffer 中有一个Cleaner 对象
(PhantomReference), CIeaner 被GC 前会执行clean 方法, 触发DirectByteBuffer 中定义的Deallocator
建议:
- 性能确实可观的时候才去使用; 分配给大型、长寿命; ( 网络传输、文件读写场景)
- 通过虚拟机参数MaxDirectMemorySize限制大小, 防止耗尽整个枳器的内存;
ByteBuffer byteBuffer = ByteBuffer.allocateDirect(4);
Channel通道
Channel的API中涵盖了UDP/TCP网络和文件IO:FileChannel、DatagramChannel、SocketChannel、ServerSocketChannel。
NIO和标准IO Stream的区别:
- 在一个通道内进行读取和写入,stream通常是单向的(input或output)
- 可以非阻塞的读取和写入通道
- 通道始终读取或写入缓冲区
SocketChannel
SocketChannel用于建立TCP网络连接,类似java.net.Socket。有两种创建SocketChannel的形式:
- 客户端主动发起和服务端的连接
- 服务端获取新的连接
write写:write()在尚未写入任何东西的时候就可能返回了。需要在循环中调用write()。
read读:read()方法可能直接返回而根本不读取任何数据,根据返回的int值判断读取了多少字节。
ServerSocketChannel
ServerSocketChannel可以监听新建的TCP通道,类似ServerSocket。
serverSocketChannel.accept():如果该通道处于非阻塞模式,那么如果没有挂起的连接,该方法将立即返回null。必须检查返回的SocketChannel是否为null。
Selector选择器
Selector是一个Java NIO组件,可以检查一个或多个NIO通道,并确定哪些通道已经准备好进行读取或写入。实现单线程可以管理多个通道,从而管理多个网络连接。
一个线程使用Selector监听多个channel的不同事件:四个事件分别对应SelectionKey的四个常量。
- Connect连接(SelectionKey.OP_CONNECT)
- Accept准备就绪(OP_ACCEPT)
- Read读取(OP_READ)
- Write写入(OP_WRITE)
实现一个线程处理多个通道的核心概念理解:事件驱动机制。
非阻塞的网络通道下,开发者通过Selector注册对于通道感兴趣的事件类型,线程通过监听事件来触发相应的代码执行。(更底层是操作系统的多路复用机制)
客户端代码:
public class NIOClient {
public static void main(String[] args) throws Exception {
SocketChannel socketChannel = SocketChannel.open();
socketChannel.configureBlocking(false); // 设置为非阻塞模式
socketChannel.connect(new InetSocketAddress("127.0.0.1", 8080));
while (!socketChannel.finishConnect()) {
// 没连接上,则一直等待
Thread.yield();
}
Scanner scanner = new Scanner(System.in);
System.out.println("请输入:");
// 发送内容
String msg = scanner.nextLine();
ByteBuffer buffer = ByteBuffer.wrap(msg.getBytes());
while (buffer.hasRemaining()) {
socketChannel.write(buffer);
}
// 读取响应
System.out.println("收到服务端响应:");
ByteBuffer requestBuffer = ByteBuffer.allocate(1024);
while (socketChannel.isOpen() && socketChannel.read(requestBuffer) != -1) {
// 长连接情况下,需要手动判断数据有没有读取结束 (此处做一个简单的判断: 超过0字节就认为请求结束了)
if (requestBuffer.position() > 0) break;
}
requestBuffer.flip();// 读取完成后复位,准备读response
byte[] content = new byte[requestBuffer.limit()];
requestBuffer.get(content);
System.out.println(new String(content));
scanner.close();
socketChannel.close();
}
}
服务器端代码:
/**
* 结合Selector实现的非阻塞服务端(放弃对channel的轮询,借助消息通知机制)
*/
public class NIOServerV2 {
public static void main(String[] args) throws Exception {
// 1. 创建网络服务端ServerSocketChannel
ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
serverSocketChannel.configureBlocking(false); // 设置为非阻塞模式
// 2. 构建一个Selector选择器,并且将channel注册上去
Selector selector = Selector.open();
SelectionKey selectionKey = serverSocketChannel.register(selector, 0, serverSocketChannel);// 将serverSocketChannel注册到selector
selectionKey.interestOps(SelectionKey.OP_ACCEPT); // 对serverSocketChannel上面的accept事件感兴趣(serverSocketChannel只能支持accept操作)
// 3. 绑定端口
serverSocketChannel.socket().bind(new InetSocketAddress(8080));
System.out.println("启动成功");
while (true) {
// 不再轮询通道,改用下面轮询事件的方式.select方法有阻塞效果,直到有事件通知才会有返回
selector.select();// 选择已经准备好IO操作的通道
// 获取事件
Set<SelectionKey> selectionKeys = selector.selectedKeys();
// 遍历查询结果e
Iterator<SelectionKey> iter = selectionKeys.iterator();
while (iter.hasNext()) {
// 被封装的查询结果
SelectionKey key = iter.next();
iter.remove();
// 关注 Read 和 Accept两个事件
if (key.isAcceptable()) {
ServerSocketChannel server = (ServerSocketChannel) key.attachment();
// 将拿到的客户端连接通道,注册到selector上面
SocketChannel clientSocketChannel = server.accept(); // mainReactor 轮询accept
clientSocketChannel.configureBlocking(false);
clientSocketChannel.register(selector, SelectionKey.OP_READ, clientSocketChannel);
System.out.println("收到新连接 : " + clientSocketChannel.getRemoteAddress());
}
if (key.isReadable()) {
SocketChannel socketChannel = (SocketChannel) key.attachment();
try {
ByteBuffer requestBuffer = ByteBuffer.allocate(1024);
while (socketChannel.isOpen() && socketChannel.read(requestBuffer) != -1) {
// 长连接情况下,需要手动判断数据有没有读取结束 (此处做一个简单的判断: 超过0字节就认为请求结束了)
if (requestBuffer.position() > 0) break;
}
if(requestBuffer.position() == 0) continue; // 如果没数据了, 则不继续后面的处理
requestBuffer.flip();
byte[] content = new byte[requestBuffer.limit()];
requestBuffer.get(content);
System.out.println(new String(content));
System.out.println("收到数据,来自:" + socketChannel.getRemoteAddress());
// TODO 业务操作 数据库 接口调用等等
// 响应结果 200
String response = "HTTP/1.1 200 OK\r\n" +
"Content-Length: 11\r\n\r\n" +
"Hello World";
ByteBuffer buffer = ByteBuffer.wrap(response.getBytes());
while (buffer.hasRemaining()) {
socketChannel.write(buffer);
}
} catch (IOException e) {
// e.printStackTrace();
key.cancel(); // 取消事件订阅
}
}
}
selector.selectNow();
}
// 问题: 此处一个selector监听所有事件,一个线程处理所有请求事件. 会成为瓶颈! 要有多线程的运用
}
}
NIO对比BIO
如果程序需要支撑大量的连接,使用NIO是最好的方式。
Tomcat8中,已经完全去除BIO相关的网络处理代码,默认采用NIO进行网络处理。
NIO与多线程结合的改进方案
总结:
NIO为开发者提供了功能丰富及强大的IO处理API , 但是在应用于网络应用开发的过程中,直接使用JDK提供的API, 比较繁琐。而且要想将性能进行提升, 光有NIO还不够, 还需要将多线程技术与之结合起来。
因为网络编程本身的复杂性, 以及JDK API开发的使用难度较高, 所以在开源社区中, 涌出来很多对JDK NIO 进行封装、增强后的网络编程框架, 例如: Netty、Mina 等。
AIO网络编程
- 服务器端:AsynchronousServerSocketChannel
- 客户端:AsynchronousSocketChannel
- 处理逻辑:实现CompletionHandler接口
AIO缺点:
- 实现复杂;
- Selector空轮询的bug;
- 可靠性差;
Netty
Netty是一个高性能、可扩展性的异步事件驱动的网络应用程序框架,它极大简化了TCP和UDP客户端和服务器开发等网络编程。
Netty重要的四个内容:
- Reactor线程模型:一种高性能的多线程程序设计思路
- Netty中自己定义的Channel概念:增强版的通道概念
- ChannelPipeline职责链设计模式:事件处理机制
- 内存管理:增强的ByteBuf缓冲区
Netty线程模型
为了让NIO更好的利用多线程特性,Netty实现了Reactor线程模型。
Reactor模型的四个核心概念:
- Resources资源(请求/任务)
- Synchronous Event Demutiplexer同步事件复用器
- Dispatcher分配器
- Request Handler请求处理器
EventLoopGroup初始化过程
EventLoop的启动
EventLoop自身实现了Executor接口,当调用executor方法提交任务时,则判断是否启动,未启动则调用内置的executor创建新线程来触发run方法执行。
Bind绑定端口的过程
Netty中的Channel概念
Netty中的Channel是一个抽象的概念,可以理解为对JDK NIO Channel的增强和扩展。增加了很多属性和方法。