java io nio socket_通过socket编程掌握IO流 —— NIO

最新推荐文章于 2022-12-24 17:37:58 发布
最新推荐文章于 2022-12-24 17:37:58 发布
阅读量118 收藏
点赞数
文章标签： java io nio socket
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39662142/article/details/114524229
版权

一、本次目标

改造server，采用NIO读取client信息；

改造client，亦采用NIO发送消息，与之前不同的BIO形成对比；

二、编码

1、新建byte数组拼接公共类

主要用作在channel读取数据时，因为缓存大小的原因，很可能出现中文半包(一个汉字的byte处在两次读取的buffer缓冲区中)而导致乱码；

package com.cjt.io;

public class CommonUtil {

/**

* byte数组拼接

*/

public static byte[] concat(byte[] first, byte[] second) {

byte[] result = new byte[first.length + second.length];

System.arraycopy(first, 0, result, 0, first.length);

System.arraycopy(second, 0, result, first.length, second.length);

return result;

}

}

2、提取channel缓存读取byte数组

便于server和client公共调用相同的代码实现；

package com.cjt.io.nio;

import com.cjt.io.CommonUtil;

import java.io.IOException;

import java.nio.ByteBuffer;

import java.nio.channels.SocketChannel;

class ChannelHandler {

static byte[] readFromChannel(SocketChannel channel, int buffSize) throws IOException {

// 创建缓存区

ByteBuffer buffer = ByteBuffer.allocate(buffSize);

byte[] result = {};

while ((channel.read(buffer)) != -1) {

// 切换为写模式，buffer的position置为0

buffer.flip();

// 读取buffer有效数据

byte[] bytes = new byte[buffer.limit()];

buffer.get(bytes, 0, bytes.length);

// 数组拼接

result = CommonUtil.concat(result, bytes);

// 清空缓存区

buffer.clear();

}

return result;

}

}

3、修改server，采用NIO机制读取client消息

需要添加selector进行管理channel，无限轮询就绪的channel主要分为两部分，首先需要将自己的serverChannel注册到selector中，同时获取对应clientChannel，设置相关参数也要注册到selector中；

package com.cjt.io.nio;

import com.cjt.io.Config;

import com.cjt.io.DateUtil;

import java.io.IOException;

import java.net.InetSocketAddress;

import java.nio.ByteBuffer;

import java.nio.channels.SelectionKey;

import java.nio.channels.Selector;

import java.nio.channels.ServerSocketChannel;

import java.nio.channels.SocketChannel;

import java.util.Set;

public class ServerNIO implements Config {

private Selector selector;

private ServerNIO(int port) {

try {

// 创建选择器

selector = Selector.open();

// 打开监听通道

ServerSocketChannel channel;

channel = ServerSocketChannel.open();

// 非阻塞模式

channel.configureBlocking(false);

// 绑定端口

channel.socket().bind(new InetSocketAddress(port));

// 将channel注册到selector中，并且“兴趣模式”为“accept”

channel.register(selector, SelectionKey.OP_ACCEPT);

System.out.println("[" + DateUtil.getCurTimeStr() + "]:服务端已经启动");

} catch (IOException e) {

e.printStackTrace();

}

}

private void start() {

while (true) {

try {

// select方法会阻塞当前线程

System.out.println("[" + DateUtil.getCurTimeStr() + "]:开始轮询获取就绪的channel");

int readyChannels = selector.select();

if (readyChannels == 0) continue;

System.out.println("[" + DateUtil.getCurTimeStr() + "]:有chanel就绪啦");

Set keySet = selector.selectedKeys();

for (SelectionKey key : keySet) {

// 删除正在处理的key

keySet.remove(key);

if (key.isValid()) {

// 可接受的(server注册的key)

if (key.isAcceptable()) {

// 获取注册的server服务端channel通道

ServerSocketChannel serverSocketChannel = (ServerSocketChannel) key.channel();

// 获取连接的client客户端channel通道

SocketChannel socketChannel = serverSocketChannel.accept();

System.out.println("[" + DateUtil.getCurTimeStr() + "]:有新的客户端连接啦");

// 设置client的channel为非阻塞

socketChannel.configureBlocking(false);

// 注册当前clientChannel到selector中，并设置clientChannel为可读

socketChannel.register(selector, SelectionKey.OP_READ);

System.out.println();

}

// 可读的(client注册的key)

if (key.isReadable()) {

SocketChannel socketChannel = (SocketChannel) key.channel();

byte[] result = ChannelHandler.readFromChannel(socketChannel, 1024);

String resultStr = new String(result, DEFAULT_ENCODE);

System.out.println("[" + DateUtil.getCurTimeStr() + "]:client传来消息");

System.out.println(resultStr);

System.out.println();

socketChannel.shutdownInput();

System.out.println("[" + DateUtil.getCurTimeStr() + "]:server写入消息");

System.out.println(resultStr);

System.out.println();

ByteBuffer buffer = ByteBuffer.wrap(result);

socketChannel.write(buffer);

// 当前channel操作完毕后一定要执行清除操作

key.cancel();

socketChannel.close();

}

}

}

} catch (IOException e) {

e.printStackTrace();

break;

}

}

}

public static void main(String[] args) {

new ServerNIO(DEFAULT_PORT).start();

}

}

