2. 程式人生 > >7.Java NIO系列教程之Server/Client完整示例

7.Java NIO系列教程之Server/Client完整示例

阿新 • • 發佈：2019-02-02

TCPServer類：

package com.gw.demo;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.util.Iterator;
import java.util.Set;

public class TCPServer {
	// 緩衝區大小
	private static final int BufferSize = 1024;

	// 超時時間，單位毫秒
	private static final int TimeOut = 3000;

	// 本地監聽埠
	private static final int ListenPort = 1978;

	public static void main(String[] args) throws IOException {
		// 建立選擇器
		Selector selector = Selector.open();

		// 開啟監聽通道
		ServerSocketChannel listenerChannel = ServerSocketChannel.open();

		// 與本地埠繫結
		listenerChannel.socket().bind(new InetSocketAddress(ListenPort));

		// 設定為非阻塞模式
		listenerChannel.configureBlocking(false);

		// 將選擇器繫結到監聽通道,只有非阻塞通道才可以註冊選擇器.並在註冊過程中指出該通道可以進行Accept操作
		//一個server socket channel準備好接收新進入的連線稱為“接收就緒”
		listenerChannel.register(selector, SelectionKey.OP_ACCEPT);

		// 建立一個處理協議的實現類,由它來具體操作
		TCPProtocol protocol = new TCPProtocolImpl(BufferSize);

		// 反覆迴圈,等待IO
		while (true) {
			// 等待某通道就緒(或超時)
			int keys = selector.select(TimeOut);
			//剛啟動時連續輸出0，client連線後一直輸出1
			//System.out.print(keys);
			if (keys == 0) {
				System.out.println("獨自等待.");
				continue;
			}
			
			/*if (selector.select(TimeOut) == 0) {
				System.out.println("獨自等待.");
				continue;
			}*/
			
			// 取得迭代器.selectedKeys()中包含了每個準備好某一I/O操作的通道的SelectionKey
			Set<SelectionKey> set = selector.selectedKeys();
			//輸出為1
			//System.out.println("selectedKeysSize:" + set.size());
			Iterator<SelectionKey> keyIter  = set.iterator();
			
			while (keyIter.hasNext()) {
				SelectionKey key = keyIter.next();

				try {
					if (key.isAcceptable()) {
						System.out.println("acceptable");
						//該方法在內部，會將interest由OP_ACCEPT改為OP_READ
						//如果不執行下面的語句，則會一直是accept狀態（初始時設定為了accept），無法進入後面的兩個if語句
						//console一直列印上面的語句
						protocol.handleAccept(key);
					}

					if (key.isReadable()) {
						// 從客戶端讀取資料
						System.out.println("readable");
						protocol.handleRead(key);
					}

					if (key.isValid() && key.isWritable()) {
						//客戶端連線一次後，N次連續進入該方法
						//System.out.println("writable");//連續輸出
						protocol.handleWrite(key);
					}
				} catch (IOException ex) {
					// 出現IO異常（如客戶端斷開連線）時移除處理過的鍵
					keyIter.remove();
					continue;
				}

				// 移除處理過的鍵
				keyIter.remove();
			}
		}
	}
}

TCPProtocol介面：
package com.gw.demo;

import java.io.IOException;
import java.nio.channels.SelectionKey;

public interface TCPProtocol {
	/**
	 * 接收一個SocketChannel的處理
	 * 
	 * @param key
	 * @throws IOException
	 */
	void handleAccept(SelectionKey key) throws IOException;

	/**
	 * 從一個SocketChannel讀取資訊的處理
	 * 
	 * @param key
	 * @throws IOException
	 */
	void handleRead(SelectionKey key) throws IOException;

	/**
	 * 向一個SocketChannel寫入資訊的處理
	 * 
	 * @param key
	 * @throws IOException
	 */
	void handleWrite(SelectionKey key) throws IOException;
}


TCPProtocolImpl實現類：

package com.gw.demo;

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.nio.charset.Charset;
import java.text.SimpleDateFormat;
import java.util.Date;

public class TCPProtocolImpl implements TCPProtocol {
	private int bufferSize;

