RPC框架设计

在网络中传输，而 HTTP 是应用层协议，主要解决如何包装数据。 Socket 是通信的基石，是支持 TCP/IP 协议的网络通信的基本操作单元。它是网络通信过程中端点的抽象表示，包含进行网络通信必须的五种信息：连接使用的协议、本地主机的 IP 地址、本地进程的协议端口、远程主机的 IP 地址、远程进程的协议端口。

2. Socket整体流程

Socket 编程主要涉及到客户端和服务端两个方面，首先是在服务器端创建一个服务器套接字

（ ServerSocket ），并把它附加到一个端口上，服务器从这个端口监听连接。端口号的范围是 0 到

65536 ，但是 0 到 1024 是为特权服务保留的端口号，可以选择任意一个当前没有被其他进程使用的端口。

客户端请求与服务器进行连接的时候，根据服务器的域名或者 IP 地址，加上端口号，打开一个套接

字。当服务器接受连接后，服务器和客户端之间的通信就像输入输出流一样进行操作。

3. 代码实现

socket编程案例完整代码（请点击）

（二）I/O模型

1. I/O模型说明

（1）. I/O 模型简单的理解：就是用什么样的通道进行数据的发送和接收，很大程度上决定了程序通信的性能

（2）. Java 共支持 3 种网络编程模型 /IO 模式： BIO( 同步并阻塞 ) 、 NIO( 同步非阻塞 ) 、 AIO( 异步非阻塞 )

阻塞与非阻塞

主要指的是访问 IO 的线程是否会阻塞（或处于等待）

线程访问资源，该资源是否准备就绪的一种处理方式

同步和异步

主要是指的数据的请求方式

同步和异步是指访问数据的一种机制

2. BIO(同步并阻塞)

Java BIO 就是传统的 socket 编程 .

BIO(blocking I/O) ：同步阻塞，服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销，可以通过线程池机制改善 ( 实现多个客户连接服务器 ) 。

工作机制

生活中的例子:

BIO问题分析

（1）. 每个请求都需要创建独立的线程，与对应的客户端进行数据 Read ，业务处理，数据 Write

（2）. 并发数较大时，需要创建大量线程来处理连接，系统资源占用较大

（3）. 连接建立后，如果当前线程暂时没有数据可读，则线程就阻塞在 Read 操作上，造成线程资源浪费

3. NIO(同步非阻塞)

同步非阻塞，服务器实现模式为一个线程处理多个请求 ( 连接 ) ，即客户端发送的连接请求都会注册到多路复用器上，多路复用器轮询到连接有 I/O 请求就进行处理。

生活中的例子 :

4. AIO(异步非阻塞)

AIO 引入异步通道的概念，采用了 Proactor 模式，简化了程序编写，有效的请求才启动线程，它的特点是先由操作系统完成后才通知服务端程序启动线程去处理，一般适用于连接数较多且连接时间较长的应用

Proactor 模式是一个消息异步通知的设计模式， Proactor 通知的不是就绪事件，而是操作完成事件，这也就是操作系统异步 IO 的主要模型。

生活中的例子 :

5. BIO、NIO、AIO 适用场景分析

（1）. BIO( 同步并阻塞 ) 方式适用于连接数目比较小且固定的架构，这种方式对服务器资源要求比较高，

并发局限于应用中， JDK1.4 以前的唯一选择，但程序简单易理解

（2）. NIO( 同步非阻塞 ) 方式适用于连接数目多且连接比较短（轻操作）的架构，比如聊天服务器，弹幕

系统，服务器间通讯等。编程比较复杂， JDK1.4 开始支持

（3）. AIO( 异步非阻塞 ) 方式使用于连接数目多且连接比较长（重操作）的架构，比如相册服务器，充分调用 OS 参与并发操作，编程比较复杂， JDK7 开始支持。

二. NIO编程

（一）NIO介绍

Java NIO 全称 java non-blocking IO ，是指 JDK 提供的新 API 。从 JDK1.4 开始， Java 提供了一系