其实现在我们可以用上一篇中的ClientBIO来测试，照例先启动server，然后运行client的main方法；

client控制台：

[19:53:50]:连接server成功

[19:53:50]:连接server成功

[19:53:51]:client写入消息

我是第二个客户端

[19:53:53]:client写入消息

我是第一个客户端

[19:53:53]:server传来消息

我是第一个客户端

[19:53:53]:server传来消息

我是第二个客户端

server控制台：

[19:53:15]:服务端已经启动

[19:53:15]:开始轮询获取就绪的channel

[19:53:50]:有chanel就绪啦

[19:53:50]:有新的客户端连接啦

[19:53:50]:开始轮询获取就绪的channel

[19:53:50]:有chanel就绪啦

[19:53:50]:有新的客户端连接啦

[19:53:50]:开始轮询获取就绪的channel

[19:53:50]:有chanel就绪啦

[19:53:53]:client传来消息

我是第一个客户端

[19:53:53]:server写入消息

我是第一个客户端

[19:53:53]:开始轮询获取就绪的channel

[19:53:53]:有chanel就绪啦

[19:53:53]:client传来消息

我是第二个客户端

[19:53:53]:server写入消息

我是第二个客户端

[19:53:53]:开始轮询获取就绪的channel

这里说个细节，仅仅server实现NIO，client相当于发起连接在server中就一直处于就绪状态，因而会造成阻塞，并且while循环读取数据时会无限循环直到client关闭socket流。如果操作ByteBuffer读取全部很容易造成OOM。

结合起来看很能发现问题：

client中两个连接server是同时的，但是server中可以看到一个是50秒，一个是53秒；

server中第一个就绪的channel连接在50秒，然后在53秒才打印出client的消息；

server中接受client还是阻塞的；

所以仅仅是server实现NIO是不行的。

4、修改client实现NIO编程

这里简单处理，client收发消息都是单线程，就不需要采用selector进行管理；

package com.cjt.io.nio;

import com.cjt.io.Config;

import com.cjt.io.DateUtil;

import java.io.IOException;

import java.net.InetSocketAddress;

import java.nio.ByteBuffer;

import java.nio.channels.SocketChannel;

