niosockt的使用简例

最新推荐文章于 2022-11-13 07:00:00 发布
最新推荐文章于 2022-11-13 07:00:00 发布
阅读量172 收藏
点赞数
分类专栏： JAVA 文章标签： java niosocket
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37426805/article/details/79970873
版权

1.niosocket服务端

package com.feng.test.nioSocket;

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.nio.charset.Charset;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;

/**
 * nioSocket服务端
 * @author lenovo
 * 
 */
public class NioSocketServer extends Thread {
	private  Selector selector;
	private  ServerSocketChannel serverSocketChannel;
	private  Charset charset = Charset.forName("utf-8");
	private  static final int port = 9092;
	private ExecutorService executorService = Executors.newSingleThreadExecutor();
	/**
	 * 构造，实现等待以及连接客户端
	 */
	public NioSocketServer() {
		try {
			selector = Selector.open();
			serverSocketChannel = ServerSocketChannel.open();
			serverSocketChannel.configureBlocking(false);
			serverSocketChannel.socket().bind(new InetSocketAddress(port));
			serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
			System.out.println("服务端已启动，等待客户端连接 ,端口号: "+port);			
		} catch (IOException e) {
			e.printStackTrace();
		}		
	}
	 	
	public static void main(String[] args) {
		NioSocketServer ns = new NioSocketServer();
		ns.execute();
	}
	
	
	public void run() {
		execute();
	}
	