列改进的输入 / 输出的新特性，被统称为 NIO( 即 New IO) ，是同步非阻塞的。

1. NIO 有三大核心部分： Channel( 通道 ) ， Buffer( 缓冲区 ), Selector( 选择器 )

2. NIO 是面向缓冲区编程的。数据读取到一个缓冲区中，需要时可在缓冲区中前后移动，这就增加了处理过程中的灵活性，使用它可以提供非阻塞式的高伸缩性网络

3. Java NIO 的非阻塞模式，使一个线程从某通道发送请求或者读取数据，但是它仅能得到目前可用的数据，如果目前没有数据可用时，就什么都不会获取，而不是保持线程阻塞，所以直至数据变的可以读取之前，该线程可以继续做其他的事情。非阻塞写也是如此，一个线程请求写入一些数据到某通道，但不需要等待它完全写入，这个线程同时可以去做别的事情。通俗理解： NIO 是可以做到用一个线程来处理多个操作的。假设有 10000 个请求过来 , 根据实际情况，可以分配 50 或者 100 个线程来处理。不像之前的阻塞 IO 那样，非得分配 10000 个。

（二）NIO和 BIO的比较

1. BIO 以流的方式处理数据 , 而 NIO 以缓冲区的方式处理数据 , 缓冲区 I/O 的效率比流 I/O 高很多

2. BIO 是阻塞的， NIO 则是非阻塞的

3. BIO 基于字节流和字符流进行操作，而 NIO 基于 Channel( 通道 ) 和 Buffer( 缓冲区 ) 进行操作，数据总是从通道读取到缓冲区中，或者从缓冲区写入到通道中。 Selector( 选择器 ) 用于监听多个通道的事件（比如：连接请求，数据到达等），因此使用单个线程就可以监听多个客户端通道。

（三）NIO 三大核心原理示意图

一张图描述 NIO 的 Selector 、 Channel 和 Buffer 的关系

1. 每个 channel 都会对应一个 Buffer

2. Selector 对应一个线程，一个线程对应多个 channel( 连接 )

3. 每个 channel 都注册到 Selector 选择器上

4. Selector 不断轮询查看 Channel 上的事件 , 事件是通道 Channel 非常重要的概念

5. Selector 会根据不同的事件，完成不同的处理操作

6. Buffer 就是一个内存块，底层是有一个数组

7. 数据的读取写入是通过 Buffer, 这个和 BIO , BIO 中要么是输入流，或者是输出流 , 不能双向，但是NIO 的 Buffer 是可以读也可以写 , channel 是双向的。

（四）缓冲区(Buffer)

1. 基本介绍

缓冲区（ Buffer ）：缓冲区本质上是一个可以读写数据的内存块，可以理解成是一个数组，该对象

提供了一组方法，可以更轻松地使用内存块，，缓冲区对象内置了一些机制，能够跟踪和记录缓冲区的状态变化情况。 Channel 提供从网络读取数据的渠道，但是读取或写入的数据都必须经由 Buffer。

2. Buffer常用API介绍

（1）. Buffer 类及其子类

在 NIO 中， Buffer 是一个顶层父类，它是一个抽象类 , 类的层级关系图 , 常用的缓冲区分别对应

byte,short, int, long,float,double,char 7 种 .

（2）缓冲区对象创建

示例代码 :

package com.lagou.buffer;

import java.nio.ByteBuffer;

/**
 * Buffer的创建
 */
public class CreateBufferDemo {
    public static void main(String[] args) {
        //1.创建指定长度的缓冲区  ByteBuffer为例
        ByteBuffer allocate = ByteBuffer.allocate(5);
        for (int i = 0; i < 5; i++) {
            System.out.println(allocate.get());//从缓冲区当中拿去数据
        }
        //会报错. 后续讲解
        //System.out.println(allocate.get());//从缓冲区当中拿去数据

        //2.创建一个有内容的缓冲区
        ByteBuffer wrap = ByteBuffer.wrap("lagou".getBytes());
        for (int i = 0; i < 5; i++) {
            System.out.println(wrap.get());
        }
    }
}