public class ClientNIO implements Config, Runnable {

private String serverIp;

private int port;

private String msg;

private int second;

private ClientNIO(String serverIp, int port) {

this.serverIp = serverIp;

this.port = port;

}

private ClientNIO second(int second) {

this.second = second;

return this;

}

private ClientNIO msg(String msg) {

this.msg = msg;

return this;

}

private void sleep(int second) {

try {

Thread.sleep(second * 1000);

} catch (InterruptedException e) {

e.printStackTrace();

}

}

@Override

public void run() {

try (SocketChannel channel = SocketChannel.open()) {

if (channel.connect(new InetSocketAddress(serverIp, port))) {

System.out.println("[" + DateUtil.getCurTimeStr() + "]:连接server成功");

channel.configureBlocking(false);

byte[] bytes = msg.getBytes(DEFAULT_ENCODE);

ByteBuffer buffer = ByteBuffer.allocate(bytes.length);

buffer.put(bytes);

buffer.flip();

sleep(second);

System.out.println("[" + DateUtil.getCurTimeStr() + "]:client写入消息");

System.out.println(msg);

channel.write(buffer);

channel.shutdownOutput();

byte[] result = ChannelHandler.readFromChannel(channel, 1024 * 1024);

String resultStr = new String(result, DEFAULT_ENCODE);

System.out.println("[" + DateUtil.getCurTimeStr() + "]:server传来消息");

System.out.println(resultStr);

System.out.println();

} else {

System.out.println("[" + DateUtil.getCurTimeStr() + "]:连接server失败");

}

} catch (IOException e) {

e.printStackTrace();

}

}

public static void main(String[] args) {

ClientNIO client_1 = new ClientNIO(DEFAULT_ADDR, DEFAULT_PORT).second(3).msg("我是第一个客户端");

new Thread(client_1).start();

ClientNIO client_2 = new ClientNIO(DEFAULT_ADDR, DEFAULT_PORT).second(1).msg("我是第二个客户端");

new Thread(client_2).start();

}

}

基本步骤和server大同小异，那么我们再次测试看看；

client控制台：

[20:08:38]:连接server成功

[20:08:38]:连接server成功

[20:08:39]:client写入消息

我是第二个客户端

[20:08:39]:server传来消息

我是第二个客户端

[20:08:41]:client写入消息

我是第一个客户端

[20:08:41]:server传来消息

我是第一个客户端

server控制台：

[20:08:30]:服务端已经启动

[20:08:30]:开始轮询获取就绪的channel

[20:08:38]:有chanel就绪啦

[20:08:38]:有新的客户端连接啦

[20:08:38]:开始轮询获取就绪的channel

[20:08:38]:有chanel就绪啦

[20:08:38]:有新的客户端连接啦

[20:08:38]:开始轮询获取就绪的channel

[20:08:39]:有chanel就绪啦

[20:08:39]:client传来消息

我是第二个客户端

[20:08:39]:server写入消息

我是第二个客户端

[20:08:39]:开始轮询获取就绪的channel

[20:08:41]:有chanel就绪啦

[20:08:41]:client传来消息

我是第一个客户端

[20:08:41]:server写入消息

我是第一个客户端

[20:08:41]:开始轮询获取就绪的channel

client输出的没有任何变化，但是server就不一样了。server是在39秒也就是client在第一个写入消息时并不是连接server的时间，提示有就绪的channel，然后打印的也是“我是第二个客户端”。然后在41秒时再次提示有个就绪的channel，打印“我是第一个客户端”。Perfect！！我们要达到的不就是这种效果么(～￣▽￣)～

三、总结

相对传统的BIO，NIO的确要复杂不少，但是在高并发上效率要高得多。简单总结下server实现NIO的步骤：

创建selector选择器；

打开监听通道，设置为非阻塞，绑定好端口；

注册监听通道到之前的selector中，设置模式为“ACCEPT”；

编写主无限循环体，执行selector.select()阻塞线程获取就绪的channel；

轮询就绪的SelectionKey，如果模式为“ACCEPT”说明是server的channel，获取连接server的client的channel，设置为非阻塞“READ”模式，并注册到selector中；如果模式为“READ”则说明是client的channel，直接创建ByteBuffer缓存区读取数据，一定要记得key.cancel()和socketChannel.close()；

client实现NIO与server相差无几，只不过我这里简单处理做成单线程，实际上大多数的client还是需要加入selector监听通道，因为单独的读取和写入应该分为不同的线程处理。