	public TCPProtocolImpl(int bufferSize) {
		this.bufferSize = bufferSize;
	}
	
	/**
	 * 將可連線 調整為 可讀取
	 */
	public void handleAccept(SelectionKey key) throws IOException {
		SocketChannel clientChannel = ((ServerSocketChannel) key.channel()).accept();
		clientChannel.configureBlocking(false);
		clientChannel.register(key.selector(), SelectionKey.OP_READ, ByteBuffer.allocate(bufferSize));
	}

	public void handleRead(SelectionKey key) throws IOException {
		// 獲得與客戶端通訊的通道
		SocketChannel clientChannel = (SocketChannel) key.channel();

		// 得到並清空緩衝區
		ByteBuffer buffer = (ByteBuffer) key.attachment();
		buffer.clear();

		// 讀取資訊獲得讀取的位元組數
		long bytesRead = clientChannel.read(buffer);

		if (bytesRead == -1) {
			// 沒有讀取到內容的情況
			clientChannel.close();
		} else {
			// 將緩衝區準備為資料傳出狀態
			buffer.flip();

			// 將位元組轉化為為UTF-16的字串
			String receivedString = Charset.forName("UTF-16").newDecoder().decode(buffer).toString();

			// 控制檯打印出來
			System.out.println("接收到來自" + clientChannel.socket().getRemoteSocketAddress() + "的資訊:" + receivedString);

			SimpleDateFormat format = new SimpleDateFormat("yyyy-mm-dd HH:mm:ss");
			String f = format.format(new Date());
			// 準備傳送的文字
			String sendString = "你好,客戶端. @" + f + "，已經收到你的資訊:" + receivedString;
			buffer = ByteBuffer.wrap(sendString.getBytes("UTF-16"));
			clientChannel.write(buffer);

			// 設定為下一次讀取或是寫入做準備
			key.interestOps(SelectionKey.OP_READ | SelectionKey.OP_WRITE);
		}
	}

	public void handleWrite(SelectionKey key) throws IOException {
		// do nothing
	}
}


TCPClient類：

package com.gw.demo;

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;

public class TCPClient {
	//通道選擇器
	private Selector selector;

	// 與伺服器通訊的通道
	SocketChannel socketChannel;

	// 要連線的伺服器Ip地址
	private String hostIp;

	// 要連線的遠端伺服器在監聽的埠
	private int hostListenningPort;

	/**
	 * 建構函式
	 * 
	 * @param HostIp
	 * @param HostListenningPort
	 * @throws IOException
	 */
	public TCPClient(String HostIp, int HostListenningPort) throws IOException {
		this.hostIp = HostIp;
		this.hostListenningPort = HostListenningPort;

		initialize();
	}

	/**
	 * 初始化
	 * 
	 * @throws IOException
	 */
	private void initialize() throws IOException {
		// 開啟監聽通道並設定為非阻塞模式
		socketChannel = SocketChannel.open(new InetSocketAddress(hostIp, hostListenningPort));
		socketChannel.configureBlocking(false);

		// 開啟並註冊選擇器到通道
		selector = Selector.open();
		socketChannel.register(selector, SelectionKey.OP_READ);

		// 啟動讀取執行緒
		new TCPClientReadThread(selector);
	}

	/**
	 * 傳送字串到伺服器
	 * 
	 * @param message
	 * @throws IOException
	 */
	public void sendMsg(String message) throws IOException {
		ByteBuffer writeBuffer = ByteBuffer.wrap(message.getBytes("UTF-16"));
		
		int r = socketChannel.write(writeBuffer);
		System.out.println("write return:" + r);
		//socketChannel.
	}

	public static void main(String[] args) throws IOException {
		TCPClient client = new TCPClient("10.10.24.67", 1978);
		for(int i=0; i<10; i++){
			client.sendMsg("Nio" + i);
			/*try {
				Thread.sleep(20);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}*/
		}
		
	}
}

TCPClientReadThread類：
package com.gw.demo;

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
import java.nio.charset.Charset;

public class TCPClientReadThread implements Runnable {
	private Selector selector;

	public TCPClientReadThread(Selector selector) {
		this.selector = selector;

		new Thread(this).start();
	}