（3）缓冲区对象添加数据

图解:

示例代码:

package com.lagou.buffer;

import java.nio.ByteBuffer;

/**
 * 向缓冲区中添加数据
 */
public class PutBufferDemo {
    public static void main(String[] args) {
        //1.创建一个缓冲区
        ByteBuffer allocate = ByteBuffer.allocate(10);
        System.out.println(allocate.position());//0 获取当前索引所在位置
        System.out.println(allocate.limit());//10 最多能操作到哪个索引位置
        System.out.println(allocate.capacity());//10 返回缓冲区总长度
        System.out.println(allocate.remaining());//10 还有多少个可以操作的个数

        System.out.println("----------------");
        // 修改当前索引所在位置
        //allocate.position(1);
        // 修改最多能操作到哪个索引的位置
        //allocate.limit(9);
        // System.out.println(allocate.position());//1 获取当前索引所在位置
        //System.out.println(allocate.limit());//9 最多能操作到哪个索引位置
        //System.out.println(allocate.capacity());//10 返回缓冲区总长度
        //System.out.println(allocate.remaining());//8 还有多少个可以操作的个数

        // 添加一个字节
        allocate.put((byte) 97);
        System.out.println(allocate.position());//1 获取当前索引所在位置
        System.out.println(allocate.limit());//10 最多能操作到哪个索引位置
        System.out.println(allocate.capacity());//10 返回缓冲区总长度
        System.out.println(allocate.remaining());//9 还有多少个可以操作的个数

        System.out.println("----------------");
        // 添加一个数组
        allocate.put("abc".getBytes());
        System.out.println(allocate.position());//4 获取当前索引所在位置
        System.out.println(allocate.limit());//10 最多能操作到哪个索引位置
        System.out.println(allocate.capacity());//10 返回缓冲区总长度
        System.out.println(allocate.remaining());//6 还有多少个可以操作的个数
        System.out.println("----------------");
        // 添加一个数组
        allocate.put("123456".getBytes());
        System.out.println(allocate.position());//10 获取当前索引所在位置
        System.out.println(allocate.limit());//10 最多能操作到哪个索引位置
        System.out.println(allocate.capacity());//10 返回缓冲区总长度
        System.out.println(allocate.remaining());//0 还有多少个可以操作的个数
        System.out.println(allocate.hasRemaining());//false 是否还能操作
        System.out.println("----------------");
        //如果缓冲区满了. 可以调整position位置, 就可以重复写. 会覆盖之前存入索引位置的值
        allocate.position(0);
        allocate.put("123456".getBytes());
        System.out.println(allocate.position());//6 获取当前索引所在位置
        System.out.println(allocate.limit());//10 最多能操作到哪个索引位置
        System.out.println(allocate.capacity());//10 返回缓冲区总长度
        System.out.println(allocate.remaining());//4 还有多少个可以操作的个数
        System.out.println(allocate.hasRemaining());//true 是否还能操作

    }
}

（4）缓冲区对象读取数据

图解:flip()方法

图解:clear()方法

实例代码:

package com.lagou.buffer;

import java.nio.ByteBuffer;

/**
 * 从缓冲区中读取数据
 */