从channel读取数据时，一定要注意读取的是有效数据，所以要好好掌握ByteBuffer的使用方法。

weixin_39662142
关注
nio.rar_NIO_NIO-socket_java nio_java 实例_java.nio
09-19
标题“nio.rar_NIO_NIO-socket_java nio_java 实例_java.nio”表明这个压缩包包含了一个关于Java NIO的实例，特别是关于NIO套接字（Socket）的编程示例。NIO套接字是Java NIO库中用于网络通信的关键组件，它们允许...
Java中的网络编程：从Socket到NIO
最新发布
微赚淘客开发者博客
07-30 688
今天我们来探讨Java中的网络编程，从基础的Socket编程到更高级的NIO（New Input/Output）编程。本文介绍了Java中的网络编程，从基础的Socket编程到高级的NIO编程。对于小规模、低并发的应用，可以使用简单的Socket编程。对于高并发、大数据量的应用，建议使用NIO。NIO由于采用了非阻塞IO和基于通道的模型，可以更好地支持高并发的网络应用，尤其适合大型服务器应用。NIO的编程模型比传统IO复杂，需要处理通道、选择器和缓冲区，但它提供了更高的灵活性和性能。语句可以简化资源管理。
Java Socket实现NIO通信
在路上
12-24 2485
手写NIO通信,其实并不复杂
ByteBuffer用法小结
热门推荐
mars5337的专栏
06-30 17万+
 在NIO中,数据的读写操作始终是与缓冲区相关联的.读取时信道(SocketChannel)将数据读入缓冲区,写入时首先要将发送的数据按顺序填入缓冲区.缓冲区是定长的,基本上它只是一个列表,它的所有元素都是基本数据类型.ByteBuffer是最常用的缓冲区,它提供了读写其他数据类型的方法,且信道的读写方法只接收ByteBuffer.因此ByteBuffer的用法是有必要牢固掌握的.1.创建
