nio通信代码实例

最新推荐文章于 2024-01-09 17:39:57 发布
最新推荐文章于 2024-01-09 17:39:57 发布
阅读量241 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39327182/article/details/107252790
版权
本文通过实例代码展示了Java NIO在服务端和客户端的使用，包括服务端启动、客户端连接及双方的控制台输出结果。
摘要由CSDN通过智能技术生成

nio通信

服务端代码

package com.li.springboot.nio.server;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;

/**
 * nio通信服务端
 * @author 张宗海
 *
 */
public class NioServer {

	/**
	 * 接收
	 */
	public void accept(){
		try {
			//记录套接字通道事件
			Selector selector = Selector.open();
			//定义一个异步socket对象
			ServerSocketChannel ssc = ServerSocketChannel.open();
			ssc.configureBlocking(false);   //设置异步
			
			ServerSocket socket = ssc.socket();  //获取socket对象
			//绑定端口
			InetSocketAddress address = new InetSocketAddress(8083);
			socket.bind(address);
			//将事件注册selector对象内
			ssc.register(selector, SelectionKey.OP_ACCEPT);
			System.out.println("端口注册完毕!");
			
			while(true){
				//查询事件如果一个事件都没有就阻塞
	            selector.select();
	            //定义一个byte缓冲区来存储收发的数据
	            ByteBuffer echoBuffer=ByteBuffer.allocate(10);	            
	            //处理数据
	            this.accept(selector,echoBuffer);
			}
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
	/**
	 * 处理数据
	 * @param selector
	 * @param echoBuffer
	 */
	public void accept(Selector selector,ByteBuffer echoBuffer){
		SocketChannel sc;
		try{
			//此循环遍例所有产生的事件
	        for (SelectionKey key : selector.selectedKeys()){
	        	//如果产生的事件为接受客户端连接(当有客户端连接服务器的时候产生)
	        	if((key.readyOps()&SelectionKey.OP_ACCEPT)==SelectionKey.OP_ACCEPT){
	        		selector.selectedKeys().remove(key);
	                //定义一个服务器socket通道
	                ServerSocketChannel subssc=(ServerSocketChannel)key.channel();
	                //将临时socket对象实例化为接收到的客户端的socket
	                sc=subssc.accept();
	                //将客户端的socket设置为异步
	                sc.configureBlocking(false);
	                //将客户端的socket的读取事件注册到事件选择器中
	                sc.register(selector, SelectionKey.OP_READ);
	                //将本此事件从迭带器中删除
	                System.out.println("有新连接:"+sc);
	                
	            //如果产生的事件为读取数据(当已连接的客户端向服务器发送数据的时候产生)
	        	}else if((key.readyOps()&SelectionKey.OP_READ)==SelectionKey.OP_READ){
	        		//将本次事件删除
	                selector.selectedKeys().remove(key);
	                //临时socket对象实例化为产生本事件的socket
	                sc=(SocketChannel) key.channel();
	                //定义一个用于存储byte数据的流对象
	                ByteArrayOutputStream bos=new ByteArrayOutputStream();
	                //先将客户端的数据清空
	                echoBuffer.clear();
	                //a为读取到数据的长度
	                 try{
	                    //循环读取所有客户端数据到byte缓冲区中,当有数据的时候read函数返回数据长度
	                    //NIO会自动的将缓冲区一次容纳不下的自动分段
	                    int readInt=0;
	                    while((readInt=sc.read(echoBuffer)) > 0){
	                      //如果获得数据长度比缓冲区大小小的话
	                      if(readInt<echoBuffer.capacity()){
	                          //建立一个临时byte数组,将齐长度设为获取的数据的长度
	                          byte[] readByte=new byte[readInt];
	                          //循环向此临时数组中添加数据
	                          for(int i=0;i<readInt;i++){
	                            readByte[i]=echoBuffer.get(i);
	                          }
	                          //将此数据存入byte流中
	                          bos.write(readByte);
	                       }else{
	                          //将读取到的数据写入到byte流对象中
	                          bos.write(echoBuffer.array());
	                       }
	                       //将缓冲区清空，以便进行下一次存储数据
	                       echoBuffer.clear();
	                    }
	                    //当循环结束时byte流中已经存储了客户端发送的所有byte数据
	                    System.out.println("接收数据: "+new String(bos.toByteArray()));
	                 }catch(Exception e){
	                   //当客户端在读取数据操作执行之前断开连接会产生异常信息
	                   e.printStackTrace();
	                   //将本socket的事件在选择器中删除
	                   key.cancel();
	                   break;
	                 }
	                 //获取byte流对象的标准byte对象
	                 byte[] b=bos.toByteArray();
	                 //建立这个byte对象的ByteBuffer,并将数据存入
	                 ByteBuffer byteBuffer=ByteBuffer.allocate(b.length);
	                 byteBuffer.put(b);
	                 //向客户端写入收到的数据
	                 Write(byteBuffer,sc);
	                 //关闭客户端连接
	                 sc.close();
	                 //将本socket的事件在选择器中删除
	                 key.cancel();
	        	}
	        }
		}catch(Exception e){
			e.printStackTrace();
		}finally{
			System.out.println("连接结束");
            System.out.println("=============================");
		}
	}
	
	/**
	 * 写数据
	 * @param echoBuffer
	 * @param sc
	 * @return
	 */
	public boolean Write(ByteBuffer echoBuffer,SocketChannel sc){
      //将缓冲区复位以便于进行其他读写操作
      echoBuffer.flip();
      try{
         //向客户端写入数据,数据为接受到数据
         sc.write(echoBuffer);
      }catch (IOException e){
         e.printStackTrace();
         return false;
      }
      System.out.println("返回数据: "+new String(echoBuffer.array()));
      return true;
	}
	
	/**
	 * 启动服务
	 * @param args
	 */
	public static void main(String[] args) {
		NioServer nioServer=new NioServer();
		nioServer.accept();
	}
}

客户端代码

package com.li.springboot.nio.client;

import java.io.ByteArrayOutputStream;
import java.net.InetSocketAddress;
import java.net.SocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;

/**
 * nio通信客户端
 * @author 张宗海
 *
 */
public class NioClient {

	/**
	 * 发送
	 * @param mssage
	 */
	public void send(String mssage){
		try {
			 //定义一个记录套接字通道事件的对象
	         Selector selector = Selector.open();
	         //定义一个服务器地址的对象
	         SocketAddress address = new InetSocketAddress("localhost",8083);
	         //定义异步客户端
	         SocketChannel client=SocketChannel.open(address);
	         //将客户端设定为异步
	         client.configureBlocking(false);
	         //在轮讯对象中注册此客户端的读取事件(就是当服务器向此客户端发送数据的时候)
	         client.register(selector, SelectionKey.OP_READ);
	         //定义用来存储发送数据的byte缓冲区
	         ByteBuffer sendbuffer=ByteBuffer.allocate(mssage.length());
	         //定义用于接收服务器返回的数据的缓冲区
	         ByteBuffer readBuffer=ByteBuffer.allocate(mssage.length());
	         //将数据put进缓冲区
	         sendbuffer.put(mssage.getBytes("utf-8"));
	         //将缓冲区各标志复位,因为向里面put了数据标志被改变要想从中读取数据发向服务器,就要复位
	         sendbuffer.flip();
	         //向服务器发送数据
	         client.write(sendbuffer);
	         System.out.println("发送数据: "+new String(sendbuffer.array()));
	         
	         //利用循环来读取服务器发回的数据
	         while(true){
	            //如果客户端连接没有打开就退出循环
	            if(!client.isOpen()) break;
	            //此方法为查询是否有事件发生如果没有就阻塞,有的话返回事件数量
	            int shijian=selector.select();
	            //如果没有事件返回循环
	            if(shijian==0){
	               continue;
	            }
	            this.send(selector,readBuffer,client);
	         }
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
	/**
	 * 发送数据
	 * @param selector
	 * @param readBuffer
	 * @param client
	 */
	public void send(Selector selector,ByteBuffer readBuffer,SocketChannel client){
		try{
			//遍例所有的事件
	        for (SelectionKey key : selector.selectedKeys()){
	           //删除本次事件
	           selector.selectedKeys().remove(key);
	           //如果本事件的类型为read时,表示服务器向本客户端发送了数据
	           if (key.isReadable()){
	              //将临时客户端对象实例为本事件的socket对象
	        	  SocketChannel sc=(SocketChannel) key.channel();
	              //定义一个用于存储所有服务器发送过来的数据
	              ByteArrayOutputStream bos=new ByteArrayOutputStream();
	              //将缓冲区清空以备下次读取
	              readBuffer.clear();
	              //此循环从本事件的客户端对象读取服务器发送来的数据到缓冲区中
	              while(sc.read(readBuffer) > 0){
	                 //将本次读取的数据存到byte流中
	                 bos.write(readBuffer.array());   
	                 //将缓冲区清空以备下次读取
	                 readBuffer.clear();
	              }
	              //如果byte流中存有数据
	              if(bos.size()>0){
	                 //建立一个普通字节数组存取缓冲区的数据
	                 byte[] b=bos.toByteArray();
	                 
	                 System.out.println("接收数据: " + new String(b));
	                 //关闭客户端连接,此时服务器在read读取客户端信息的时候会返回-1
	                 client.close();
	                 System.out.println("连接关闭!");
	              }
	           }
	        }
		}catch(Exception e){
			e.printStackTrace();
		}		
	}
	
	/**
	 * 启动
	 * @param args
	 */
	public static void main(String[] args) {
		NioClient nioClient=new NioClient();
		nioClient.send("123456789");
	}
}

测试结果

服务端控制台输出
在这里插入图片描述
客户端控制台输出
在这里插入图片描述

一剑问九州
关注
NIO 简单实例
淦淦淦！
05-16 1584
前言 在 Java 中，数据传输 IO 模型大概分为三类：BIO（同步阻塞）、NIO（同步非阻塞）、AIO（异步非阻塞）。 在 BIO 中，服务器会针对每一个连接都去开一个新的线程进行处理，这样实现非常简单快速，但是对于资源消耗巨大，于是提出了 NIO。 在看本博客之前建议先了解一下 NIO 的基本用法。 一、NIO简介 NIO 是一种基于事件驱动的 IO 模型，面向缓冲区编程，NIO有三大核心部分：Channel（通道）、Buffer（缓冲区）、Selector（选择器）。通俗理解，NIO 的一个线程管理
Java NIO原理分析及代码实例
08-06
Java NIO（New IO）是Java 1.4版本引入的一个新API，全称为Non-blocking Input/Output，它提供了一种不同于传统IO的编程模型，传统IO...在实际编码时，参考博文链接中的代码实例，可以帮助你更好地理解和实践Java NIO。
Java网络编程-Nio 实例代码
卓轩&高江涛==> 个人博客
07-22 1778
Nio 实例代码
NIO通信代码示例
最新发布
Cover_sky的博客
01-09 785
先启动server再启动client。
Java NIO 模型代码示例
qq_33471737的博客
12-12 1902
在高并发（持续大量的连接同时请求）场景中，之前的两种 BIO 优化方案都需要消耗大量的线程来维持连接。并且 CPU 在线程切换上消耗很大。 Java NIO 模型的主要优势：少量的线程就可以处理大量连接的请求。 主要组成： Channel 通道：IO 传输发生时数据通过的入口 Buffer 缓冲区：可以理解为数据在管道传输时的起点和终点 Selector 选取器（IO监听器）：负责监听 IO 事件 所用通道都向 Selector 注册，Selector 负责轮询检测，然后服务端进程会阻塞在 Select
NIO简单的实例
weixin_40727749的博客
10-27 292
上篇文章是关于BIO的实例，现在知道BIO的缺点就是在不考虑多线程的情况下，无法实现并发，主要原因是有两个阻塞状态：1、服务器阻塞等待客户端的连接；2、服务器阻塞等待客户端向socket中发送消息。因此一个BIO的连接通常情况下会对CPU资源造成很大的浪费。 针对BIO的缺点，java引进了NIO（Noblocking IO）即非阻塞IO。 首先，需要了解几个重要的概念： ServerSocketChannel：与BIO中的ServerSocket意义是一样的，都是用来监听客户端的连接，只不过多了非阻塞状态
nio.rar_NIO_NIO-socket_java nio_java 实例_java.nio
09-19
标签“nio nio-socket java_nio java_实例 java.nio”进一步强调了这个实例与Java NIO、NIO套接字以及具体的代码实例相关。 压缩包内的文件“www.pudn.com.txt”可能是提供有关NIO的文档或者代码注释，而“nio”...
NIO实例
08-04
标题中的"NIO实例"指的是Java中的非阻塞I/O（Non-blocking Input/Output）技术，它是Java从1.4版本开始引入的一种I/O...通过阅读相关博文和研究代码实例，我们可以深入理解并掌握NIO技术，提高我们的Java网络编程能力。
Java NIO 经典实例代码
zhj100921的博客
08-18 414
Java NIO 经典实例代码
nio入门文档及示例代码
01-06
不错的学习nio的资料，其中包含示例代码。轻松学习nio.
NIO 通信示例
lslxy1021的博客
10-21 290
在之前的三篇文章中介绍了 NIO 的相关知识： Java NIO 缓冲区 Java NIO 通道 Java NIO 选择器Selector 下面根据 NIO 的相关知识，编写一个 NIO 服务端与客户端通信的一个完整的比较简单的例子。 程序的功能是客户端向服务器端发送 request time 请求，服务器接收到请求并验证正确后向客户端返回服务器时间。 服务器： public cl...
NIO的原理介绍和Java示例代码
C.
06-21 954
NIO简介 nio 是New IO 的简称，在jdk1.4 里提供的新api 。Sun 官方标榜的特性如下： 为所有的原始类型提供(Buffer)缓存支持。字符集编码解码解决方案。 Channel ：一个新的原始I/O 抽象。 支持锁和内存映射文件的文件访问接口。 提供多路(non-bloking) 非阻塞式的高伸缩性网络I/O 。 传统IO与NIO的区别 传统的I/O 使用传统的I/...
Java NIO 代码示例
weixin_34378922的博客
03-27 200
NIOServer package com.ye.nio; import java.io.IOException; import java.net.InetSocketAddress; import java.nio.ByteBuffer; import java.nio.channels.*; import java.nio.channels.Channel; import java.nio....
java NIO socket 通信实例
zhuyijian135757的专栏
07-10 8221
java nio 通信简单 demo
java NIO代码示例
一念永恒
09-04 689
服务端：package cn.nio; import java.io.IOException; import java.net.InetSocketAddress; import java.nio.ByteBuffer; import java.nio.channels.SelectionKey; import java.nio.channels.Selector; import java.ni
java nio 示例代码
qq_21588061的博客
09-02 225
1.服务端 package io.netty.example.nio; import java.io.IOException; import java.net.InetSocketAddress; import java.nio.ByteBuffer; import java.nio.channels.*; import java.util.Iterator; import java.util.Scanner; public class NioService { private static Sel
NIO代码实例分享
dengminhui
10-20 94
  (1)server主要是读取client发过来的信息，并返回一条信息     /** * @author Jeff */ public class HelloWorldServer { static int BLOCK = 1024; static String name ...
NIO通信示例
日有寸进
08-28 348
public class Const { public static int DEFAULT_PORT = 12345; public static String DEFAULT_SERVER_IP = "127.0.0.1"; public static String response(String msg){ return "Hello,"+msg+"...
Java NIO 实现Socket通信的详细教程
"Java使用NIO包实现Socket通信的实例代码" 在Java编程中，当涉及到网络通信时，我们通常会使用传统的IO流（java.io）或者NIO（New Input/Output，java.nio）包。NIO包是在Java 1.4版本引入的，其设计目标是为了提供...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值