原文转载：Netty介绍及NIO详解_dzyls的笔记-CSDN博客
目录
Netty的介绍
netty概念
- netty是一个Java开源框架，现为github上的独立项目
- netty是一个异步、基于事件驱动的网络应用框架，用于快速开发高性能、高可靠性的网络IO程序，就是对原生JavaIO优化和重写
- netty主要针对在TCP协议下，面向Clients端的高并发应用，或者Peer-to-Peer场景下的大量数据持续传输的应用
- netty本质是一个NIO框架，适用于服务器通讯相关的多种应用场景
- 总结一下，就是在TCP/IP协议下，上面覆盖着Java原生IO，再包裹着NIO网络开发，这些基础上才是netty
名词概念
- 事件驱动：netty会根据客户端的行为，产生相应的事件驱动，简单理解就是做了一些操作，调用某些方法，客户端发送请求，服务端可能会调用方法做相应处理；
- 异步：异步不需要等到响应回来，浏览器就可以去做别的事情，b/s架构中的异步主要通过ajax来实现，通过里面回调函数来处理响应后的数据，就是这么理解，不需要等你响应数据，浏览器直接做其他操作，等你数据响应回来之后直接被回调函数进行处理
- 同步：b/s架构中，请求发出去，等到响应回来之后，才能做下面的工作
netty应用场景
- 分布式节点中分布式系统远程服务调用，作为高性能的通信框架，作为基础通信组件被RPC框架使用
- 典型的阿里分布式框架使用Dubbo协议，默认使用netty作为基础通信组件，用于实现各节点之间的通信
- 游戏行业，高性能的通讯组件
I/O模型基本说明
I/O模型基本说明
就是用什么样的通道进行数据的发送和接收，很大程度上决定了程序通信的性能
Java共支持的3种网络编程模型I/O模式：
BIO、NIO、AIO
JavaBIO(Java原生IO)
同步阻塞(传统阻塞型)，这里的阻塞指的是如果没有读到数据，会阻塞在函数或者方法那里，服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销，Java BIO 就是传统的java io 编程，其相关的类和接口在 java.io
模型示意图
缺点：如果有多个客户端的话，意味着服务器端有很多线程，线程是有开销的，以及线程间的切换。链接建立起来后，如果不进行通讯的话，服务端也要维护这个线程。
Java NIO
同步非阻塞，服务器实现模式为一个线程处理多个请求(连接)，或者说多个客户端，即客户端发送的连接请求都会注册到多路复用器(简单理解为选择器)上，多路复用器轮询到连接有I/O请求就进行处理 。
简单示意图
特点：
哪有I/O请求就连接哪边客户端，体现了事件驱动；
单一一个线程进行处理多个客户端与服务器读写操作，体现了多路复用。
问题：
一个线程能够维护多少个连接，肯定是有上限的，一般实现多个线程维护多个连接，具体实现如下：
Java AIO(NIO.2)
异步非阻塞，AIO 引入异步通道的概念，采用了 Proactor 模式，简 化了程序编写，有效的请求才启动线程，它的特点是先由操作系统完成后才通知服务端程序启动线程去处理，一般用于连接数较多且时间比较长的应用。（简单介绍，不是重点，记住netty5.x是基于他实现的，但是效果不是很好，就将其Netty5.x作废了。因为Linux系统本身的原因）
BIO、NIO、AIO适用场景分析
BIO方式适用于连接数目比较小且固定的架构，这种方式对服务器资源要求比较高，并发局限于应用中，JDK1.4以前的唯一选择，但程序简单易理解。
NIO方式适用于连接数目多且连接比较短(轻操作)的架构，比如聊天服务器，弹幕系统，服务器间通讯等，编程比较复杂，JDK1.4开始支持。
AIO方式适用于连接数目多且连接比较长(重操作)的架构，比如相册服务器，充分调用OS参与并发操作，编程比较复杂，JDK7开始支持。
I/O介绍
Java BIO工作机制
简单流程
- 服务器端启动一个ServerSocket
- 客户端启动Socket对服务器进行通讯，默认情况下，服务器端需要对每个请求(客户端)建立一个线程与之通讯
- 客户端发出请求后，先咨询服务器是否有线程响应，如果没有则会等待，或者被拒绝
- 如果有线程响应，客户端线程会等待请求结束后，才继续执行，就是一个请求一个请求进行执行，是同步阻塞型编程模式
应用案例
实例说明(主要验证有一个连接就启动一个线程)：
- 使用BIO模型编写一个服务器端，监听6666端口，当有客户端连接时，就启动一个线程与之进行通讯；
- 要求使用线程池机制改善，可以连接多个客户端；
- 服务器端可以接收客户端发送的数据；
代码
public class BIOServer {
public static void main(String[] args) throws IOException {
//线程池机制
//思路
//1.创建一个线程池
//2.如果有客户端连接，就创建一个线程与之通讯(单独写一个方法)
//创建线程池
ExecutorService newCachedThreadPool = Executors.newCachedThreadPool();
//创建ServerSocket 分配了一个端口，这里理解为服务端
ServerSocket serverSocket = new ServerSocket(6666);
System.out.println("服务器启动了");
//这个循环是为了有客户端进行连接的话，进行连接
while (true){
//监听 等待客户端连接 定义为final类型的 让他不可更改
//这里面socket就是用来跟客户端通讯的
//accept会发生阻塞，如果连接不到客户端的话
final Socket socket = serverSocket.accept();
System.out.println("连接到一个客户端");
//创建一个线程与之通讯
newCachedThreadPool.execute(new Runnable() {
public void run() {
//可以和客户端通讯
handler(socket);
}
});
}
}
//编写一个handler方法，和客户端通讯
//拿到socket来进行通讯
public static void handler(Socket socket){
//接收数据
byte[] bytes = new byte[1024];
//通过socket 获取输入流,通过输入流可以读取到管道中的数据
try {
InputStream inputStream = socket.getInputStream();
//循环读取客户端发送的数据，这里面循环就是为了循环读数据
while (true){
//讲数据读取到数组中，返回的值为读取的数据量，到底读了多少数据
int read = inputStream.read(bytes);
//在这边没有读到数据，应该发生阻塞了
if (read != -1){
//说明还有数据要读
//输出客户端发送的数据，因为数据在数组中，再转化为字符串
String str = new String(bytes, 0, read);
System.out.println(str);
}else{
break;
}
}
} catch (IOException e) {
e.printStackTrace();
}finally {
System.out.println("关闭client的连接");
try {
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}结果展示
一个线程对应这个一个客户端
总结
-
每个请求都需要创建独立的线程，与对应的客户端进行数据read，业务处理，数据write
-
当并发数较大时，需要创建大量线程来处理连接，系统资源占用较大
-
连接建立后，如果当前线程暂时没有数据可读，则线程就阻塞在read操作上，造成线程资源浪费，没有数据读取的话，服务器可以去做其他的事情
Java NIO介绍
-
Java NIO 全称java non-blocking IO，是指JDK提供的新API，从JDK1.4开始，Java提供了一系列改进的输入/输出的新特性，被统称为NIO(即NEW IO)，是同步非阻塞的
-
NIO相关类都被放在java.nio包及子包下，并且对原java.io包中的很多类进行改写
-
NIO有三大核心部分：Channel(通道，相当于BIO里面的socket)，Buffer(缓冲区)，Selector(选择器)
-
NIO是面对缓冲区，或者面向块编程的，数据读取到一个稍后处理的缓冲区，需要时可在缓冲区中前后移动，这就增加了处理过程中的灵活性，使用它可以提供非阻塞式的高伸缩性网络，通过缓冲区实现了非阻塞的机制
-
Java NIO的非阻塞模式，使一个线程从某个通道发送请求或者读取数据，但是它仅能得到目前可用的数据，如果目前没有数据可用时，就什么都不会获取，而不是保持线程阻塞，所以直至数据变得可以读取之前，该线程可以继续做其他的事情。非阻塞写也是如此，一个线程请求写入一些数据到某通道，但不需要等待它完全写入，这个线程同时可以去做别的事情。就是哪个通道发生了selector关心的事件，就是处理哪个通道的事情(读，写，连接)；
-
通俗理解：NIO是可以做到用一个线程来处理多个操作的。假设有10000个请求过来，根据实际情况，可以分配50或者100个线程来处理，不像之前的阻塞IO那样，非得分配10000个
-
HTTP2.0使用了多路复用的技术，做到同一个连接并发处理多个请求，而且并发请求的数量比HTTP1.1大了好几个数量级；
简单示意图
简单示例
public class basicBuffer {
public static void main(String[] args) {
//举例说明Buffer的使用
//创建一个Buffer,大小为5，即可以存放5个int
IntBuffer intBuffer = IntBuffer.allocate(5);
//向buffer中存放数据
for (int i = 0; i < intBuffer.capacity(); i++) {
intBuffer.put(i*2);
}
//如何从buffer中读取数据
//将buffer转换，读写切换,就是刚刚写进去了，现在要读了，进行转换
intBuffer.flip();
//判断里面是否有剩余的
while (intBuffer.hasRemaining()){
//每get一次，索引往后移一次
System.out.println(intBuffer.get());
}
}
}NIO和BIO的比较
- BIO以流的方式处理数据，而NIO以块的方式处理数据，块I/O的效率比流I/O高很多
- BIO是阻塞的,NIO则是非阻塞的
- BIO基于字节流和字符流进行操作，而NIO基于Channel(通道)和Buffer(缓冲区)进行操作，数据总是从通道读取到缓冲区中，或者从缓冲区写入到通道中；
Selector(选择器)用于监听多个通道的事件(比如：连接请求，数据到达等)，因此使用单个线程就可以监听多个客户端通道
NIO三大核心组件的关系
示意图
Selector、Channel和Buffer的关系说明：
- 每个Channel都对应一个Buffer
- 一个Selector都会对应一个线程
- 一个线程都会对应多个Channel(连接)
- 上图反映了，有三个Channel注册到了该Selector
- 程序切换到哪个Channel是由事件决定的,Event是一个很重要的概念
- Selector会根据不同的事件在各个通道上切换
- Buffer就是一个内存块，底层是有一个数组
- 数据的读取写入是通过Buffer，这个和BIO有本质区别，BIO中要么是输入流或者是输出流，不能是双向的，但是NIO的Buffer是可以读也可以写，需要flip方法进行切换
- Channel是双向的，可以返回底层操作系统的情况，比如Linux底层操作系统通道就是双向的
缓冲区Buffer
基本介绍
缓冲区(Buffer):缓冲区本质上是一个可以读写数据的内存块，可以理解成一个容器对象(含数组)，该对象提供了一组方法，可以更轻松地使用内存块，缓冲区对象内置了一些机制，能够跟踪和记录缓冲区的状态变化情况。Channel提供从文件、网络读取数据的渠道，但是读取或写入的数据都必须经由Buffer，如图
友情提示：Buffer内部存在一些机制,能够跟踪和记录缓冲区的状态变化情况。Channel就是渠道，可以想象，网络传输的二进制流，就是人，Channel就是到目的的一种方式如水路，空中飞行，大路（在网络中就是相当于协议如WS协议，http协议），这个buffer就是交通工具，轮船，飞机，汽车。
public abstract class IntBuffer
extends Buffer
implements Comparable<IntBuffer>
{
// These fields are declared here rather than in Heap-X-Buffer in order to
// reduce the number of virtual method invocations needed to access these
// values, which is especially costly when coding small buffers.
//
final int[] hb; // Non-null only for heap buffers
final int offset;
boolean isReadOnly; Buffer部分源码，可以看到IntBuffer底层包含数组，也是通过int数组进行存取数据的
Buffer 类及其子类
1）buffer 则用来缓冲读写数据，常见的 buffer 有，除了Boolean类型其他类型都有：
将各个类型的数据存储到缓冲区中
- ByteBuffer
- MappedByteBuffer
- DirectByteBuffer
- HeapByteBuffer
- ShortBuffer
- IntBuffer
- LongBuffer
- FloatBuffer
- DoubleBuffer
- CharBuffer
2）Buffer类定义了所有的缓冲区都具有的四个属性来提供关于其所包含的数据元素的信息：
public abstract class Buffer {
/**
* The characteristics of Spliterators that traverse and split elements
* maintained in Buffers.
*/
static final int SPLITERATOR_CHARACTERISTICS =
Spliterator.SIZED | Spliterator.SUBSIZED | Spliterator.ORDERED;
// Invariants: mark <= position <= limit <= capacity
private int mark = -1;
private int position = 0;
private int limit;
private int capacity;| 属性 | 描述 |
| Capacity | 容量，即可以容纳的最大数据量，在缓冲区创建时被设定并且不能改变 |
| Limit | 表示缓冲区的当前终点，不能对缓冲区超过极限的位置进行读写操作，且极限是可以修改的 |
| Position | 位置，下一个要读或写的元素的索引，每次读写缓冲区数据时都会改变该值，为下次读写作准备 |
| Mark | 标记 |
- capacity()：相当于数组给的初始容量，始终不变的
- position()：相当于一个指针，不断的移动，初始值为0
- limit()：指针移动的极限位置，也就是写入的数据的最终的位置。
- mark():表示标记，给某一个位置加上标记，可以让其指定在指定的位置，不断的从标记位读取数据，初始值为-1
示例代码debug
- 创建缓冲区的时候
- 读入数据的时候
当输入到最后的时候，会发现position和limit值是一样的，不能超过limit值
- flip方法
public final Buffer flip() {
limit = position;//读到哪就设定到哪，limit设为这个值
position = 0;//position置为0
mark = -1;
return this;
}读取数据的时候，position也是继续一个一个移动
3）Buffer类相关方法
ByteBuffer
从前面可以看出对于Java中的基本数据类型(boolean除外)，都有一个Buffer类型与之相对应，最常用的自然是ByteBuffer类(二进制数据)，该类的主要方法如下：
通道(Channel)
基本介绍
1）NIO的通道类似于流，但是有些区别如下：
- 通道可以同时进行读写，而流只能读或者只能写
- 通道可以实现异步读写数据
- 通道可以从缓冲读数据，也可以写数据到缓冲
2）BIO中的stream是单向的，例如FileInputStream对象只能进行读取数据的操作，而NIO中的通道(Channel)是双向的，可以读操作，也可以写操作
3）Channel在NIO中国是一个接口 public interface Channel extends Closeable{}
4）常用的Channel类有：FileChannel、DatagramChannel、ServerSocketChannel和SocketChannel
5）FileChannel用于文件的数据读写，DatagramChannel用于UDP的数据读写，ServerSocketChannel和socketChannel用于TCP的数据读写
常见的 Channel
- FileChannel ：专门读取文件的
- DatagramChannel ：专门用于UDP的
- SocketChannel：对应网络传输的客户端，用于TCP的
- ServerSocketChannel：：对应网络传输的服务端，用于TCP的
FIleChannel类
FileChannel主要用来对本地文件进行I/O操作，常见的方法有
- public int read(ByteBuffer dst),从通道读取数据并放到缓冲区中
- public int write(ByteBuffer src),把缓冲区的数据写到通道中
- public long transferFrom(ReadableByteChannel src,long position,long count),从目标通道中复制数据到当前通道
- public long transferTo(long position,long count,WritableByteChannel target),把数据从当前通道复制给目标通道
实例1-本地文件写数据:
1) 使用前面学习后的ByteBuffer(缓冲) 和 FileChannel(通道)， 将 "hello,尚硅谷" 写入 到file01.txt 中
2) 文件不存在就创建
代码展示
public class NIOFileChannel01 {
public static void main(String[] args) throws Exception{
String str = "hello 尚硅谷";
//创建一个输出流，后面这个输出流会包装到channel里面去
FileOutputStream fileOutputStream = new FileOutputStream("D:\\temp\\file01.txt");
//通过获取对应的文件FileChannel,真实类型是FileChannelImpl
FileChannel fileChannel = fileOutputStream.getChannel();
//创建一个缓冲区ByteBuffer
ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
//将str放入到缓冲区中
byteBuffer.put(str.getBytes());
//对byteBuffer进行flip，因为之前不是写了吗，position指到limit了，现在要读就需要翻转
byteBuffer.flip();
//将byteBuffer数据写入到fileChannel
fileChannel.write(byteBuffer);
fileOutputStream.close();
}
}debug
运行到put方法的时候，6个字母+3个汉字9个字节，共15个字节
翻转之后，position变为0，limit变为15
fileOutPutStream里面包含的fileChannelImpl
实现过程
实例2-本地文件读数据:
1) 使用前面学习后的ByteBuffer(缓冲) 和 FileChannel(通道)， 将 file01.txt 中的数据读 入到程序，并显示在控制台屏幕
2) 假定文件已经存在
代码展示
public class NIOFileChannel02 {
public static void main(String[] args) throws Exception{
//创建文件的输入流
File file = new File("D:\\temp\\file01.txt");
FileInputStream fileInputStream = new FileInputStream(file);
//通过fileInputStream 获取对应的FileChannel，实际类型FileChannelImpl
FileChannel fileChannel = fileInputStream.getChannel();
//创建缓冲区
ByteBuffer byteBuffer = ByteBuffer.allocate((int) file.length());
//将通道的数据读入到buffer中
fileChannel.read(byteBuffer);
//将缓冲区的字节转换为字符串
System.out.println(new String(byteBuffer.array()));
fileInputStream.close();
}
}整体思路：
实例3-使用一个buffer完成文件读取和写入
之前两个示例是分别用两个buffer进行读和写
- 使用FileChannel(通道)和方法read,write,完成文件的拷贝
- 拷贝一个文本文件1.txt，放在项目下即可
代码演示
public class NIOFIleChannel03 {
public static void main(String[] args) throws Exception{
File file = new File("D:\\temp\\file02.txt");
File file01 = new File("D:\\temp\\file03.txt");
FileInputStream fileInputStream = new FileInputStream(file);
FileOutputStream fileOutputStream = new FileOutputStream(file01);
FileChannel fileChannel01 = fileInputStream.getChannel();
FileChannel fileChannel02 = fileOutputStream.getChannel();
ByteBuffer byteBuffer = ByteBuffer.allocate((int) file.length());
fileChannel01.read(byteBuffer);
byteBuffer.flip();
fileChannel02.write(byteBuffer);
fileInputStream.close();
fileOutputStream.close();
}
}这里面没有考虑到万一数据超过1024的话，超过部分是没有办法拷贝的
其实我这里应该也可以的吧，因为我分配的缓存区的长度就是文件的长度
另一种代码展示
public class NIOFIleChannel03 {
public static void main(String[] args) throws Exception{
File file = new File("D:\\temp\\file02.txt");
File file01 = new File("D:\\temp\\file03.txt");
FileInputStream fileInputStream = new FileInputStream(file);
FileOutputStream fileOutputStream = new FileOutputStream(file01);
FileChannel fileChannel01 = fileInputStream.getChannel();
FileChannel fileChannel02 = fileOutputStream.getChannel();
ByteBuffer byteBuffer = ByteBuffer.allocate((int) file.length());
while (true){
//清空buffer，主要是将position清0，要不然一直和limit相等，这两个值相同的话，read值为0，导致后面循环无法结束
byteBuffer.clear();
// public final Buffer clear() {
// position = 0;
// limit = capacity;
// mark = -1;
// return this;
// }
int read = fileChannel01.read(byteBuffer);
if (read == -1){
break;
}
byteBuffer.flip();
fileChannel02.write(byteBuffer);
}
fileInputStream.close();
fileOutputStream.close();
}
}直接封装好的文件复制方法
package com.atguigu.nio;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.nio.channels.FileChannel;
public class NIOFileChannel04 {
public static void main(String[] args) throws Exception {
//创建相关流
FileInputStream fileInputStream = new FileInputStream("d:\\a.jpg");
FileOutputStream fileOutputStream = new FileOutputStream("d:\\a2.jpg");
//获取各个流对应的filechannel
FileChannel sourceCh = fileInputStream.getChannel();
FileChannel destCh = fileOutputStream.getChannel();
//使用transferForm完成拷贝
destCh.transferFrom(sourceCh,0,sourceCh.size());
//关闭相关通道和流
sourceCh.close();
destCh.close();
fileInputStream.close();
fileOutputStream.close();
}
}实例5
友情提示：transferTo的使用效率高，底层会利用操作系统的零拷贝进行优化, 这个方法一次只能传递2g内存 数据
package cn.itcast.nio.c3;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.channels.FileChannel;
public class TestFileChannelTransferTo {
public static void main(String[] args) {
try (
FileChannel from = new FileInputStream("data.txt").getChannel();
FileChannel to = new FileOutputStream("to.txt").getChannel();
) {
// 效率高，底层会利用操作系统的零拷贝进行优化, 这个方法一次只能传递2g内存 数据
long size = from.size();
// left 变量代表还剩余多少字节
for (long left = size; left > 0; ) {
System.out.println("position:" + (size - left) + " left:" + left);
// 下面的方式可以传递多次，
left -= from.transferTo((size - left), left, to);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}关于Buffer 和 Channel的注意事项和细节
- ByteBuffer支持类型化的put和get，put放入的室什么数据类型，get就应该使用相应的数据类型来取出，否则可能有BufferUnderflowException异常
- 可以将一个普通Buffer转成只读Buffer
- NIO还提供了MappedByteBuffer，可以让文件直接在内存(堆外的内存)中进行修改，操作系统不需要拷贝一次，而如何同步到文件有NIO来完成
- 前面我们讲的读写操作，都是通过一个Buffer完成的，NIO还支持通过多个Buffer(即Buffer数组)完成读写操作，即Scattering和Gathering
MappedByteBuffer
- 友情提示：代码执行完成，在idea中查看数据是没有改变的。到电脑的文件的管理系统，去查看，里面的数据是改变。
- NIO 还提供了 MappedByteBuffer， 可以让文件直接在内存（堆外的内存）中进 行修改， 而如何同步到文件由NIO来完成，少了一次拷贝，注意这里是5 的含义，最多只能修改5个字节
package com.atguigu.nio;
import java.io.RandomAccessFile;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
/*
说明
1. MappedByteBuffer 可让文件直接在内存(堆外内存)修改, 操作系统不需要拷贝一次
*/
public class MappedByteBufferTest {
public static void main(String[] args) throws Exception {
RandomAccessFile randomAccessFile = new RandomAccessFile("1.txt", "rw");
//获取对应的通道
FileChannel channel = randomAccessFile.getChannel();
/**
* 参数1: FileChannel.MapMode.READ_WRITE 使用的读写模式
* 参数2： 0 ： 可以直接修改的起始位置
* 参数3: 5: 是映射到内存的大小(不是索引位置) ,即将 1.txt 的多少个字节映射到内存
* 可以直接修改的范围就是 0-5，需要注意不包含5
* 实际类型 DirectByteBuffer
*/
MappedByteBuffer mappedByteBuffer = channel.map(FileChannel.MapMode.READ_WRITE, 0, 15);
//把第一个位置改为大写H，依此类推
mappedByteBuffer.put(0, (byte) 'H');
mappedByteBuffer.put(3, (byte) '9');
mappedByteBuffer.put(14, (byte) 'Y');//IndexOutOfBoundsException
randomAccessFile.close();
System.out.println("修改成功~~");
}
}Scattering 和 Gathering
NIO 还支持 通过多个 Buffer (即 Buffer 数组) 完成读写操作，主要就是对应的Channle的read和write方法内部参数可以使Buffer数组对象
- Scattering：将数据写入到buffer时，可以采用buffer数组，依次写入 [分散]
- Gathering: 从buffer读取数据时，可以采用buffer数组，依次读
package com.atguigu.nio;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Arrays;
/**
* Scattering：将数据写入到buffer时，可以采用buffer数组，依次写入 [分散]
* Gathering: 从buffer读取数据时，可以采用buffer数组，依次读
*/
public class ScatteringAndGatheringTest {
public static void main(String[] args) throws Exception {
//使用 ServerSocketChannel 和 SocketChannel 网络
ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
InetSocketAddress inetSocketAddress = new InetSocketAddress(7000);
//绑定端口到socket ，并启动
serverSocketChannel.socket().bind(inetSocketAddress);
//创建buffer数组
ByteBuffer[] byteBuffers = new ByteBuffer[2];
byteBuffers[0] = ByteBuffer.allocate(5);
byteBuffers[1] = ByteBuffer.allocate(3);
//等客户端连接(telnet)
SocketChannel socketChannel = serverSocketChannel.accept();
int messageLength = 8; //假定从客户端接收8个字节
//循环的读取
while (true) {
int byteRead = 0;
while (byteRead < messageLength ) {
// 从客户端读数据
long l = socketChannel.read(byteBuffers);
byteRead += l; //累计读取的字节数
System.out.println("byteRead=" + byteRead);
//使用流打印, 看看当前的这个buffer的position 和 limit
Arrays.asList(byteBuffers).stream().map(buffer -> "postion=" + buffer.position() + ", limit=" + buffer.limit()).forEach(System.out::println);
}
//将所有的buffer进行flip
Arrays.asList(byteBuffers).forEach(buffer -> buffer.flip());
//将数据读出显示到客户端
long byteWirte = 0;
while (byteWirte < messageLength) {
long l = socketChannel.write(byteBuffers); //
byteWirte += l;
}
//将所有的buffer 进行clear
Arrays.asList(byteBuffers).forEach(buffer-> {
buffer.clear();
});
System.out.println("byteRead:=" + byteRead + " byteWrite=" + byteWirte + ", messagelength" + messageLength);
}
}
}结果显示
203
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