ByteBuffer的allocate()方法详解
weixin_44400390的博客
06-28 2万+
ByteBuffer的allocate()方法详解 allocate()方法用于分配缓冲区。但是如果是聚集写入,与分散读取,就需要注意这个大小设置, String property = System.getProperty("user.dir"); FileOutputStream FileOutputStream = new FileOutputStream(property ...
java nio socket,Java----NioSocket的简单使用
weixin_39585974的博客
03-19 601
一、自己理解的概念nioSocket(即new io socket)是一种同步非阻塞的I/O，其使用buffer来缓存数据和channel来传输数据，使用select来分拣消息。其使用的ServerSocketChannel和SocketChannel对应于之前学习的ServerSocket和Socket。在我看的书(《看透Spring MVC源代码分析与实践》)中形容为：当今的快递物流，现实中的...
nio.rar_Java socketA_java nio_java socket a
09-24
标题中的“Java socketA_java nio_java socket a”可能是指使用Java NIO实现的Socket通信，这里的"A"可能是表示"Advanced"或"Alternative"，意味着比传统的阻塞I/O模型更为高级或替代方案。 在Java Socket API中，...
Java源码：Socket编程.rar_java socket _java编程_socket java_socket编程 jav
07-13
本资料包含的"Java源码：Socket编程"是一个示例，旨在帮助开发者理解并掌握Java中的Socket编程技术。 首先，Socket编程涉及的主要类有`ServerSocket`和`Socket`。`ServerSocket`类用于创建服务器端的监听套接字，它...
TCP-socket.zip_java_java Tcp _java socket _socket_socket多线程
09-20
此外，还能了解如何使用Java的IO或NIO（非阻塞I/O）进行数据的读写，以及如何通过异常处理来保证程序的健壮性。对于想要从事网络编程或者服务器开发的Java程序员来说，这些都是必备的基础知识。
nio socket编程java代码示例，客户端发送消息，服务端接收
01-12
通过以上代码，我们构建了一个基于Java NIO的Socket通信示例。客户端发送"Hello, Server!"，服务器接收到消息后将其打印出来。这个基础架构可以扩展到更复杂的网络应用，例如聊天服务器、文件传输等。NIO的优势在于...
NIO与传统IO的区别
周宏亮G的日志
06-26 5万+
 传统的socket IO中，需要为每个连接创建一个线程，当并发的连接数量非常巨大时，线程所占用的栈内存和CPU线程切换的开销将非常巨大。使用NIO，不再需要为每个线程创建单独的线程，可以用一个含有限数量线程的线程池，甚至一个线程来为任意数量的连接服务。由于线程数量小于连接数量，所以每个线程进行IO操作时就不能阻塞，如果阻塞的话，有些连接就得不到处理，NIO提供了这种非阻塞的能力。 小
【网络编程socket】java NIO编程示例以及流程详解
m0_45406092的博客
12-18 1144
参考： 《java NIO示例以及流程详解》
Java Nio实现socket读写文件
dongsheng186的专栏
06-17 470
http://blog.csdn.net/a15937712253/article/details/37914569 服务器端 [java] view plaincopy package com.nio;      import java.io.IOException;   import java.net.InetSock
NIO的网络IO操作
逆流而上的博客
01-28 6895
一、网络IO 1.1 概述 文件IO用到的FileChannel并不支持非阻塞操作，学习NIO主要就是进行网络IO，JavaNIO中的网络通道是非阻塞10的实现，基于事件驱动，非常适用于服务器需要维持大量连接，但是数据交换量不大的情况，例如一些即时通信的服务等… 在Java中编写Socket服务器，通常有以下几种模式: 一个客户 端连接用一个线程，优点:程序编写简单;缺点:如果连接非常多，分配的...
java socket 缓冲_Java nio 笔记：系统IO、缓冲区、流IO、socket通道
weixin_31270363的博客
02-12 393
一、Java IO 和 系统 IO 不匹配在大多数情况下，Java 应用程序并非真的受着 I/O 的束缚。操作系统并非不能快速传送数据，让 Java 有事可做；相反，是 JVM 自身在 I/O 方面效率欠佳。操作系统与 Java 基于流的 I/O模型有些不匹配。操作系统要移动的是大块数据(缓冲区)，这往往是在硬件直接存储器存取(DMA)的协助下完成的。而 JVM 的 I/O 操作类喜欢操作小块数据...
java io socket_JAVA IO总结及socket简单实现
weixin_30043179的博客
02-12 405
为了方便理解与阐述，先引入两张图：a、Java IO中常用的类在整个Java.io包中最重要的就是5个类和一个接口。5个类指的是File、OutputStream、InputStream、Writer、Reader；一个接口指的是Serializable.掌握了这些IO的核心操作那么对于Java中的IO体系也就有了一个初步的认识了Java I/O主要包括如下几个层次，包含三个部分：1.流式部分――...
Java网络编程：IO，NIO与Netty
闫玉林的博客
06-16 560
新公司新项目，项目需要在硬件和软件平台进行信息传递，具体来说使用Netty。硬件和软件使用socket连接，硬件作为客户端，软件平台作为服务的，使用TCP/IP通信。接着这个机会把Java IO和Netty重新学习了一下，总结在这里，不准确或错误的地方，欢迎指出来。对于Java IO，可以分为同步与异步，也可以分为阻塞与非阻塞，下面对这些概念进行解释：reactor 模型：非阻塞同步网络模型，NIO使用的模型，事件分离器负责等待文件描述符或socket为读写操作准备就绪，然后将就绪事件传递给对应的处理器，最
Java NIO Socket编程：客户端与服务端消息通信示例
资源摘要信息: "本文详细介绍了Java NIO socket编程的基本知识，提供...以上就是Java NIO socket编程的相关知识点和代码示例，通过这些示例，可以进一步了解NIO的非阻塞IO模型以及如何在Java中进行基于NIO的网络通信。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值