	@Override
	public void run() {
		try {
			while (selector.select() > 0) {
				// 遍歷每個有可用IO操作Channel對應的SelectionKey
				for (SelectionKey sk : selector.selectedKeys()) {

					// 如果該SelectionKey對應的Channel中有可讀的資料
					if (sk.isReadable()) {
						// 使用NIO讀取Channel中的資料
						SocketChannel sc = (SocketChannel) sk.channel();
						ByteBuffer buffer = ByteBuffer.allocate(1024);
						sc.read(buffer);
						buffer.flip();

						// 將位元組轉化為為UTF-16的字串
						String receivedString = Charset.forName("UTF-16").newDecoder().decode(buffer).toString();

						// 控制檯打印出來
						System.out.println("接收到來自伺服器" + sc.socket().getRemoteSocketAddress() + "的資訊:" + receivedString);

						// 為下一次讀取作準備
						sk.interestOps(SelectionKey.OP_READ);
					}

					// 刪除正在處理的SelectionKey
					selector.selectedKeys().remove(sk);
				}
			}
		} catch (IOException ex) {
			ex.printStackTrace();
		}
	}
}


服務端輸出如下：

獨自等待.
獨自等待.
acceptable
readable
接收到來自/10.10.24.67:57863的資訊:Nio0Nio1Nio2Nio3Nio4Nio5Nio6
readable
接收到來自/10.10.24.67:57863的資訊:Nio7Nio8Nio9

客戶端輸出如下：

接收到來自伺服器/10.10.24.67:1978的資訊:你好,客戶端. @2015-18-23 15:18:06，已經收到你的資訊:Nio0Nio1Nio2Nio3Nio4Nio5Nio6你好,客戶端. @2015-18-23 15:18:06，已經收到你的資訊:Nio7Nio8Nio9

說明：客戶端迴圈十次，呼叫sendMsg，但是伺服器端只接收到了兩次訊息（不固定，多次執行，甚至只會接收到一次訊息），客戶端只收到了一次訊息。這是為什麼呢？

在client的買方法中，增加Thread.sleep(20);語句後。

服務端輸出如下：

獨自等待.
acceptable
readable
接收到來自/10.10.24.67:58343的資訊:Nio0
readable
接收到來自/10.10.24.67:58343的資訊:Nio1
readable
接收到來自/10.10.24.67:58343的資訊:Nio2
readable
接收到來自/10.10.24.67:58343的資訊:Nio3
readable
接收到來自/10.10.24.67:58343的資訊:Nio4
readable
接收到來自/10.10.24.67:58343的資訊:Nio5
readable
接收到來自/10.10.24.67:58343的資訊:Nio6
readable
接收到來自/10.10.24.67:58343的資訊:Nio7
readable
接收到來自/10.10.24.67:58343的資訊:Nio8
readable
接收到來自/10.10.24.67:58343的資訊:Nio9

客戶端輸出如下：

接收到來自伺服器/10.10.24.67:1978的資訊:你好,客戶端. @2015-31-23 15:31:56，已經收到你的資訊:Nio0你好,客戶端. @2015-31-23 15:31:56，已經收到你的資訊:Nio1
write return:10
接收到來自伺服器/10.10.24.67:1978的資訊:你好,客戶端. @2015-31-23 15:31:56，已經收到你的資訊:Nio2
write return:10
接收到來自伺服器/10.10.24.67:1978的資訊:你好,客戶端. @2015-31-23 15:31:56，已經收到你的資訊:Nio3
write return:10
接收到來自伺服器/10.10.24.67:1978的資訊:你好,客戶端. @2015-31-23 15:31:56，已經收到你的資訊:Nio4
write return:10
接收到來自伺服器/10.10.24.67:1978的資訊:你好,客戶端. @2015-31-23 15:31:56，已經收到你的資訊:Nio5
write return:10
接收到來自伺服器/10.10.24.67:1978的資訊:你好,客戶端. @2015-31-23 15:31:56，已經收到你的資訊:Nio6
write return:10
接收到來自伺服器/10.10.24.67:1978的資訊:你好,客戶端. @2015-31-23 15:31:56，已經收到你的資訊:Nio7
write return:10
接收到來自伺服器/10.10.24.67:1978的資訊:你好,客戶端. @2015-31-23 15:31:56，已經收到你的資訊:Nio8
write return:10
接收到來自伺服器/10.10.24.67:1978的資訊:你好,客戶端. @2015-31-23 15:31:56，已經收到你的資訊:Nio9

