java NIO Socket交互

红太狼 2022-08-08 13:42 120阅读 0赞

socket服务端代码：

package com.gaoxu.socket;
    
    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;
    import java.util.Iterator;
    import java.util.Set;
    
    public class SocketServer {
    	/* 标志数字 */
    	private static int flag = 0;
    	/* 定义缓冲区大小 */
    	private static int block = 4096;
    	/* 接收缓冲区 */
    	private static ByteBuffer receiveBuffer = ByteBuffer.allocate(block);
    	/* 发送缓冲区 */
    	private static ByteBuffer sendBuffer = ByteBuffer.allocate(block);
    	/* 定义Selector */
    	private Selector selector;
    
    	/* 初始化参数 */
    	public SocketServer(int port) throws IOException {
    
    		// 打开服务器套接字通道
    		ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
    		// 服务器配置为非阻塞
    		serverSocketChannel.configureBlocking(false);
    		// 检索与此服务器套接字通道关联的套接字
    		ServerSocket serverSocket = serverSocketChannel.socket();
    		// 进行服务的绑定
    		serverSocket.bind(new InetSocketAddress(port));
    		// 通过open()方法找到Selector
    		selector = Selector.open();
    		// 注册到selector
    		serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
    		System.out.println("Server Start -----port:" + port);
    	}
    	// 监听
    	public void listen() throws IOException {
    		while (true) {
    			// 监控所有注册的 channel ，当其中有注册的 IO 操作可以进行时，该函数返回，并将对应的 SelectionKey 加入
    			// selected-key set
    			selector.select();
    			// Selected-key set 代表了所有通过 select() 方法监测到可以进行 IO 操作的 channel
    			// ，这个集合可以通过 selectedKeys() 拿到
    			Set<SelectionKey> selectionKeys = selector.selectedKeys();
    			Iterator<SelectionKey> iterator = selectionKeys.iterator();
    			while (iterator.hasNext()) {
    				SelectionKey selectionKey = iterator.next();
    				handleKey(selectionKey);
    				iterator.remove();
    			}
    			try {
    				Thread.sleep(3000);
    			} catch (InterruptedException e) {
    				
    				e.printStackTrace();
    			}
    		}
    	}
    
    	// 处理请求
    	public void handleKey(SelectionKey selectionKey) throws IOException {
    		// 接受请求
    		ServerSocketChannel serverSocketChannel = null;
    		SocketChannel socketChannel = null;
    		String receiveText;
    		String sendText;
    		int count;
    		// 测试此键的通道是否准备好接受新的套接字连接
    		if (selectionKey.isAcceptable()) {
    			// 返回创建此键的通道
    			serverSocketChannel = (ServerSocketChannel) selectionKey.channel();
    			// 接受客户端建立连接的请求，并返回 SocketChannel 对象
    			socketChannel = serverSocketChannel.accept();
    			// 配置为非阻塞
    			socketChannel.configureBlocking(false);
    			// 注册到selector
    			socketChannel.register(selector, SelectionKey.OP_READ);
    		} else if (selectionKey.isReadable()) {
    			// 返回为之创建此键的通道
    			socketChannel = (SocketChannel) selectionKey.channel();
    			// 将缓冲区清空，以备下次读取
    			receiveBuffer.clear();
    			// 将发送来的数据读取到缓冲区
    			count = socketChannel.read(receiveBuffer);
    			if (count > 0) {
    				receiveText = new String(receiveBuffer.array(), 0, count);
    				System.out.println("服务器端接受到的数据---" + receiveText);
    				socketChannel.register(selector, SelectionKey.OP_WRITE);
    			}
    		} else if (selectionKey.isWritable()) {
    			// 将缓冲区清空以备下次写入
    			sendBuffer.clear();
    			// 返回为之创建此键的通道。
    			socketChannel = (SocketChannel) selectionKey.channel();
    			sendText = "服务端数字--" + (flag++);
    			// 向缓冲区中输入数据
    			sendBuffer.put(sendText.getBytes());
    			// 将缓冲区各标志复位,因为向里面put了数据标志被改变要想从中读取数据发向服务器,就要复位
    			sendBuffer.flip();
    			// 输出到通道
    			socketChannel.write(sendBuffer);
    			System.out.println("服务器端向客户端发送数据--：" + sendText);
    			socketChannel.register(selector, SelectionKey.OP_READ);
    		}
    
    	}
    
    	public static void main(String[] args) throws IOException {
    
    		SocketServer socket = new SocketServer(8888);
    		socket.listen();
    
    	}
    
    }

client代码：