public class GetBufferDemo {
    public static void main(String[] args) {
        //1.创建一个指定长度的缓冲区
        ByteBuffer allocate = ByteBuffer.allocate(10);
        allocate.put("0123".getBytes());
        System.out.println("position:" + allocate.position());//4
        System.out.println("limit:" + allocate.limit());//10
        System.out.println("capacity:" + allocate.capacity());//10
        System.out.println("remaining:" + allocate.remaining());//6

        //切换读模式
        System.out.println("读取数据--------------");
        allocate.flip();
        System.out.println("position:" + allocate.position());//4
        System.out.println("limit:" + allocate.limit());//10
        System.out.println("capacity:" + allocate.capacity());//10
        System.out.println("remaining:" + allocate.remaining());//6
        for (int i = 0; i < allocate.limit(); i++) {
            System.out.println(allocate.get());
        }
        //读取完毕后.继续读取会报错,超过limit值
        //System.out.println(allocate.get());
        //读取指定索引字节
        System.out.println("读取指定索引字节是不需要去判断limit值的--------------");
        System.out.println(allocate.get(1));

        System.out.println("读取多个字节--------------");
        // 重复读取
        allocate.rewind();
        byte[] bytes = new byte[4];
        //通过这个get方法将内容读到数组
        allocate.get(bytes);
        System.out.println(new String(bytes));

        // 将缓冲区转化字节数组返回
        System.out.println("将缓冲区转化字节数组返回--------------");
        byte[] array = allocate.array();
        System.out.println(new String(array));

        // 切换写模式,覆盖之前索引所在位置的值
        System.out.println("写模式--------------");
        allocate.clear();
        allocate.put("abc".getBytes());
        System.out.println(new String(allocate.array()));

    }
}

注意事项:

1. capacity ：容量（长度） limit ：界限（最多能读 / 写到哪里） posotion ：位置（读 / 写

哪个索引）

2. 获取缓冲区里面数据之前，需要调用 flip 方法

3. 再次写数据之前，需要调用 clear 方法，但是数据还未消失，等再次写入数据，被覆盖了

才会消失。

（五）通道(Channel)

1. 基本介绍

通常来说NIO中的所有IO都是从 Channel（通道）开始的。NIO 的通道类似于流，但有些区别如下：

（1）. 通道可以读也可以写，流一般来说是单向的（只能读或者写，所以之前我们用流进行 IO 操作的时候

需要分别创建一个输入流和一个输出流）

（2）. 通道可以异步读写

（3）. 通道总是基于缓冲区 Buffer 来读写

2. Channel常用类介绍

（1）Channel接口

常用的 Channel 实现类类有： FileChannel , DatagramChannel ,ServerSocketChannel 和

SocketChannel 。 FileChannel 用于文件的数据读写， DatagramChannel 用于 UDP 的数据读

写， ServerSocketChannel 和 SocketChannel 用于 TCP 的数据读写。【 ServerSocketChanne

类似 ServerSocket , SocketChannel 类似 Socket 】

（2）SocketChannel 与ServerSocketChannel

类似 Socke和ServerSocket,可以完成客户端与服务端数据的通信工作.

3. 编写NIO ServerSocketChannel

服务端实现步骤:

1. 打开一个服务端通道

2. 绑定对应的端口号

3. 通道默认是阻塞的，需要设置为非阻塞

4. 检查是否有客户端连接有客户端连接会返回对应的通道

5. 获取客户端传递过来的数据 , 并把数据放在 byteBuffer 这个缓冲区中

6. 给客户端回写数据

7. 释放资源

代码实现 :

package com.lagou.channel;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.nio.charset.StandardCharsets;

/**
 * 服务端
 */
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("服务端启动成功....");
        while (true) {
            //4. 检查是否有客户端连接 有客户端连接会返回对应的通道
            SocketChannel socketChannel = serverSocketChannel.accept();
            if (socketChannel == null) {
                System.out.println("没有客户端连接...我去做别的事情");
                Thread.sleep(2000);
                continue;
            }
            //5. 获取客户端传递过来的数据,并把数据放在byteBuffer这个缓冲区中
            //5.1创建一个缓冲区
            ByteBuffer allocate = ByteBuffer.allocate(1024);
            //返回值
            //正数: 表示本地读到有效字节数
            //0: 表示本次没有读到数据
            //-1: 表示读到末尾
            int read = socketChannel.read(allocate);
            System.out.println("客户端消息:" + new String(allocate.array(), 0,
                    read, StandardCharsets.UTF_8));
            //6. 给客户端回写数据，创建一个有内容的缓存区，将其回写给客户端
            socketChannel.write(ByteBuffer.wrap("没钱".getBytes(StandardCharsets.UTF_8)));
            //7. 释放资源
            socketChannel.close();
        }
    }
}