將TCPClient類的main方法改成如下形式：

public static void main(String[] args) throws IOException {
		class MyThread extends Thread{
			int i;
			TCPClient client ;
			
			public MyThread(TCPClient client, int index) {
				i = index;
				this.client = client;
			}
			
			@Override
			public void run() {
				try {
					client.sendMsg("Nio" + i);
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
		
		TCPClient client = new TCPClient("10.10.24.67", 1978);
		for(int i=0; i<10; i++){
			new MyThread(client, i).start();
			
		}
		
	}

伺服器端輸出如下：

獨自等待.
acceptable
readable
接收到來自/10.10.24.67:58503的資訊:Nio1
readable
接收到來自/10.10.24.67:58503的資訊:Nio0Nio3Nio2Nio4Nio6Nio8Nio5Nio7Nio9

客戶端輸出如下：

接收到來自伺服器/10.10.24.67:1978的資訊:你好,客戶端. @2015-38-23 15:38:52，已經收到你的資訊:Nio1你好,客戶端. @2015-38-23 15:38:52，已經收到你的資訊:Nio0Nio3Nio2Nio4Nio6Nio8Nio5Nio7Nio9

相關推薦

7.Java NIO系列教程之Server/Client完整示例

TCPServer類： package com.gw.demo; import java.io.IOException; import java.net.InetSocketAddress; import java.nio.channels.SelectionKey;

8.Java NIO系列教程之FileChannel

Java NIO中的FileChannel是一個連線到檔案的通道。可以通過檔案通道讀寫檔案。 FileChannel無法設定為非阻塞模式，它總是執行在阻塞模式下。 開啟FileChannel 在使用FileChannel之前，必須先開啟它。但是，我們無法直接開啟一

【轉】【NIO】Java NIO系列教程

http://ifeve.com/overview/ http://ifeve.com/java-nio-all/ https://www.cnblogs.com/duanxz/p/6759689.html   原文連結     作者：Jako

Java NIO系列教程（十二） Java NIO 與 IO

Java NIO系列教程（十二） Java NIO 與 IO 當學習了 Java NIO 和 IO 的 API 後，一個問題馬上湧入腦海： 我應該何時使用 IO，何時使用 NIO 呢？在本文中，我會盡量清晰地解析 Java NIO 和 IO 的差異、它們的使用場景，以及它們如何影響您的程式碼設計。 下表

Java NIO系列教程（一） Java NIO 概述

Java NIO 由以下幾個核心部分組成： Channels Buffers Selectors 雖然Java NIO 中除此之外還有很多類和元件，但在我看來，Channel，Buffer 和 Selector 構成了核心的API。其它元件，如P

Java NIO系列教程（二） Channel

Java NIO的通道類似流，但又有些不同： 既可以從通道中讀取資料，又可以寫資料到通道。但流的讀寫通常是單向的。 通道可以非同步地讀寫。 通道中的資料總是要先讀到一個Buffer，或者總是要從一個Buffer中寫入。 正如上面所說，從通道讀取資

java nio系列教程(2)---channel(通道介紹)和使用

大家推薦個靠譜的公眾號程式設計師探索之路，大家一起加油 ​   package com.zzh.buffer; import com.google.common.collect.Lists; import org.junit.jupiter.api.Test; imp

java nio 系列教程(1)----buffer介紹和使用方法

大家推薦個靠譜的公眾號程式設計師探索之路，大家一起加油 ​   package com.zzh.buffer; import org.junit.jupiter.api.Test; import java.nio.ByteBuffer; /** * 一.緩衝區(b

Java NIO系列教程（十 五）Java NIO Path

原文連結  譯者：章筱虎 Path介面是java NIO2的一部分。首次在java 7中引入。Path介面在java.nio.file包下，所以全稱是java.nio.file.Path。 java中的Path表示檔案系統的路徑。可以指向檔案或資料夾。也有相對路徑和絕對路徑之分。絕對路徑表示從

Java NIO系列教程（四） Scatter/Gather

作者：Jakob Jenkov   譯者：郭蕾    Java NIO開始支援scatter/gather，scatter/gather用於描述從Channel（譯者注：Channel在中文經常翻譯為通道）中讀取或者寫入到Channel的操作。 分散（scatter）從Channel中讀取是

Java NIO系列教程（七） FileChannel

原文連結     作者：Jakob Jenkov     譯者：周泰      校對：丁一 Java NIO中的FileChannel是一個連線到檔案的通道。可以通過檔案通道讀寫檔案。 FileChannel無法設定為非阻塞模式，它總是執行在阻塞模式下。 開啟FileChannel 在使用F

Java NIO系列教程（九） ServerSocketChannel

原文連結     作者：Jakob Jenkov     譯者：鄭玉婷      校對：丁一 Java NIO中的 ServerSocketChannel 是一個可以監聽新進來的TCP連線的通道, 就像標準IO中的ServerSocket一樣。ServerSocketChannel類在 jav

Java NIO系列教程（十一） Pipe

原文連結     作者：Jakob Jenkov     譯者：黃忠       校對：丁一 Java NIO 管道是2個執行緒之間的單向資料連線。Pipe有一個source通道和一個sink通道。資料會被寫到sink通道，從source通道讀取。 這裡是Pipe原理的圖示： 建立管道 通

Java NIO系列教程（五） 通道之間的資料傳輸

作者：Jakob Jenkov   譯者：郭蕾     校對：周泰 在Java NIO中，如果兩個通道中有一個是FileChannel，那你可以直接將資料從一個channel（譯者注：channel中文常譯作通道）傳輸到另外一個channel。 transferFrom() FileChan

Java NIO系列教程（十） Java NIO DatagramChannel

原文連結    作者：Jakob Jenkov    譯者：鄭玉婷     校對：丁一 Java NIO中的DatagramChannel是一個能收發UDP包的通道。因為UDP是無連線的網路協議，所以不能像其它通道那樣讀取和寫入。它傳送和接收的是資料包。 開啟 DatagramChannel

Java NIO系列教程（十二） Java NIO與IO

作者：Jakob Jenkov   譯者：郭蕾    校對：方騰飛 當學習了Java NIO和IO的API後，一個問題馬上湧入腦海： 我應該何時使用IO，何時使用NIO呢？在本文中，我會盡量清晰地解析Java NIO和IO的差異、它們的使用場景，以及它們如何影響您的程式碼設計。 Java

Java NIO系列教程（三） Buffer

原文連結     作者：Jakob Jenkov     譯者：airu     校對：丁一 Java NIO中的Buffer用於和NIO通道進行互動。如你所知，資料是從通道讀入緩衝區，從緩衝區寫入到通道中的。 緩衝區本質上是一塊可以寫入資料，然後可以從中讀取資料的記憶體。這塊記憶體被包裝成N

Java NIO系列教程（六） Selector

原文連結 作者：Jakob Jenkov 譯者：浪跡v 校對：丁一 Selector（選擇器）是Java NIO中能夠檢測一到多個NIO通道，並能夠知曉通道是否為諸如讀寫事件做好準備的元件。這樣，一個單獨的執行緒可以管理多個channel，從而管理多個網路連線。 下面是本文所涉及到的主題列表：

Java NIO系列教程（八） SocketChannel

原文連結     作者：Jakob Jenkov     譯者：鄭玉婷      校對：丁一 Java NIO中的SocketChannel是一個連線到TCP網路套接字的通道。可以通過以下2種方式建立SocketChannel： 開啟一個SocketChannel並連線到網際網路上的某臺伺服

Java NIO 系列教程

原文地址 作者：Jakob Jenkov   譯者：郭蕾    校對：方騰飛 Java NIO(New IO)是一個可以替代標準Java IO API的IO API（從Java 1.4開始)，Java NIO提供了與標準IO不同的IO工作方式。 Java NIO: Channels and B