package com.gaoxu.socket.test;
    
    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.SocketChannel;
    import java.util.Scanner;
    import java.util.Set;
    
    public class TestSocket {
    	/* 标识数字 */
    	private static int flag = 0;
    	/* 缓冲区大小 */
    	private static int BLOCK = 4096;
    	/* 接受数据缓冲区 */
    	private static ByteBuffer sendBuffer = ByteBuffer.allocate(BLOCK);
    	/* 发送数据缓冲区 */
    	private static ByteBuffer receiveBuffer = ByteBuffer.allocate(BLOCK);
    	/* 服务器端地址 */
    	private final static InetSocketAddress SERVER_ADDRESS = new InetSocketAddress(
    			"localhost", 8888);
    	private SocketChannel clientChannel=null;
    	private static SocketChannel  socketChannel=null;
    	private static Set<SelectionKey> selectionKeys=null;
    	private static Selector selector=null;
    	
    	public TestSocket() throws IOException{
    		
    		// 打开socket通道
    				 clientChannel = SocketChannel.open();
    				// 设置为非阻塞方式
    				clientChannel.configureBlocking(false);
    				// 打开选择器
    				selector = Selector.open();
    				// 注册连接服务端socket动作
    				clientChannel.register(selector, SelectionKey.OP_CONNECT);
    				// 连接
    				clientChannel.connect(SERVER_ADDRESS);
    		
    	}
    	public static void client() throws IOException {
    		
    		String receiveText;
    		String sendText;
    		int count = 0;
    		while (true) {
    			// 选择一组键，其相应的通道已为 I/O 操作准备就绪。
    			// 监控所有注册的 channel ，当其中有注册的 IO 操作可以进行时，该函数返回，并将对应的 SelectionKey 加入
    			// selected-key set
    			selector.select();
    			// 返回此选择器的已选择键集。
    			selectionKeys = selector.selectedKeys();
    			// System.out.println(selectionKeys.size());
    			for (SelectionKey selectionKey : selectionKeys) {
    				// 判断是否为建立连接的事件
    				if (selectionKey.isConnectable()) {
    					System.out.println("Client connect.......");
    					socketChannel = (SocketChannel) selectionKey.channel(); //
    					// 判断此通道上是否正在进行连接操作。
    					// 完成套接字通道的连接过程。
    					if (socketChannel.isConnectionPending()) {
    						// 完成连接的建立（TCP三次握手）
    						socketChannel.finishConnect();
    						System.out.println("完成连接!");
    						sendBuffer.clear();
    						sendBuffer.put("Hello,Server".getBytes());
    						sendBuffer.flip();
    						socketChannel.write(sendBuffer);
    					}
    					socketChannel.register(selector, SelectionKey.OP_READ);
    				} else if (selectionKey.isReadable()) {
    					socketChannel = (SocketChannel) selectionKey.channel();
    					// 将缓冲区清空以备下次读取
    					receiveBuffer.clear();
    					// 读取服务器发送来的数据到缓冲区中
    					count = socketChannel.read(receiveBuffer);
    					if (count > 0) {
    						receiveText = new String(receiveBuffer.array(), 0,
    								count);
    						System.out.println("客户端接受服务器端数据--:" + receiveText);
    						socketChannel.register(selector, SelectionKey.OP_WRITE);
    					}
    
    				} else if (selectionKey.isWritable()) {
    					sendBuffer.clear();
    					socketChannel = (SocketChannel) selectionKey.channel();
    					sendText = "客户端数字--" + (flag++);
    					sendBuffer.put(sendText.getBytes());
    					// 将缓冲区各标志复位,因为向里面put了数据标志被改变要想从中读取数据发向服务器,就要复位
    					sendBuffer.flip();
    					socketChannel.write(sendBuffer);
    					System.out.println("客户端向服务器端发送数据--：" + sendText);
    					socketChannel.register(selector, SelectionKey.OP_READ);
    				}
    			}
    			selectionKeys.clear();
    			try {
    				Thread.sleep(3000);
    			} catch (InterruptedException e) {
    				
    				e.printStackTrace();
    			}
    		}
    	}
    	//模拟输入的客户端
    	public static void test_input() throws IOException{
    		
    				String receiveText;
    				String sendText;
    				int count = 0;
    				while (true) {
    					
    					// 选择一组键，其相应的通道已为 I/O 操作准备就绪。
    					// 监控所有注册的 channel ，当其中有注册的 IO 操作可以进行时，该函数返回，并将对应的 SelectionKey 加入
    					// selected-key set
    					selector.select();
    					// 返回此选择器的已选择键集。
    					selectionKeys = selector.selectedKeys();
    					// System.out.println(selectionKeys.size());
    					for (SelectionKey selectionKey : selectionKeys) {
    						// 判断是否为建立连接的事件
    						if (selectionKey.isConnectable()) {
    							System.out.println("Client connect.......");
    							socketChannel = (SocketChannel) selectionKey.channel(); //
    							// 判断此通道上是否正在进行连接操作。
    							// 完成套接字通道的连接过程。
    							if (socketChannel.isConnectionPending()) {
    								// 完成连接的建立（TCP三次握手）
    								socketChannel.finishConnect();
    								System.out.println("完成连接!");
    								sendBuffer.clear();
    								System.out.println("请输入内容:");
    								Scanner scanner = new Scanner(System.in);
    								String info = scanner.next();
    								sendBuffer.put(info.getBytes());
    								sendBuffer.flip();
    								socketChannel.write(sendBuffer);
    							}else if (selectionKey.isReadable()) {
    								socketChannel = (SocketChannel) selectionKey.channel();
    								// 将缓冲区清空以备下次读取
    								receiveBuffer.clear();
    								// 读取服务器发送来的数据到缓冲区中
    								count = socketChannel.read(receiveBuffer);
    								if (count > 0) {
    									receiveText = new String(receiveBuffer.array(), 0,
    											count);
    									System.out.println("客户端接受服务器端数据--:" + receiveText);
    									socketChannel.register(selector, SelectionKey.OP_WRITE);
    								}
    
    							} 
    							socketChannel.register(selector, SelectionKey.OP_READ);
    						}
    					}
    				}
    	}
    	public static void main(String[] args) throws IOException{
    		new TestSocket();
    		client();
    			//test_input();
    	}
    }

![Image 1][]

[Image 1]: