java NIO Socket交互

最新推荐文章于 2024-07-30 07:15:00 发布

一只勤奋的代码狗

最新推荐文章于 2024-07-30 07:15:00 发布

阅读量1.1k

点赞数

分类专栏： Java

本文链接：https://blog.csdn.net/gaoxuaiguoyi/article/details/45846951

版权

Java 专栏收录该内容

9 篇文章 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();
	}
}