网络编程
Socket网络编程
Socket概述
Socket，套接字就是两台主机之间逻辑连接的端点。TCP/IP协议是传输层协议，主要解决数据如何在网络中传输，而HTTP是应用层协议，主要解决如何包装数据。Socket是通信的基石，是支持TCP/IP协议的网络通信的基本操作单元。它是网络通信过程中端点的抽象表示，包含进行网络通信必须的五种信息：连接使用的协议、本地主机的IP地址、本地进程的协议端口、远程主机的IP地址、远程进程的协议端口。
Socket整体流程
Socket编程主要涉及到客户端和服务端两个方面，首先是在服务器端创建一个服务器套接字（ServerSocket），并把它附加到一个端口上，服务器从这个端口监听连接。端口号的范围是0到65536，0到1024是为特权服务保留的端口号，可以选择任意一个当前没有被其他进程使用的端口。
客户端请求与服务器进行连接的时候，根据服务器的域名或者IP地址，加上端口号，打开一个套接字。当服务器接受连接后，服务器和客户端之间的通信就像输入输出流一样进行操作。
代码实现
服务端代码
package com.ajie.server;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.nio.charset.StandardCharsets;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* @author ajie
* @description: TODO
*/
public class ServerDemo {
public static void main(String[] args) throws IOException {
// 1.创建一个线程池,如果有客户端连接就创建一个线程, 与之通信
ExecutorService executorService = Executors.newCachedThreadPool();
// 2.创建 ServerSocket 对象
ServerSocket serverSocket = new ServerSocket(9999);
System.out.println("服务器已启动");
while (true){
Socket socket = serverSocket.accept();
// 3.监听客户端
System.out.println("有客户端连接");
//4.开启新的线程处理
executorService.execute(new Runnable() {
@Override
public void run() {
handle(socket);
}
});
}
}
private static void handle(Socket socket) {
try {
System.out.println("线程id："+Thread.currentThread().getId()+
"，线程名称："+Thread.currentThread().getName());
// 从连接中取出输入流来接收消息
InputStream is = socket.getInputStream();
byte[] b = new byte[1024];
int read = is.read(b);
System.out.println("客户端："+new String(b,0,read));
// 连接中取出输出流并回话
OutputStream os = socket.getOutputStream();
os.write("没钱".getBytes(StandardCharsets.UTF_8));
} catch (Exception e) {
e.printStackTrace();
}finally {
try {
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
客户端代码
package com.ajie.client;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.nio.charset.StandardCharsets;
import java.util.Scanner;
/**
* @author ajie
* @description: TODO
*/
public class ClientDemo {
public static void main(String[] args) throws IOException {
// 1.创建 Socket 对象
Socket socket = new Socket("127.0.0.1", 9999);
// 2.从连接中取出输出流并发消息
OutputStream os = socket.getOutputStream();
System.out.println("请输入:");
Scanner scanner = new Scanner(System.in);
String msg = scanner.nextLine();
os.write(msg.getBytes(StandardCharsets.UTF_8));
// 3.从连接中取出输入流并接收回话
InputStream is = socket.getInputStream();
byte[] b = new byte[1024];
int read = is.read(b);
System.out.println("老板说：" + new String(b, 0, read));
socket.close();
}
}
I/O模型
I/O模型说明
I/O 模型简单的理解：就是用什么样的通道进行数据的发送和接收，很大程度上决定了程序通信的性能
Java 共支持 3 种网络编程模型/IO 模式：BIO(同步并阻塞)、NIO(同步非阻塞)、AIO(异步非阻塞)
-
阻塞与非阻塞
主要指的是访问IO的线程是否会阻塞（或处于等待）线程访问资源，该资源是否准备就绪的一种处理方式
-
同步和异步
主要是指的数据的请求方式 同步和异步是指访问数据的一种机制
BIO(同步并阻塞)
Java BIO就是传统的 socket编程.
BIO(blocking I/O) ： 同步阻塞，服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销，可以通过线程池机制改善(实现多个客户连接服务器)。
工作机制
生活中的例子:
BIO问题分析
- 每个请求都需要创建独立的线程，与对应的客户端进行数据 Read，业务处理，数据 Write
- 并发数较大时，需要创建大量线程来处理连接，系统资源占用较大
- 连接建立后，如果当前线程暂时没有数据可读，则线程就阻塞在 Read 操作上，造成线程资源浪费
NIO(同步非阻塞)
同步非阻塞，服务器实现模式为一个线程处理多个请求(连接)，即客户端发送的连接请求都会注册到多路复用器上，多路复用器轮询到连接有 I/O 请求就进行处理
生活中的例子:
AIO(异步非阻塞)
AIO 引入异步通道的概念，采用了 Proactor 模式，简化了程序编写，有效的请求才启动线程，它的特点是先由操作系统完成后才通知服务端程序启动线程去处理，一般适用于连接数较多且连接时间较长的应用
Proactor 模式是一个消息异步通知的设计模式，Proactor 通知的不是就绪事件，而是操作完成事件，这也就是操作系统异步 IO 的主要模型
生活中的例子:
BIO、NIO、AIO适用场景分析:
- BIO(同步并阻塞) 方式适用于连接数目比较小且固定的架构，这种方式对服务器资源要求比较高，并发局限于应用中，JDK1.4以前的唯一选择，但程序简单易理解
- NIO(同步非阻塞) 方式适用于连接数目多且连接比较短（轻操作）的架构，比如聊天服务器，弹幕系统，服务器间通讯等。编程比较复杂，JDK1.4 开始支持
- AIO(异步非阻塞) 方式使用于连接数目多且连接比较长（重操作）的架构，比如相册服务器，充分调用 OS 参与并发操作， 编程比较复杂，JDK7 开始支持。
NIO编程
NIO介绍
Java NIO 全称java non-blocking IO ，是指 JDK 提供的新 API。从 JDK1.4 开始，Java 提供了一系列改进的输入/输出的新特性，被统称为 NIO(即 New IO)，是同步非阻塞的.
- NIO 有三大核心部分：Channel(通道)，Buffer(缓冲区), Selector(选择器)
- NIO是 面向缓冲区编程的。数据读取到一个缓冲区中，需要时可在缓冲区中前后移动，这就增加了处理过程中的灵活性，使用它可以提供非阻塞式的高伸缩性网络
- Java NIO 的非阻塞模式，使一个线程从某通道发送请求或者读取数据，但是它仅能得到目前可用的数据，如果目前没有数据可用时，就什么都不会获取，而不是保持线程阻塞，所以直至数据变的可以读取之前，该线程可以继续做其他的事情。 非阻塞写也是如此，一个线程请求写入一些数据到某通道，但不需要等待它完全写入， 这个线程同时可以去做别的事情。通俗理解：NIO 是可以做到用一个线程来处理多个操作的。假设有 10000 个请求过来,根据实际情况，可以分配50 或者 100 个线程来处理。不像之前的阻塞 IO 那样，非得分配 10000 个
NIO三大核心原理示意图
一张图描述 NIO 的 Selector 、 Channel 和 Buffer 的关系
- 每个 channel 都会对应一个 Buffer
- Selector 对应一个线程， 一个线程对应多个 channel(连接)
- 每个 channel 都注册到 Selector选择器上
- Selector不断轮询查看Channel上的事件, 事件是通道Channel非常重要的概念
- Selector 会根据不同的事件，完成不同的处理操作
- Buffer 就是一个内存块 ， 底层是有一个数组
- 数据的读取写入是通过 Buffer, BIO 中要么是输入流，或者是输出流, 不能双向，但是NIO 的 Buffer 是可以读也可以写 , channel 是双向的.
NIO和BIO的比较
- BIO 以流的方式处理数据,而 NIO 以缓冲区的方式处理数据,缓冲区 I/O 的效率比流 I/O 高很多
- BIO 是阻塞的，NIO则是非阻塞的
- BIO 基于字节流和字符流进行操作，而 NIO 基于 Channel(通道)和 Buffer(缓冲区)进行操作，数据总是从通道读取到缓冲区中，或者从缓冲区写入到通道中。Selector(选择器)用于监听多个通道的事件（比如：连接请求， 数据到达等），因此使用单个线程就可以监听多个客户端通道
缓冲区(Buffer)
基本介绍
缓冲区（Buffer）：缓冲区本质上是一个可以读写数据的内存块，可以理解成是一个数组，该对象提供了一组方法，可以更轻松地使用内存块，缓冲区对象内置了一些机制，能够跟踪和记录缓冲区的状态变化情况。Channel 提供从网络读取数据的渠道，但是读取或写入的数据都必须经由 Buffer.
Buffer常用API介绍
-
Buffer 类及其子类
在 NIO 中，Buffer是一个顶层父类，它是一个抽象类, 类的层级关系图,常用的缓冲区分别对应byte,short, int, long,float,double,char 7种.
-
缓冲区对象创建
方法名 说明 static ByteBuffer allocate(长度) 创建byte类型的指定长度的缓冲区 static ByteBuffer wrap(byte[] array) 创建一个有内容的byte类型缓冲区 示例代码:
package com.ajie.buffer; import java.nio.ByteBuffer; /** * @author ajie * @description: 创建缓冲区 */ public class CreateBufferDemo { public static void main(String[] args) { // 1.创建一个指定长度的缓冲区，以byteBuffer为例 ByteBuffer byteBuffer = ByteBuffer.allocate(5); for (int i = 0; i < 5; i++) { System.out.println(byteBuffer.get()); } // 在此调用会报错--后续再读缓冲区时着重讲解 // System.out.println(byteBuffer.get()); // 2.创建一个有内容的缓冲区 ByteBuffer wrap = ByteBuffer.wrap("ajie".getBytes()); for (int i = 0; i < 4; 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) 添加一个字节/添加字节数组 图解:
package com.ajie.buffer; import java.nio.ByteBuffer; import java.nio.charset.StandardCharsets; /** * @author ajie * @description: TODO */ public class PutBuffer { public static void main(String[] args) { // 1.创建一个指定长度的缓冲区, 以ByteBuffer为例 ByteBuffer byteBuffer = ByteBuffer.allocate(10); System.out.println(byteBuffer.position()); // 获取当前索引所在位置 0 System.out.println(byteBuffer.limit()); // 最多能操作到哪个索引 10 System.out.println(byteBuffer.capacity()); // 返回缓冲区总长度 10 System.out.println(byteBuffer.remaining()); // 还有多少个能操作 10 /*System.out.println("---------------------"); // 修改当前索引位置 byteBuffer.position(1); // 修改最多能操作到哪个索引位置 byteBuffer.limit(9); System.out.println(byteBuffer.position()); // 获取当前索引所在位置 1 System.out.println(byteBuffer.limit()); // 最多能操作到哪个索引 9 System.out.println(byteBuffer.capacity()); // 返回缓冲区总长度 10 System.out.println(byteBuffer.remaining()); // 还有多少个能操作 8*/ System.out.println("------------------"); // 添加一个字节 byteBuffer.put((byte) 97); System.out.println(byteBuffer.position()); // 获取当前索引所在位置 1 System.out.println(byteBuffer.limit()); // 最多能操作到哪个索引 10 System.out.println(byteBuffer.capacity()); // 返回缓冲区总长度 10 System.out.println(byteBuffer.remaining()); // 还有多少个能操作 9 System.out.println("------------------"); // 添加一个字节数组 byteBuffer.put("abc".getBytes(StandardCharsets.UTF_8)); System.out.println(byteBuffer.position()); // 获取当前索引所在位置 4 System.out.println(byteBuffer.limit()); // 最多能操作到哪个索引 10 System.out.println(byteBuffer.capacity()); // 返回缓冲区总长度 10 System.out.println(byteBuffer.remaining()); // 还有多少个能操作 6 System.out.println("------------------"); // 当添加超过缓冲区的长度时会报错 byteBuffer.put("123456".getBytes(StandardCharsets.UTF_8)); System.out.println(byteBuffer.position()); // 获取当前索引所在位置 10 System.out.println(byteBuffer.limit()); // 最多能操作到哪个索引 10 System.out.println(byteBuffer.capacity()); // 返回缓冲区总长度 10 System.out.println(byteBuffer.remaining()); // 还有多少个能操作 0 System.out.println(byteBuffer.hasRemaining()); // 是否还能有操作的数组 false System.out.println("------------------"); // 如果缓存区存满后, 可以调整position位置可以重复写,这样会覆盖之前存入索引的对应的值 byteBuffer.position(0); byteBuffer.put("012345".getBytes(StandardCharsets.UTF_8)); } } -
缓冲区对象读取数据
方法名 介绍 flip() 写切换读模式 limit设置position位置, position设置0 get() 读一个字节 get(byte[] dst) 读多个字节 get(int index) 读指定索引的字节 rewind() 将position设置为0，可以重复读 clear() 切换写模式 position设置为0 , limit 设置为 capacity array() 将缓冲区转换成字节数组返回 图解:flip()方法
图解:clear()方法
实例代码:
package com.ajie.buffer; import java.nio.ByteBuffer; import java.nio.charset.StandardCharsets; /** * @author ajie * @description: TODO */ public class GetBufferDemo { public static void main(String[] args) { // 创建一个指定长度的缓冲区 ByteBuffer allocate = ByteBuffer.allocate(10); allocate.put("0123".getBytes(StandardCharsets.UTF_8)); 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());//0 System.out.println("limit:" + allocate.limit());//4 System.out.println("capacity:" + allocate.capacity());//10 System.out.println("remaining:" + allocate.remaining());//4 for (int i = 0; i < allocate.limit(); i++) { System.out.println(allocate.get()); } // 读取完毕后.继续读取会报错,超过limit值 // System.out.println(allocate.get()); // 读取指定索引字节 System.out.println("读取指定索引字节--------------"); System.out.println(allocate.get(1)); System.out.println("读取多个字节--------------"); // 重复读取 allocate.rewind(); byte[] bytes = new byte[4]; 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(StandardCharsets.UTF_8)); System.out.println(new String(allocate.array())); } }
注意事项:
- capacity：容量（长度）limit： 界限（最多能读/写到哪里）posotion：位置（读/写哪个索引）
- 获取缓冲区里面数据之前，需要调用flip方法
- 再次写数据之前，需要调用clear方法，但是数据还未消失，等再次写入数据，被覆盖了才会消失。
通道(Channel)
基本介绍
通常来说NIO中的所有IO都是从 Channel（通道） 开始的。NIO 的通道类似于流，但有些区别如下：
- 通道可以读也可以写，流一般来说是单向的（只能读或者写，所以之前我们用流进行IO操作的时候需要分别创建一个输入流和一个输出流）
- 通道可以异步读写
- 通道总是基于缓冲区Buffer来读写
Channel常用类介绍
-
Channel接口
常 用 的Channel实现类类 有 ：FileChannel , DatagramChannel ,ServerSocketChannel和SocketChannel 。FileChannel 用于文件的数据读写， DatagramChannel 用于 UDP 的数据读写， ServerSocketChannel 和SocketChannel 用于 TCP 的数据读写。【ServerSocketChanne类似ServerSocket , SocketChannel类似Socket】
-
SocketChannel 与ServerSocketChannel
类似 Socke和ServerSocket,可以完成客户端与服务端数据的通信工作.
ServerSocketChannel
服务端实现步骤:
- 打开一个服务端通道
- 绑定对应的端口号
- 通道默认是阻塞的，需要设置为非阻塞
- 检查是否有客户端连接 有客户端连接会返回对应的通道
- 获取客户端传递过来的数据,并把数据放在byteBuffer这个缓冲区中
- 给客户端回写数据
- 释放资源
代码实现:
package com.ajie.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;
import java.util.concurrent.TimeUnit;
/**
* @author ajie
* @description: TODO
*/
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("没有客户端连接......处理别的业务");
TimeUnit.SECONDS.sleep(2);
continue;
}
// 5. 获取客户端传递过来的数据,并把数据放在byteBuffer这个缓冲区中
ByteBuffer buffer = ByteBuffer.allocate(1024);
// 返回值:
// 正数: 表示本次读到的有效字节个数.
// 0 : 表示本次没有读到有效字节.
//-1 : 表示读到了末尾
int read = socketChannel.read(buffer);
System.out.println("客户端消息：" + new String(buffer.array(), 0, read));
// 6. 给客户端回写数据
socketChannel.write(ByteBuffer.wrap("没钱".getBytes(StandardCharsets.UTF_8)));
// 7. 释放资源
socketChannel.close();
}
}
}
SocketChannel
实现步骤
- 打开通道
- 设置连接IP和端口号
- 写出数据
- 读取服务器写回的数据
- 释放资源
代码实现:
package com.ajie.channel;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;
import java.nio.charset.StandardCharsets;
/**
* @author ajie
* @description: TODO
*/
public class NIOClient {
public static void main(String[] args) throws IOException {
// 1. 打开通道
SocketChannel socketChannel = SocketChannel.open();
// 2. 设置连接IP和端口号
socketChannel.bind(new InetSocketAddress("127.0.0.1",9999));
// 3. 写出数据
socketChannel.write(ByteBuffer.wrap("老板, 该还钱拉!".getBytes(StandardCharsets.UTF_8)));
// 4. 读取服务器写回的数据
ByteBuffer buffer = ByteBuffer.allocate(1024);
int read = socketChannel.read(buffer);
System.out.println("服务端消息："+new String(buffer.array(),0,read));
// 5. 释放资源
socketChannel.close();
}
}
Selector (选择器)
基本介绍
可以用一个线程，处理多个的客户端连接，就会使用到NIO的Selector(选择器). Selector 能够检测多个注册的服务端通道上是否有事件发生，如果有事件发生，便获取事件然后针对每个事件进行相应的处理。这样就可以只用一个单线程去管理多个通道，也就是管理多个连接和请求。
在这种没有选择器的情况下,对应每个连接对应一个处理线程.但是连接并不能马上就会发送信息,所以还会产生资源浪费
只有在通道真正有读写事件发生时，才会进行读写，就大大地减少了系统开销，并且不必为每个连接都创建一个线程，不用去维护多个线程,避免了多线程之间的上下文切换导致的开销
常用API介绍
-
Selector 类是一个抽象类
常用方法:
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 —— 写就绪事件，表示已经可以向通道写数据了（通道目前可以用于写操作）
- 常用方法
Selector编码
服务端实现步骤:
- 打开一个服务端通道
- 绑定对应的端口号
- 通道默认是阻塞的，需要设置为非阻塞
- 创建选择器
- 将服务端通道注册到选择器上,并指定注册监听的事件为OP_ACCEPT
- 检查选择器是否有事件
- 获取事件集合
- 判断事件是否是客户端连接事件SelectionKey.isAcceptable()
- 得到客户端通道,并将通道注册到选择器上, 并指定监听事件为OP_READ
- 判断是否是客户端读就绪事件SelectionKey.isReadable()
- 得到客户端通道,读取数据到缓冲区
- 给客户端回写数据
- 从集合中删除对应的事件, 因为防止二次处理.
代码实现:
package com.ajie.selector;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.nio.charset.StandardCharsets;
import java.util.Iterator;
import java.util.Set;
/**
* @author ajie
* @description: TODO
*/
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.println("服务端启动成功");
while (true) {
// 6. 检查选择器是否有事件
int select = selector.select(2000);
if (select == 0) {
continue;
}
// 7. 获取事件集合
Set<SelectionKey> selectionKeys = selector.selectedKeys();
Iterator<SelectionKey> iterator = selectionKeys.iterator();
while (iterator.hasNext()) {
SelectionKey key = iterator.next();
// 8. 判断事件是否是客户端连接事件SelectionKey.isAcceptable()
if (key.isAcceptable()) {
// 9. 得到客户端通道,并将通道注册到选择器上, 并指定监听事件为OP_READ
SocketChannel socketChannel = serverSocketChannel.accept();
System.out.println("客户端已连接......" + socketChannel);
// 必须设置通道为非阻塞, 因为selector需要轮询监听每个通道的事件
socketChannel.configureBlocking(false);
// 并指定监听事件为OP_READ
socketChannel.register(selector, SelectionKey.OP_READ);
}
// 10. 判断是否是客户端读就绪事件SelectionKey.isReadable()
if (key.isReadable()) {
// 11. 得到客户端通道,读取数据到缓冲区
SocketChannel socketChannel = (SocketChannel) key.channel();
ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
int read = socketChannel.read(byteBuffer);
if (read > 0) {
System.out.println("客户端：" + new String(byteBuffer.array(), 0, read));
// 12. 给客户端回写数据
socketChannel.write(ByteBuffer.wrap("没钱！".getBytes(StandardCharsets.UTF_8)));
socketChannel.close();
}
}
// 13. 从集合中删除对应的事件, 因为防止二次处理.
iterator.remove();
}
}
}
}
扫一扫
1551
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