4. 编写NIO SocketChannel

实现步骤

1. 打开通道

2. 设置连接 IP 和端口号

3. 写出数据

4. 读取服务器写回的数据

5. 释放资源

代码实现:

package com.lagou.channel;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;
import java.nio.charset.StandardCharsets;

/**
 * 客户端
 */
public class NIOClient {
    public static void main(String[] args) throws IOException {
        //1. 打开通道
        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 allocate = ByteBuffer.allocate(1024);
        int read = socketChannel.read(allocate);
        System.out.println("服务端消息:" +
                new String(allocate.array(), 0, read, StandardCharsets.UTF_8));
        //5. 释放资源
        socketChannel.close();
    }
}

（六） Selector (选择器)

1. 基本介绍

可以用一个线程，处理多个的客户端连接，就会使用到 NIO 的 Selector( 选择器 ). Selector 能够检测

多个注册的服务端通道上是否有事件发生，如果有事件发生，便获取事件然后针对每个事件进行相应的处理。这样就可以只用一个单线程去管理多个通道，也就是管理多个连接和请求。

在这种没有选择器的情况下 , 对应每个连接对应一个处理线程 . 但是连接并不能马上就会发送信息 , 所以还会产生资源浪费。

只有在通道真正有读写事件发生时，才会进行读写，就大大地减少了系统开销，并且不必为每个连接都创建一个线程，不用去维护多个线程 , 避免了多线程之间的上下文切换导致的开销。

2. 常用API介绍

（1）Selector 类是一个抽象类

常用方法:

Selector.open() : // 得到一个选择器对象

selector.select() : // 阻塞监控所有注册的通道 , 当有对应的事件操作时 , 会将 SelectionKey 放入

集合内部并返回事件数量

selector.select(1000): // 阻塞 1000 毫秒，监控所有注册的通道 , 当有对应的事件操作时 , 会将

SelectionKey 放入集合内部并返回

selector.selectedKeys() : // 返回存有 SelectionKey 的集合

（2）SelectionKey

常用方法：

SelectionKey.isAcceptable(): 是否是连接继续事件：（代表着客户端向服务端发起了一个连接时间）
SelectionKey.isConnectable(): 是否是连接就绪事件: (代表着客户端向服务端发起的连接已经就绪)
SelectionKey.isReadable()是否是读就绪事件
SelectionKey.isWritable(): 是否是写就绪事件

SelectionKey中定义的4种事件:

SelectionKey.OP_ACCEPT —— 接收连接继续事件，表示服务器监听到了客户连接，服务器可以接收这个连接了
SelectionKey.OP_CONNECT —— 连接就绪事件，表示客户端与服务器的连接已经建立成功
SelectionKey.OP_READ —— 读就绪事件，表示通道中已经有了可读的数据，可以执行读操作了（通道目前有数据，可以进行读操作了）
SelectionKey.OP_WRITE —— 写就绪事件，表示已经可以向通道写数据了（通道目前可以用于写操作）

3. Selector 编码

服务端实现步骤:

最低0.47元/天解锁文章

enterpc

关注

1
点赞
踩
4

收藏

觉得还不错? 一键收藏
打赏
0
评论
RPC框架设计

一. Socket回顾与I/0模型（一）Socket网络编程回顾 1. Socket概述Socket，套接字就是两台主机之间逻辑连接的端点。TCP/IP协议是传输层协议，主要解决数据如何在网络中传输，而HTTP是应用层协议，主要解决如何包装数据。Socket是通信的基石，是支持TCP/IP协议的网络通信的基本操作单元。它是网络通信过程中端点的抽象表示，包含进行网络通信必须的五种信息：连接使用的协议、本地主机的IP地址、本地进程的协议端口、远程主机的IP地址、远程进程的协议端口。2
复制链接

扫一扫