	public  void execute(){
    	try {
			while(selector.select()>0){// 
//				无论是否有读写事件发生，selector每隔1s被唤醒一次  
//              selector.select(1000);  
//              //阻塞,只有当至少一个注册的事件发生的时候才会继续.  
            selector.select(); 
				 Set<SelectionKey> selectedKeys =  selector.selectedKeys();
				for(SelectionKey sk : selectedKeys){
					System.out.println("--------------------------------------进来这儿 1 ---------------------------------------------");
					if(sk.isAcceptable()){//Tests whether this key's channel is ready to accept a new socket connection. 
						System.out.println("接受连接请求："+ new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
						//通过ServerSocketChannel的accept创建SocketChannel实例  
                        //完成该操作意味着完成TCP三次握手，TCP物理链路正式建立  
						SocketChannel socketChannel =	serverSocketChannel.accept();//Accepts a connection made to this channel's socket. 
						 //设置为非阻塞的  
					    socketChannel.configureBlocking(false);						
						//注册为读  
						socketChannel.register(selector, SelectionKey.OP_READ);					   
					    //将key对应的channel设置成准备接受其他请求
					    sk.interestOps(SelectionKey.OP_ACCEPT);
					}
					System.out.println("--------------------------------------进来这儿 2 ---------------------------------------------");
					//读消息
					if(sk.isReadable()){
						System.out.println("接受客户端请求： "+new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
						SocketChannel socketChannel = (SocketChannel) sk.channel();
					    //如果可读状态时读取的数据为空，则判断服务端关闭输出
						executorService.submit(new  ServerThread(sk,socketChannel));
					}					
				}
				selectedKeys.clear();//Removes all of the elements from this set (optional operation). The set will be empty after this call returns.
				try {
					System.out.println("--------------------------------------进来这儿3 ---------------------------------------------");
					Thread.sleep(2000);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
    }
	
	private class  ServerThread implements  Callable<String>{
		private SelectionKey selectionKey;
		private SocketChannel socketChannel;
		private  static final int bufferSize = 4096;
		
		
		public ServerThread(SelectionKey selectionKey,SocketChannel socketChannel) {
			this.selectionKey = selectionKey;
			this.socketChannel = socketChannel;
		}
		
		public String call() throws Exception {
			try{//***没有处理异常，结果在此新起线程里，新线程死掉，主线程接收不到异常信息
				
				String content = "";			
				ByteBuffer byteBuffer = ByteBuffer.allocate(bufferSize);
				while(socketChannel.read(byteBuffer) > 0){
					byteBuffer.flip();//Flips this buffer. The limit is set to the current position and then the position is set to zero. If the mark is defined then it is discarded. 
					content +=charset.decode(byteBuffer); 
				}
				System.out.println("接受的客户端信息："+content);
				//将sk对应的channel设置成准备下一次的数据读取
				selectionKey.interestOps(SelectionKey.OP_READ);
				//处理数据
				if(!content.equals("")){
				Map<String,String>  map = handleAction(content,socketChannel);//1
					//Map<String,String>  map = handleAction2(content,socketChannel);//2
					
				}
				
			}catch(Exception e){
				e.printStackTrace();
			}
			return null;
		}
		
		/**
		 * 处理业务流程，一次处理完就结束
		 * @param content
		 * @param sc
		 * @return
		 */
		private  Map<String, String>  handleAction(String content,SocketChannel sc){
			Map<String, String>  result = new HashMap<String, String>();
			//处理业务
			if(content!=null&&!"".equals(content)){
				String   resultStr = content+"_"+System.currentTimeMillis()+""+"\r\n"; 
				doWrite(sc,resultStr);
			    try {
					sc.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			    result.put("result", "正常");
			}else{
				result.put("result", "参数错误");
			}			
			return result;			
		}	
		
		/**
		 * 处理业务流程不间断
		 * @param content
		 * @param sc
		 * @return
		 */
		private  Map<String, String>  handleAction2(String content,SocketChannel sc){
			Map<String, String>  result = new HashMap<String, String>();
			//处理业务
			if(content!=null&&!"".equals(content)){	
				new Thread(new chuiliThread(sc,content)).start();
			}else{
				result.put("result", "参数错误");
			}			
			return result;	
		}	
		
		
	
		
		
		/**
		 * 异步发送应答消息
		 * @param sc
		 * @param resultStr
		 */
		private void  doWrite(SocketChannel sc,String resultStr){
			System.out.println("开始往客户端返回数据："+resultStr);
			//将消息编码为字节数组
			byte[]  bytes= resultStr.getBytes();
			//根据数组容量创建ByteBuffer
			ByteBuffer writeBuffer = ByteBuffer.allocate(bytes.length);
			writeBuffer.put(bytes);//This method transfers the bytes remaining in the given source buffer into this buffer
			writeBuffer.flip();			 
			try {
				//发送缓冲区的字节数组
				sc.write(writeBuffer);
			} catch (IOException e) {
				e.printStackTrace();
			}
		}				
	}		





	
	
	/**
	 * 一直保持连接不关闭，服务端不断产生数据往客户端发送
	 * @author Lenovo
	 *
	 */
	private class   chuiliThread  implements  Runnable {
		private  String request ;
		private SocketChannel sc;
		public chuiliThread(SocketChannel sc ,String request) {
			this.sc = sc;
			this.request = request;
		}
		
		public void run() {			
			while(true){
				String result = "nihao_"+request+"_"+(int)(Math.random()*100)+"\r\n";				
				doWrite(sc,result);				
				try {
					Thread.sleep(1000);
				}catch (Exception e) {
					e.printStackTrace();
				}
			}			
		}
		

		/**
		 * 异步发送应答消息
		 * @param sc
		 * @param resultStr
		 * 
		 */
		private void  doWrite(SocketChannel sc,String resultStr){
			System.out.println("开始往客户端返回数据："+resultStr);
			//将消息编码为字节数组
			byte[]  bytes= resultStr.getBytes();
			//根据数组容量创建ByteBuffer
			ByteBuffer writeBuffer = ByteBuffer.allocate(bytes.length);
			writeBuffer.put(bytes);//This method transfers the bytes remaining in the given source buffer into this buffer
			writeBuffer.flip();			 
			try {
				//发送缓冲区的字节数组
				sc.write(writeBuffer);
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
	
}

2.niosocket客户端

package com.feng.test.nioSocket;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.ClosedChannelException;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
import java.nio.charset.Charset;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

/**
 * nioSocket贯通整个流程，观察这个特性
 * @author lenovo
 *
 */
public class NioSocketClient  extends Thread{
	private final int bufferSize = 4096 ;//分配缓冲内存大小
	
	private Charset charset;//niocharset,字符编码
	private InetSocketAddress address;
	private Selector selector ;//客户端专用selector
	private SocketChannel socketChannel;//通道
	
	//方法重载，传入参数
	public NioSocketClient(String ip,Integer port,String code) {
		this.address = new InetSocketAddress(ip, port);//构造网络地址
		if(code!=null&&!"".equals(code)){
			charset = Charset.forName(code);
		}else{
			charset = Charset.forName("utf-8");
		}
	}
	
	public static void main(String[] args) {
		NioSocketClient nioSocketClient =  new  NioSocketClient("localhost",9092,"UTF-8");
		nioSocketClient.sendReq("111");
	}
	
	@Override
	public void run() {
		sendReq("111");
	}
	
	
	public String sendReq(String param) {
		String result = "";
		try {
			if(param!=null&&!"".equals(param)){
				//定义检测socketChannel的selector对象
				selector = Selector.open();
				//连接服务器，打开通道
				socketChannel = SocketChannel.open(address);
				//通道设置成非阻塞模式
				socketChannel.configureBlocking(false);
				//向Selector注册通道,此socketChannel注册到selector中
				socketChannel.register(selector, SelectionKey.OP_READ);//SelectionKey.OP_READ
				FutureTask<String> future = new FutureTask<String>(new clientThread(selector));//1
				//FutureTask<String> future = new FutureTask<String>(new clientThread2(selector));//2
				new Thread(future).start();	
				socketChannel.write(charset.encode(param));//Writes a sequence of bytes to this channel from the given buffer. 
				if(future.get() != null){//Waits if necessary for the computation to complete, and then retrieves its result.
					result = future.get();
					System.out.println("客户端打印："+result);
				}		
			}else{
				result = "传参错误";
			}
		} catch (ClosedChannelException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} catch (InterruptedException e) {
			e.printStackTrace();
		} catch (ExecutionException e) {
			e.printStackTrace();
		}
		return result;		
	}
	
	
	/**
	 * 客户端读取通道中数据处理线程，单条数据处理完就结束，服务端也只响应这一次请求
	 * @author lenovo
	 *
	 */
	private class  clientThread implements Callable<String> {
		
		private Selector selector;
		
		private static final int bufferSize = 4096;
		
		public clientThread(Selector selector) {
			this.selector = selector;
		}	
		
		/**
		 * 
		 */
		public String call()   {		
			String result = "";		
			int flag = 0;
			try {
				while(selector.select() > 0){//	The number of keys, possibly zero, whose ready-operation sets were updated.				
					System.out.println("--------------------------------------进来这儿 1 ---------------------------------------------");					
					for(SelectionKey sk :selector.selectedKeys() ){//A token representing the registration of a SelectableChannel with a Selector.
						System.out.println("--------------------------------------进来这儿 2 ---------------------------------------------");
						selector.selectedKeys().remove(sk);
						if(sk.isReadable()){//Tests whether this key's channel is ready for reading. 
							//从key里面获取可读通道
						    SocketChannel  channel =  (SocketChannel) sk.channel();
						    //数据缓冲区设置
						    ByteBuffer buffer = ByteBuffer.allocate(bufferSize);
						    byte[] data = buffer.array();
						    //channel.read(buffer);//Reads a sequence of bytes from this channel into the given buffer. 
						    //如果可读状态时读取的数据为空，则判断服务端关闭输出
						    if(channel.read(buffer)>-1){//The number of bytes read, possibly zero, or -1 if the channel has reached end-of-stream
						    	System.out.println("服务端关闭输出");						    	
						    	flag = 1;
						    	channel.close();
						    	selector.close();
						    	
						    }
						    result =   new  StringBuffer().append(new String(data).trim()).toString();
						    System.out.println("客户端接收到的结果："+result);
						    //sk.interestOps(SelectionKey.OP_READ);//Sets this key's interest set to the given value. 
						    Thread.sleep(1000);
						}
					}
				  if(flag==1){						
						break;
				  }
				}
				System.out.println("-----selector.close()---------");
				selector.close();
		    	
			} catch (IOException e) {
				e.printStackTrace();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}			
			return result;
		}
		
	}
	
	/**
	 * 客户端读取通道中数据处理线程，一直保持连接不关闭，服务端不断产生数据往客户端发送
	 * @author lenovo
	 *
	 */
	private class  clientThread2 implements Callable<String> {
		
		private Selector selector;
		
		private static final int bufferSize = 4096;
		
		public clientThread2(Selector selector) {
			this.selector = selector;
		}	
		
		/**
		 * 
		 */
		public String call()   {		
			String result = "";		
			int flag = 0;
			try {
				while(selector.select() > 0){//	The number of keys, possibly zero, whose ready-operation sets were updated.				
					System.out.println("--------------------------------------进来这儿 1 ---------------------------------------------");					
					for(SelectionKey sk :selector.selectedKeys() ){//A token representing the registration of a SelectableChannel with a Selector.
						System.out.println("--------------------------------------进来这儿 2 ---------------------------------------------");
						selector.selectedKeys().remove(sk);
						if(sk.isReadable()){//Tests whether this key's channel is ready for reading. 
							//从key里面获取可读通道
						    SocketChannel  channel =  (SocketChannel) sk.channel();
						    //数据缓冲区设置
						    ByteBuffer buffer = ByteBuffer.allocate(bufferSize);
						    byte[] data = buffer.array();
						    //channel.read(buffer);//Reads a sequence of bytes from this channel into the given buffer. 
						    //如果可读状态时读取的数据为空，则判断服务端关闭输出
						    if(channel.read(buffer)>-1){//The number of bytes read, possibly zero, or -1 if the channel has reached end-of-stream
						    	System.out.println("服务端关闭输出");						    	
						    	flag = 1;
						    	//channel.close();
						    	//selector.close();
						    	
						    }
						    result =   new  StringBuffer().append(new String(data).trim()).toString();
						    System.out.println("客户端接收到的结果："+result);
						    //sk.interestOps(SelectionKey.OP_READ);//Sets this key's interest set to the given value. 
						    Thread.sleep(1000);
						}
					}
				  /*if(flag==1){
						
						break;
					}*/
				}
				System.out.println("-----selector.close()---------");
				selector.close();
		    	
			} catch (IOException e) {
				e.printStackTrace();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}			
			return result;
		}
		
	}
	
	
	
	
	
	/**
	 * 关闭通道，选择器
	 */
	public void close() {
		try {
			if(socketChannel!=null&&socketChannel.isConnected()){			
				socketChannel.close();			
			}
			if(selector!=null&&selector.isOpen()){
				selector.close();
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	
}
3.详细请看代码以及注释
*攻城狮*
关注
专栏目录
java nio socket,Java----NioSocket的简单使用
weixin_39585974的博客
03-19 579
一、自己理解的概念nioSocket(即new io socket)是一种同步非阻塞的I/O，其使用buffer来缓存数据和channel来传输数据，使用select来分拣消息。其使用的ServerSocketChannel和SocketChannel对应于之前学习的ServerSocket和Socket。在我看的书(《看透Spring MVC源代码分析与实践》)中形容为：当今的快递物流，现实中的...
java Nio 使用 NioSocket 客户端与服务端交互实现
热门推荐
wkNote
07-07 2万+
NioSocket 客户端与服务端交互实现 &amp;amp;nbsp;&amp;amp;nbsp;&amp;amp;nbsp;&amp;amp;nbsp;&amp;amp;nbsp;&amp;amp;nbsp;&amp;amp;nbsp;java Nio是jdk1.4新增的io方式—–nio（new IO），这种方式在目前来说算不算new，更合适的解释应该是non-block IO。 &amp;amp;nbsp;&amp;amp;
NioSocket的用法
dmqi22563的博客
03-31 121
不知道该咋说(ง •_•)ง ServerSocketChannel和SocketChannel，它们对应原来的ServerSocket和Socket。 Buffer、Channel和Selector Buffer就是所要送的货物，Channel就是送货员（或者开往某个区域的配货车），Selector就是中转站的分拣员。 NioSocket使用中首先要创建ServerSocket...
Java中的Socket的用法
weixin_30765577的博客
12-24 210
Java中的Socket的用法 Java中的Socket分为普通的Socket和NioSocket。 普通Socket的用法 　　Java中的网络通信时通过Socket实现的，Socket分为ServerSocket和Socket两大类，ServerSocket用于服务器端，可以通过accept方法监听请求，监听请求后返回Socket，...
Java NioSocket 的用法
jeikerxiao
10-23 360
说明从 JDK1.4 开始， Java增加了新的 io 模式，nio(new IO), nio在底层采用了新的处理方式，极大地提高了IO的效率。nio与原来的io对比： io nio ServerSocket ServerSocketChannel Socket SocketChannel 要理解 NioSocket 的使用必须要理解三个概念： Buffer Channel S
Java中Socket的用法（二） NioSocket的用法
Gradual的博客
10-31 382
从JDK1.4开始，Java新增了新的IO模式——nio(new IO)，nio再底层采用了新的处理方式，极大地提高了IO的效率。我们使用的Socket也属于IO的一种，nio提供了相应的ServerSocketChannel和SocketChannel，他们分别对应原来的ServerSocket和Socket。 要理解NioSocket的使用必须先理解三个概念： Buffer Channe...
NIO--Socket通道
weixin_49702090的博客
06-19 751
NIO ServerSocketChnnel介绍
Java NIO实战篇：使用Socket实现报文交互
最新发布
猪大肠的博客
11-13 2231
最近有个对接渠道需求，对方提供文档中要求使用Socket短链接的方式进行报文交互，所以这边采用NIO方式编写Socket。
java nio ScatteringByteChannel，GatheringByteChannel源码分析
许诗宇的博客
12-04 183
package java.nio.channels; import java.io.IOException; import java.nio.ByteBuffer; /** * 一种能将字节读入缓冲区序列的通道。 * * <p> 分散读操作在一次调用中将一个字节集合读入一个或多个给定的缓冲区序列中。 * 分散读取在实现网络协议或文件格式时通常是有用的， * 例如，将数据分组成段，由一个或多个固定长度的报头和可变长度的主体组成。 * 在GatheringByteChannel..
nio-socket编程
标题有点难
04-17 269
一、前言 从Java1.4开始， Java引入了non-blocking IO，简称NIO。NIO与传统socket最大的不同就是引入了Channel和多路复用selector的概念。传统的socket是基于stream的，它是单向的，有InputStream表示read和OutputStream表示写。而Channel是双工的，既支持读也支持写，channel的读/写都是面向Buf...
基于NIO的Socket通信(使用Java NIO的综合示例讲解)
Java新生代
08-23 1万+
本篇文章并不是NIO和Socket的入门文章，如果你在看完后有些难度可以先学习基础知识后再进行阅读，但是本文的一些概念不论是入门还是学习已久的人都会有些许收获。（感觉基础不足的可以阅读前文两个链接来获取更多的细节） 一、NIO的简介 Java NIO（New IO）是从Java 1.4版本开始引入的一个新的IO API，Java NIO提供了与标准IO不同的IO工作方式： IO NIO...
Java NIO —— TCP套接字（ServerSocketChannel & SocketChannel）
司马懿的西山居
12-02 1943
package com.demo.test;import java.io.IOException; import java.net.InetSocketAddress; import java.nio.ByteBuffer; import java.nio.channels.ServerSocketChannel; import java.nio.channels.SocketChannel; im
webSocket学习与使用
qq_38799387的博客
07-20 1832
webSocket实战
NIO最佳实践
weixin_33698043的博客
08-31 317
NIO最佳实践 SelectionKey.OP_WRITE订阅时机 channel.write()写数据问题 TCP断开判断 ByteBuf使用 ByteBuf 的clear()和discardReadBytes()对比 NIO epoll空轮训bug SelectionKey.OP_WRITE订阅时机 现象: cpu占用超高 原因: 订阅了SelectionKey.OP_WRITE事件...
TF新手使用教程（一）
zongzi13545329的博客
08-14 5683
简介写在前面的话： 在进行深度学习的过程中，我们不可避免的需要了解和使用一些深度学习的框架，其中最有名的应该就是谷歌支持下的tensorflow深度学习框架了。 Tensorflow是一个使用数据流图 (data flow graphs) 技术来进行数值计算的开源软件库。 数据流图是是一个有向图，使用结点（一般用圆形或者方形描述，表示
ByteChannel，分散聚集通道接口的定义（SocketChannel）
Donald_Draper
04-24 324
Channel接口定义：[url]http://donald-draper.iteye.com/blog/2369111[/url] AbstractInterruptibleChannel接口定义：[url]http://donald-draper.iteye.com/blog/2369238[/url] SelectableChannel接口定义:[url]http://donald-dr...
NIO与Socket编程技术指南
剑来
03-08 1069
java的技术点不止是ssh、ssm，更应该落脚在多线程、并发处理、NIO以及Socket技术上 多线程 高性能的解决方案离不开多线程，使1个cpu运行更多的任务，使用Socket实现某些功能时是需求借助于多线程 并发处理 concurrent并发包是对多线程技术的封装 Socket 高性能的服务器的架构设计离不开集群，集群同样离不开Socket，Socket技术可以实现不同计算机间的数据通信，从而实现在集群中的服务器之间进行数据交换 一、NIO介绍 a、NIO与原来的IO有同样的作用和目的
Socket和NioSocket浅谈
Amaranth007的博客
04-22 5640
Socket java中的网络通信是通过Socket实现的，之前说过TCP/IP协议只是一套规则，并不能具体工作，就像程序中的接口一样，而Socket是TCP/IP协议的一个具体的实现。Socket分为ServerSocket和Socket两大类，ServerSocket用于服务端，可以通过方法监听请求，监听到请求后返回Scoket,Socket用于具体完成数据传输，客户端直接使用Socket发...
程序设计的最基本的三种结构
qq_37426805的博客
12-29 1万+
任何简单或复杂的算法都可以由顺序结构、选择结构和循环结构这三种基本结构组合而成。这三种结构就被称为程序设计的三种基本结构，也是结构化程序设计必须采用的结构。 Java语言的方法体内同样是这三种结构组成的，换句话说，虽然Java是面向对象的，但Java的方法里则是 一种结构化的程序流。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值