2025年1月22日星期三

Java 7 to 17 Socket

一、前言

一、前言

Socket 程式設計是網路應用的基礎，Java 作為廣泛使用的程式語言，其 Socket API 的發展也備受關注。從 Java 7 到 Java 17，雖然 Socket API 的核心功能沒有發生根本性的改變，但仍然有一些重要的改進和新特性，旨在提升開發效率、性能以及安全性。本文將整理並分析 Java 7 至 17 中關於 Socket 相關的新特性，並提供相關範例，以幫助開發者更好地理解和應用。

目錄

一、前言
- 目錄
二、傳統阻塞式 Socket 範例
三、Java 7 中的 NIO.2 與 Asynchronous SocketChannel
四、Java 8 的非同步程式設計簡化：Lambda 與 CompletableFuture
五、Java 9 及以後的版本：模組化與安全性
六、Java 13 - JEP 353
七、Java 15 - JEP 373
八、總結

二、傳統阻塞式 Socket 範例

本章節提供一個傳統阻塞式 Socket 的簡單範例，方便後續與非阻塞式 Socket 進行比較。我們將建立一個簡單的 BlockingServer 和 BlockingClient 。

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.time.ZonedDateTime;
import java.util.Random;

public class BlockingServer {
    public static void main(String[] args) throws IOException {
        // 印出伺服器啟動訊息
        System.out.println("Blocking Server started on port 5455");
        // 使用 try-with-resources 語法，確保 ServerSocket 在程式碼結束時自動關閉
        try (ServerSocket serverSocket = new ServerSocket(5455)) {
            // 無限循環，持續接受新的連線
            while (true) {
                // 1. 接受客戶端連線，這是一個阻塞式操作
                Socket clientSocket = serverSocket.accept();
                // 印出客戶端連線訊息
                System.out.println("Blocking Server: Client connected: " + clientSocket.getInetAddress());

                // 使用 try-with-resources 語法，確保 BufferedReader 和 PrintWriter 在程式碼結束時自動關閉
                try (BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
                        PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true);) {
                    String inputLine;
                     // 2. 無限循環讀取客戶端發來的訊息，是一個阻塞式操作
                    while ((inputLine = in.readLine()) != null) {
                        // 印出收到的訊息和當前時間
                        System.out.println("[" + ZonedDateTime.now() + "]" + "Blocking Server Received: " + inputLine);
                        // 模擬伺服器處理延遲
                        Thread.sleep(new Random().nextInt(500) + 500);
                         // 3. 回應客戶端
                        out.println("Hello Client! I received: " + inputLine);
                    }
                } catch (Exception ex) {
                    // 捕捉程式執行時發生的例外並印出錯誤訊息
                    System.out.println("Blocking Server Exception: " + ex.getMessage());
                } finally {
                    // 確保客戶端連線 socket 關閉
                     clientSocket.close();
                }
            }
        } catch (IOException e) {
            // 捕捉初始化 ServerSocket 時發生的例外並印出錯誤訊息
            System.out.println("Blocking Server Socket Exception: " + e.getMessage());
        }
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;
import java.time.ZonedDateTime;

public class BlockingClient {
    public static void main(String[] args) throws IOException {
        // 設定要發送的訊息數量
        int numMessages = 3;
        try {
            // 1. 建立連線到伺服器，是一個阻塞式操作
            Socket socket = new Socket("localhost", 5455);
            // 建立 PrintWriter 用於向伺服器發送訊息
            PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
            // 建立 BufferedReader 用於接收伺服器發來的訊息
            BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            // 2. 迴圈發送指定數量的訊息給伺服器
            for (int i = 0; i < numMessages; i++) {
                String message = "Blocking Hello Server! - " + i; // 建立訊息
                out.println(message); // 發送訊息到伺服器
                // 3. 接收伺服器的回應，是一個阻塞式操作
                String response = in.readLine();
                // 印出伺服器回應訊息和時間
                System.out.println("[" + ZonedDateTime.now() + "]" + "Blocking Client Received: " + response);
                Thread.sleep(100); // 加入小延遲
            }
            // 4. 關閉客戶端 socket 連線
            socket.close();
        } catch (Exception ex) {
            // 捕捉程式執行時發生的例外並印出錯誤訊息
            System.out.println("Blocking Client Exception:" + ex.getMessage());
        }
    }
}

啟動服務器：

$ javac -encoding utf-8 BlockingServer.java && java -Dfile-encoding=utf-8 BlockingServer
Blocking Server started on port 5455

執行客戶端：

$ javac -encoding utf-8 BlockingClient.java && java -Dfile-encoding=utf-8 BlockingClient
[2025-01-21T11:17:41.357950100+08:00[Asia/Taipei]]Blocking Client Received: Hello Client! I received: Blocking Hello Server! - 0
[2025-01-21T11:17:42.048108900+08:00[Asia/Taipei]]Blocking Client Received: Hello Client! I received: Blocking Hello Server! - 1
[2025-01-21T11:17:43.108937300+08:00[Asia/Taipei]]Blocking Client Received: Hello Client! I received: Blocking Hello Server! - 2

查看服務器日誌：

Blocking Server: Client connected: /127.0.0.1
[2025-01-21T11:17:40.722456100+08:00[Asia/Taipei]]Blocking Server Received: Blocking Hello Server! - 0
[2025-01-21T11:17:41.464008600+08:00[Asia/Taipei]]Blocking Server Received: Blocking Hello Server! - 1
[2025-01-21T11:17:42.150854900+08:00[Asia/Taipei]]Blocking Server Received: Blocking Hello Server! - 2

三、Java 7 中的 NIO.2 與 Asynchronous SocketChannel

Java 7 最大的網路程式設計改進之一是引入了 NIO.2 (New Input/Output 2) 框架，其中最重要的特性是 AsynchronousSocketChannel 。

(3.1) `AsynchronousSocketChannel` 的優勢

非阻塞 I/O: 相比於傳統的阻塞式 Socket ， AsynchronousSocketChannel 允許程式碼在 I/O 操作完成前繼續執行，不會被阻塞。這提高了網路應用的吞吐量和響應速度。
基於回呼 (Callback) 或 Future: 使用 AsynchronousSocketChannel 時，可以選擇使用回呼函式或 Future 來獲取 I/O 操作的結果。
異步操作: 提供了 connect , read , write 等異步操作，使得網路程式設計更具效率。

(3.2) 架構

AsynchronousSocketChannel 的架構基於 AsynchronousChannelGroup ，後者管理著底層的作業系統線程池，負責非同步 I/O 操作。開發者不需要直接管理線程，這降低了程式設計的複雜度。

(3.3) 工具與範例

範例:

非同步伺服器 ( AsyncServer.java )

import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousServerSocketChannel;
import java.nio.channels.AsynchronousSocketChannel;
import java.nio.channels.CompletionHandler;
import java.util.Random;
import java.io.IOException;
import java.nio.charset.StandardCharsets;

public class AsyncServer {
    // 定義結束訊息常數，用於標示訊息的結束
    private static final String END_MESSAGE = "END";

    public static void main(String[] args) throws Exception {
        // 1. 開啟一個非同步的伺服器 socket channel
        AsynchronousServerSocketChannel serverSocket = AsynchronousServerSocketChannel.open();
        // 2. 綁定伺服器到指定的 IP 地址和端口
        InetSocketAddress hostAddress = new InetSocketAddress("localhost", 5454);
        serverSocket.bind(hostAddress);
        System.out.println("Async Server started on port 5454");
        // 3. 開始非同步接受連線請求
        accept(serverSocket);
        // 4. 保持主線程運行，避免程式結束
        Thread.currentThread().join();
    }

    // 遞迴地非同步接受連線
    private static void accept(AsynchronousServerSocketChannel serverSocket) {
        serverSocket.accept(null, new CompletionHandler<AsynchronousSocketChannel, Void>() {
            // 當有客戶端連線建立時執行
            @Override
            public void completed(AsynchronousSocketChannel clientSocket, Void attachment) {
                accept(serverSocket); // 繼續接受下一個連線
                handleClient(clientSocket); // 處理客戶端連線
            }

            // 當接受連線失敗時執行
            @Override
            public void failed(Throwable exc, Void attachment) {
                System.out.println("Accept failed: " + exc.getMessage());
                accept(serverSocket); // 嘗試繼續接受連線
            }
        });
    }

    // 處理客戶端連線
    private static void handleClient(AsynchronousSocketChannel clientSocket) {
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        // 1. 非同步讀取客戶端資料
        clientSocket.read(buffer, buffer, new CompletionHandler<Integer, ByteBuffer>() {
            // 當讀取操作完成時執行
            @Override
            public void completed(Integer result, ByteBuffer attachment) {
                // 如果 result 為 -1，表示連線已經關閉，則關閉 socket 並結束
                if (result == -1) {
                    try {
                        clientSocket.close();
                    } catch (IOException ex) {
                        System.out.println("Error closing connection: " + ex.getMessage());
                    }
                    return;
                }
                attachment.flip(); // 準備從 buffer 讀取資料
                byte[] input = new byte[attachment.remaining()];
                attachment.get(input); // 從 buffer 讀取資料
                String message = new String(input, StandardCharsets.UTF_8); // 將資料轉為字串
                System.out.println("Async Server Received: " + message); // 印出收到的訊息

                // 建立回傳訊息
                String response = "Hello Client! I received: " + message;
                ByteBuffer responseBuffer = ByteBuffer.wrap(response.getBytes(StandardCharsets.UTF_8));

                // 2. 非同步分段寫入回覆訊息
                writeChunked(clientSocket, responseBuffer, new CompletionHandler<Void, Void>() {
                    // 資料分段寫入完成後，發送結束訊息
                    @Override
                    public void completed(Void result, Void attachment) {
                        sendEndMessage(clientSocket);
                    }

                    // 資料分段寫入失敗時執行
                    @Override
                    public void failed(Throwable exc, Void attachment) {
                        System.out.println("Write failed: " + exc.getMessage());
                        try {
                            clientSocket.close();
                        } catch (IOException e) {
                            System.out.println("Error closing socket: " + e.getMessage());
                        }
                    }
                });

                buffer.clear(); // 清空 buffer，準備讀取下一個訊息
                clientSocket.read(buffer, buffer, this); // 遞迴呼叫 read 方法，準備讀取下一個訊息

            }

            // 當讀取操作失敗時執行
            @Override
            public void failed(Throwable exc, ByteBuffer attachment) {
                System.out.println("Read failed: " + exc.getMessage());
                try {
                    clientSocket.close();
                } catch (IOException e) {
                    System.out.println("Error closing socket: " + e.getMessage());
                }
            }
        });
    }

    // 非同步分段寫入訊息
    private static void writeChunked(AsynchronousSocketChannel clientSocket, ByteBuffer buffer,
            CompletionHandler<Void, Void> completionHandler) {
        // 1. 檢查是否還有資料要發送
        if (!buffer.hasRemaining()) {
            completionHandler.completed(null, null); // 資料發送完畢，執行 callback
            return;
        }

        // 2. 決定這次發送的資料大小 (6-13 bytes)
        int chunkSize = new Random().nextInt(6) + 8;
        int remaining = buffer.remaining();
        int bytesToSend = Math.min(chunkSize, remaining);

        // 3. 建立新的 ByteBuffer，儲存這次要發送的資料
        ByteBuffer chunk = ByteBuffer.allocate(bytesToSend);
        for (int i = 0; i < bytesToSend; i++) {
            chunk.put(buffer.get());
        }
        chunk.flip(); // 準備從 buffer 讀取資料

        // 4. 非同步寫入部分資料到 client socket
        clientSocket.write(chunk, chunk, new CompletionHandler<Integer, ByteBuffer>() {
            // 當寫入操作完成時執行
            @Override
            public void completed(Integer result, ByteBuffer attachment) {
                try {
                    Thread.sleep(new Random().nextInt(100) + 100); // 加入隨機延遲
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                writeChunked(clientSocket, buffer, completionHandler); // 遞迴呼叫 writeChunked，繼續發送剩餘的資料
            }

            // 當寫入操作失敗時執行
            @Override
            public void failed(Throwable exc, ByteBuffer attachment) {
                System.out.println("Write failed: " + exc.getMessage());
                try {
                    clientSocket.close(); // 關閉連線
                } catch (IOException e) {
                    System.out.println("Error closing socket: " + e.getMessage());
                }
                completionHandler.failed(exc, null); // 執行 callback 的 failed 方法
            }
        });
    }

    // 非同步發送結束訊息
    private static void sendEndMessage(AsynchronousSocketChannel clientSocket) {
        ByteBuffer endBuffer = ByteBuffer.wrap(END_MESSAGE.getBytes(StandardCharsets.UTF_8));
        clientSocket.write(endBuffer, endBuffer, new CompletionHandler<Integer, ByteBuffer>() {
            // 當寫入操作完成時執行
            @Override
            public void completed(Integer result, ByteBuffer attachment) {
                // Do nothing
            }

            // 當寫入操作失敗時執行
            @Override
            public void failed(Throwable exc, ByteBuffer attachment) {
                System.out.println("Write failed: " + exc.getMessage());
                try {
                    clientSocket.close();
                } catch (IOException e) {
                    System.out.println("Error closing socket: " + e.getMessage());
                }
            }
        });
    }
}

說明:

使用 AsynchronousServerSocketChannel.open() 建立伺服器通道。
使用 serverSocket.bind(hostAddress) 綁定伺服器地址和埠號。
使用 serverSocket.accept(null, handler) 異步接受客戶端連接，並提供 CompletionHandler 來處理接受連線之後的操作。
在 handleClient 方法裡處理 client 的請求，使用 clientSocket.read() 異步讀取訊息。
將讀取的訊息回應給 client，並將 connection 關閉。

非同步客戶端 ( AsyncClient.java )

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousSocketChannel;
import java.nio.channels.CompletionHandler;
import java.util.concurrent.CountDownLatch;
import java.nio.charset.StandardCharsets;

public class AsyncClient {
    // 定義結束訊息常數，用於標示訊息的結束
    private static final String END_MESSAGE = "END";

    public static void main(String[] args) throws Exception {
        // 設定目標連線數量
        int targetNumMessages = 3;
        // 宣告一個 AsynchronousSocketChannel 陣列，用於儲存連線
        AsynchronousSocketChannel[] clients = new AsynchronousSocketChannel[targetNumMessages];
        // 設定伺服器的 IP 地址和端口
        InetSocketAddress hostAddress = new InetSocketAddress("localhost", 5454);

        int realNumMessage = 0; // 實際建立的連線數量
        // 1. 迴圈建立 AsynchronousSocketChannel 連線，並紀錄連線數量
        for (int i = 0; i < targetNumMessages; i++) {
            try {
                clients[i] = AsynchronousSocketChannel.open(); // 開啟新的 AsynchronousSocketChannel
                clients[i].connect(hostAddress).get(); // 連接到伺服器 (使用 get() 等待連線建立)
                realNumMessage++; // 連線成功，遞增計數器
            } catch (Exception e) {
                e.printStackTrace(); // 連線失敗，印出錯誤訊息
            }
        }
        // 檢查是否有連線建立
        if (realNumMessage == 0) {
            System.out.println("realNumMessage=" + realNumMessage + ", 沒有建立任何連線, 結束程序!");
            return; // 若沒有建立連線，則結束程式
        } else {
            System.out.println("已建立 " + realNumMessage + " 條連線."); // 印出已建立的連線數量
        }

        // 宣告一個 CountDownLatch，用於等待所有讀取操作完成
        CountDownLatch latch = new CountDownLatch(realNumMessage);

        // 2. 迴圈發送訊息到不同的客戶端
        for (int i = 0; i < realNumMessage; i++) {
            final int index = i; // 記錄目前客戶端的 index
            String message = "Async Hello Server! - " + index; // 建立要傳送的訊息
            ByteBuffer buffer = ByteBuffer.wrap(message.getBytes(StandardCharsets.UTF_8)); // 建立 ByteBuffer 來存放訊息

            // 非同步寫入資料到伺服器
            clients[index].write(buffer, buffer, new CompletionHandler<Integer, ByteBuffer>() {
                // 當寫入操作成功完成時執行
                @Override
                public void completed(Integer result, ByteBuffer attachment) {
                    StringBuffer sb = new StringBuffer(); // 建立 StringBuffer 用於儲存讀取到的資料
                    read(index, clients[index], latch, sb); // 開始讀取伺服器的回應
                }

                // 當寫入操作失敗時執行
                @Override
                public void failed(Throwable exc, ByteBuffer attachment) {
                    System.out.println("Write[" + index + "] failed: " + (exc == null ? "null" : exc.getMessage()));
                    try {
                        clients[index].close(); // 關閉連線
                    } catch (IOException e) {
                        System.out.println("Error closing socket: " + e.getMessage());
                    }
                }
            });
        }

        System.out.println("Main: before latch.await()");
        latch.await(); // 等待所有 read 操作完成
        System.out.println("Main: after latch.await()");

        // 3. 關閉所有連線
        for (int i = 0; i < realNumMessage; i++) {
            if (clients[i] != null) { //確認 `clients[i]` 不是 null，才關閉連線
                try {
                    clients[i].close();
                } catch (IOException e) {
                    System.out.println("Error closing socket: " + e.getMessage());
                }
            }
        }
        System.out.println("Main: End!");
    }

    // 遞迴處理非同步讀取操作，直到收到結束訊息
    private static void read(int index, AsynchronousSocketChannel client, CountDownLatch latch, StringBuffer sb) {
        // 配置 ByteBuffer 用於讀取資料
        ByteBuffer readBuffer = ByteBuffer.allocate(10); //設定每次讀取 10 Bytes
        // 開始非同步讀取操作
        client.read(readBuffer, readBuffer, new CompletionHandler<Integer, ByteBuffer>() {
            // 當讀取操作成功完成時執行
            @Override
            public void completed(Integer result, ByteBuffer attachment) {
                // 如果 result 為 -1，表示連線已經關閉，關閉連線並結束
                if (result == -1) {
                    try {
                        client.close();
                    } catch (Exception ex) {
                        System.out.println("Error closing socket[" + index + "]: " + ex.getMessage());
                    }
                    return;
                }
                attachment.flip(); // 準備從 buffer 讀取資料
                byte[] responseBytes = new byte[attachment.remaining()];
                attachment.get(responseBytes); // 從 buffer 讀取資料
                String response = new String(responseBytes, StandardCharsets.UTF_8); // 將資料轉為字串
                sb.append(response); // 將讀到的資料放入 StringBuffer
                System.out.println("Async Client Received[" + index + "]: " + response); // 印出收到的資料

                // 判斷是否收到結束訊息
                if (response.trim().contains(END_MESSAGE)) {
                    System.out.println("Read all message[" + index + "]: " + sb.toString()); // 印出所有資料
                    System.out.println("Read completed[" + index + "]: before latch.coutDown()");
                    latch.countDown(); // 遞減 latch
                    System.out.println("Read completed[" + index + "]: after latch.coutDown()");
                    try {
                        client.close();
                    } catch (Exception ex) {
                        System.out.println("Error closing socket[" + index + "]: " + ex.getMessage());
                    }
                    return;
                }
                readBuffer.clear(); // 清空 buffer，準備下一次讀取
                read(index, client, latch, sb); // 繼續讀取
            }

            // 當讀取操作失敗時執行
            @Override
            public void failed(Throwable exc, ByteBuffer attachment) {
                System.out.println("Read failed[" + index + "]: " + (exc == null ? "null" : exc.getMessage()));
                try {
                    Thread.sleep(100); // 加入延遲，避免快速重試導致資源耗盡
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
    }
}

說明:

使用 AsynchronousSocketChannel.open() 建立通道。
使用 client.connect(hostAddress) 連接伺服器，返回 Future<Void> 。
使用 client.write(buffer) 寫入資料，返回 Future<Integer> 。
使用 client.read(buffer) 讀取資料，返回 Future<Integer> 。
使用 Future.get() 等待非同步操作完成。

編譯與執行:

$ javac -encoding utf-8 AsyncServer.java && java -Dfile-encoding=utf-8 AsyncServer
Async Server started on port 5454

客戶端端 (AsyncClient.java) 輸出：

$ javac -encoding utf-8 AsyncClient.java && java -Dfile-encoding=utf-8 AsyncClient
已建立 3 條連線.
Main: before latch.await()
Async Client Received[2]: Hello Cl
Async Client Received[1]: Hello Clie
Async Client Received[1]: nt!
Async Client Received[0]: Hello Cli
Async Client Received[2]: ient! I re
Async Client Received[2]: c
Async Client Received[1]:  I receive
Async Client Received[1]: d
Async Client Received[0]: ent! I rec
Async Client Received[0]: eiv
Async Client Received[2]: eived: As
Async Client Received[0]: ed: Async
Async Client Received[0]: H
Async Client Received[1]: : Async
Async Client Received[2]: ync Hello
Async Client Received[2]: Se
Async Client Received[0]: ello Serve
Async Client Received[0]: r
Async Client Received[1]: Hello Serv
Async Client Received[2]: rver! - 2
Async Client Received[1]: er! - 1
Async Client Received[0]: ! - 0
Async Client Received[2]: END
Read all message[2]: Hello Client! I received: Async Hello Server! - 2END
Read completed[2]: before latch.coutDown()
Read completed[2]: after latch.coutDown()
Async Client Received[1]: END
Read all message[1]: Hello Client! I received: Async Hello Server! - 1END
Read completed[1]: before latch.coutDown()
Read completed[1]: after latch.coutDown()
Async Client Received[0]: END
Read all message[0]: Hello Client! I received: Async Hello Server! - 0END
Read completed[0]: before latch.coutDown()
Read completed[0]: after latch.coutDown()
Main: after latch.await()
Main: End!

建立多個連線：客戶端成功建立了 3 條連線。
非同步接收資料：由於伺服器是分段傳輸資料，你會看到客戶端依序收到伺服器回傳的部分訊息。並且每次讀取訊息的大小是有限制的，因此會出現分段讀取。
訊息接收順序不一致: 客戶端接收資料的順序，與發送訊息的順序不一定相同，這是因為 AsynchronousSocketChannel 是非同步運作。
StringBuffer 的作用：你會發現客戶端使用 StringBuffer 來儲存收到的訊息片段，當所有訊息都收到時 (也就是收到 END 的時候) ，才輸出完整的訊息。
收到 END_MESSAGE: 每個客戶端最後都收到了 END 訊息，這表示伺服器端成功傳送了結束訊息。
latch.countDown()：每個客戶端都成功遞減了 CountDownLatch 的計數器。
主執行緒等待：主執行緒在等待所有連線完成後，才繼續執行。

伺服器端 (AsyncServer.java) 輸出：

Async Server Received: Async Hello Server! - 2
Async Server Received: Async Hello Server! - 0
Async Server Received: Async Hello Server! - 1

非同步處理：從輸出的順序可以看出，伺服器可以同時處理多個客戶端的連線，並非按照連線建立的順序處理訊息。伺服器端先收到來自客戶端 2 的訊息，然後才收到客戶端 0 和客戶端 1 的訊息。這說明了伺服器端是非同步處理這些連線。
依序接收客戶端訊息: 可以看到訊息是由客戶端逐一發送的。
沒有錯誤產生: 可以確認伺服器端程式碼在執行過程中，沒有任何錯誤發生。

四、Java 8 的非同步程式設計簡化：Lambda 與 CompletableFuture

Java 8 引入了 Lambda 表達式和 CompletableFuture 等新特性，這些特性極大地簡化了非同步程式設計，讓程式碼更簡潔、易讀，也更易於維護。雖然這些特性並沒有直接修改 Socket API 本身，但是它們可以與 AsynchronousSocketChannel 完美配合，提升開發效率並降低非同步程式設計的複雜度。

(4.1) Lambda 表達式

Lambda 表達式是一種簡潔的匿名函式，可以把它們當作程式碼來傳遞，也可以用來簡化 CompletionHandler 的實作，尤其是在處理回呼函式時，可以避免撰寫大量的匿名內部類。

(4.1.1) 使用 Lambda 表達式簡化 `CompletionHandler`

在 Java 7 中，我們需要使用匿名內部類來實作 CompletionHandler ，這使得程式碼看起來有些冗長。

Java 7 匿名內部類範例：

client.connect(hostAddress, null, new CompletionHandler<Void, Void>() {
    @Override
    public void completed(Void result, Void attachment) {
        System.out.println("Connection completed!");
        // ... 執行連線後的程式碼
    }
    @Override
    public void failed(Throwable exc, Void attachment) {
        System.out.println("Connection failed: " + exc.getMessage());
    }
});

使用 Lambda 表達式後，程式碼可以簡化為：

Java 8 Lambda 表達式範例：

client.connect(hostAddress, null, (result, attachment) -> {
    System.out.println("Connection completed!");
    // ... 執行連線後的程式碼
}, (exc, attachment) -> {
    System.out.println("Connection failed: " + exc.getMessage());
});

程式碼簡潔： Lambda 表達式可以省略 new CompletionHandler<Void, Void>() 等冗長的程式碼。
程式碼易讀： 使用 Lambda 表達式可以更直接地呈現程式碼的意圖，提高了程式碼的可讀性。

(4.1.2) 範例：使用 Lambda 的非同步客戶端

以下是一個使用 Lambda 表達式來簡化 AsyncClient 程式碼的範例 (只展示部分程式碼，完整程式碼在下方)：

 client.connect(hostAddress, null, (result, attachment) -> {
            ByteBuffer buffer = ByteBuffer.wrap("Hello Server!".getBytes(StandardCharsets.UTF_8));
            client.write(buffer, buffer, (writeResult, writeAttachment) -> {
                ByteBuffer readBuffer = ByteBuffer.allocate(1024);
                client.read(readBuffer, readBuffer, (readResult, readAttachment) -> {
                    readBuffer.flip();
                    byte[] response = new byte[readBuffer.remaining()];
                    readBuffer.get(response);
                    System.out.println("Response from server: " + new String(response, StandardCharsets.UTF_8));
                }, (readExc, readAttachment) -> {
                       System.err.println("Read failed: " + readExc.getMessage());
                      try{
                         client.close();
                         } catch (IOException e){}
                 });
            }, (writeExc, writeAttachment) -> {
                System.err.println("Write failed: " + writeExc.getMessage());
                try{
                     client.close();
                  } catch (IOException e){}
             });
        }, (exc, attachment) -> {
            System.err.println("Connect failed: " + exc.getMessage());
            try{
                 client.close();
               } catch (IOException e){}
         });

(4.2) `CompletableFuture`

CompletableFuture 是 Java 8 引入的一個強大的非同步程式設計工具，它可以讓你更容易地管理非同步操作，並且可以方便地進行鏈式調用、錯誤處理、組合和轉換等操作。雖然 CompletableFuture 並沒有直接應用在 AsynchronousSocketChannel 的操作，但可以讓你更容易的處理非同步的操作。

(4.2.1) 將 `Future` 轉換為 `CompletableFuture`

AsynchronousSocketChannel 中的許多方法，會返回 Future 物件，你可以使用 CompletableFuture.supplyAsync() 或其他方法，將 Future 物件轉換成 CompletableFuture 物件。

範例：將 Future<Void> 轉換為 CompletableFuture<Void>

 Future<Void> connectFuture = client.connect(hostAddress);
 CompletableFuture<Void> connectCompletableFuture = CompletableFuture.supplyAsync(() -> {
        try{
           return connectFuture.get();
         } catch (Exception ex){
           throw new RuntimeException(ex);
        }
 });
  connectCompletableFuture.thenRun(() -> System.out.println("Connected"))
                        .exceptionally(ex -> {
                            System.err.println("Connection failed:" + ex.getMessage());
                            return null;
                        });

(4.2.2) `CompletableFuture` 的常用方法

thenApply(Function) : 執行一個 Function，並將上一個 CompletableFuture 的結果轉換為新的結果。
thenAccept(Consumer) : 執行一個 Consumer，接收上一個 CompletableFuture 的結果，但沒有新的結果。
thenRun(Runnable) : 執行一個 Runnable，不接收上一個 CompletableFuture 的結果，也沒有新的結果。
exceptionally(Function) : 當 CompletableFuture 發生錯誤時，執行一個 Function 來處理錯誤。
thenCompose(Function) : 將上一個 CompletableFuture 的結果傳給一個新的 CompletableFuture ，並返回新的 CompletableFuture 。
allOf(CompletableFuture...) : 等待所有提供的 CompletableFuture 都完成。
anyOf(CompletableFuture...) : 只要其中一個 CompletableFuture 完成，就完成。

(4.2.3) 範例：使用 `CompletableFuture` 的非同步客戶端

以下是一個使用 CompletableFuture 來簡化 AsyncClient 程式碼的範例 (只展示部分程式碼，完整程式碼在下方)：

  CompletableFuture<Void> connection =  CompletableFuture.supplyAsync(() -> {
            try{
               return client.connect(hostAddress).get();
             } catch (Exception ex){
                 throw new RuntimeException(ex);
            }
      });

    CompletableFuture<Integer> write =  connection.thenCompose(aVoid -> CompletableFuture.supplyAsync(() -> {
               ByteBuffer buffer = ByteBuffer.wrap("Hello Server!".getBytes(StandardCharsets.UTF_8));
                try {
                    return client.write(buffer).get();
                 } catch (Exception ex){
                     throw new RuntimeException(ex);
                 }
       }));

   CompletableFuture<byte[]> read =   write.thenCompose(integer -> CompletableFuture.supplyAsync(() ->{
                ByteBuffer readBuffer = ByteBuffer.allocate(1024);
                try{
                    client.read(readBuffer).get();
                    readBuffer.flip();
                    byte[] response = new byte[readBuffer.remaining()];
                    readBuffer.get(response);
                   return response;
                } catch (Exception ex){
                     throw new RuntimeException(ex);
                }
       }));

      read.thenAccept(bytes -> System.out.println("Server Response: " + new String(bytes, StandardCharsets.UTF_8)))
                .exceptionally(ex -> {
                     System.err.println("Error during IO operations:" + ex.getMessage());
                     return null;
                 }).thenRun(() -> {
                    try{
                         client.close();
                    } catch (IOException e){}
                });

(4.3) 範例程式碼

以下是使用 Lambda 表達式和 CompletableFuture 的 AsyncClientWithLambda 範例：

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousSocketChannel;
import java.nio.charset.StandardCharsets;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CountDownLatch;

public class AsyncClientWithLambda {
    private static final String END_MESSAGE = "END";

    public static void main(String[] args) throws Exception {
        // 設定目標連線數量
        int targetNumMessages = 3;
        // 宣告一個 AsynchronousSocketChannel 陣列，用於儲存連線
        AsynchronousSocketChannel[] clients = new AsynchronousSocketChannel[targetNumMessages];
        // 設定伺服器的 IP 地址和端口
        InetSocketAddress hostAddress = new InetSocketAddress("localhost", 5454);

        int realNumMessage = 0; // 實際建立的連線數量
        // 1. 迴圈建立 AsynchronousSocketChannel 連線，並紀錄連線數量
        for (int i = 0; i < targetNumMessages; i++) {
            try {
                clients[i] = AsynchronousSocketChannel.open(); // 開啟新的 AsynchronousSocketChannel
                clients[i].connect(hostAddress).get(); // 連接到伺服器 (使用 get() 等待連線建立)
                realNumMessage++; // 連線成功，遞增計數器
            } catch (Exception e) {
                e.printStackTrace(); // 連線失敗，印出錯誤訊息
            }
        }
        // 檢查是否有連線建立
        if (realNumMessage == 0) {
            System.out.println("realNumMessage=" + realNumMessage + ", 沒有建立任何連線, 結束程序!");
            return; // 若沒有建立連線，則結束程式
        } else {
            System.out.println("已建立 " + realNumMessage + " 條連線."); // 印出已建立的連線數量
        }

        // 宣告一個 CountDownLatch，用於等待所有讀取操作完成
        CountDownLatch latch = new CountDownLatch(realNumMessage);

        // 2. 迴圈處理每個客戶端的連線
        for (int i = 0; i < realNumMessage; i++) {
            final int index = i; // 記錄目前客戶端的 index
            final AsynchronousSocketChannel client = clients[i]; // 取得當前客戶端的 AsynchronousSocketChannel
            String message = "Async Hello Server! - " + index; // 建立要發送的訊息
            ByteBuffer buffer = ByteBuffer.wrap(message.getBytes(StandardCharsets.UTF_8)); // 建立 ByteBuffer 來存放訊息

            // 使用 CompletableFuture 處理非同步寫入操作
            CompletableFuture.supplyAsync(() -> {
                try {
                    return client.write(buffer).get(); // 非同步寫入訊息，並返回 CompletableFuture
                } catch (Exception ex) {
                    throw new RuntimeException(ex); // 如果發生例外則拋出 RuntimeException
                }
            })
                    .thenAccept(result -> read(index, client, latch, new StringBuffer())) // 寫入完成後執行 read 操作
                    .exceptionally(ex -> {
                        System.out.println("Write[" + index + "] failed: " + (ex == null ? "null" : ex.getMessage())); // 印出寫入錯誤訊息
                        try {
                            client.close(); // 關閉連線
                        } catch (IOException e) {
                            System.out.println("Error closing socket: " + e.getMessage()); // 印出關閉錯誤訊息
                        }
                        return null; // 返回 null 避免中斷 CompletableFuture 鏈
                    });
        }

        System.out.println("Main: before latch.await()");
        latch.await(); // 等待所有讀取操作完成
        System.out.println("Main: after latch.await()");

        // 3. 關閉所有連線
        for (int i = 0; i < realNumMessage; i++) {
            if (clients[i] != null) { //確認 `clients[i]` 不是 null
                try {
                    clients[i].close(); // 關閉連線
                } catch (IOException e) {
                    System.out.println("Error closing socket: " + e.getMessage()); // 印出關閉錯誤訊息
                }
            }
        }
        System.out.println("Main: End!"); // 印出程式結束訊息
    }

    // 遞迴處理非同步讀取操作，直到收到結束訊息
    private static void read(int index, AsynchronousSocketChannel client, CountDownLatch latch, StringBuffer sb) {
        // 配置 ByteBuffer 用於讀取資料
        ByteBuffer readBuffer = ByteBuffer.allocate(10); //設定每次讀取 10 Bytes
        // 使用 CompletableFuture 處理非同步讀取操作
        CompletableFuture.supplyAsync(() -> {
            try {
                return client.read(readBuffer).get(); // 非同步讀取訊息，並返回 CompletableFuture
            } catch (Exception ex) {
                throw new RuntimeException(ex); // 如果發生例外則拋出 RuntimeException
            }
        })
                .thenCompose(result -> {
                    if (result == -1) { // 如果 result 為 -1，表示連線已經關閉，關閉連線並返回
                        try {
                            client.close(); // 關閉連線
                        } catch (Exception ex) {
                            System.out.println("Error closing socket[" + index + "]: " + ex.getMessage()); // 印出關閉錯誤訊息
                        }
                        return CompletableFuture.completedFuture(null); // 返回一個空的 CompletableFuture，表示連線已關閉
                    }
                    return CompletableFuture.completedFuture(readBuffer); // 返回包含了 readBuffer 的 CompletableFuture
                })
                .thenAccept(attachment -> { // 使用 thenAccept 接收上一步的 ByteBuffer
                    if (attachment == null) {
                        return; // 如果是空的，則不再執行讀取操作。
                    }
                    attachment.flip(); // 準備從 buffer 讀取資料
                    byte[] responseBytes = new byte[attachment.remaining()];
                    attachment.get(responseBytes); // 從 buffer 讀取資料
                    String response = new String(responseBytes, StandardCharsets.UTF_8); // 將資料轉為字串
                    sb.append(response); // 將讀到的資料放入 StringBuffer
                    System.out.println("Async Client Received[" + index + "]: " + response); // 印出收到的資料
                    // 判斷是否收到結束訊息
                    if (response.trim().contains(END_MESSAGE)) {
                        System.out.println("Read all message[" + index + "]: " + sb.toString()); // 印出所有資料
                        System.out.println("Read completed[" + index + "]: before latch.coutDown()"); // 印出計數器遞減前的訊息
                        latch.countDown(); // 遞減 latch
                        System.out.println("Read completed[" + index + "]: after latch.coutDown()"); // 印出計數器遞減後的訊息
                        try {
                            client.close(); // 關閉連線
                        } catch (Exception ex) {
                            System.out.println("Error closing socket[" + index + "]: " + ex.getMessage()); // 印出關閉錯誤訊息
                        }
                        return; // 結束當前 read 操作
                    }
                    readBuffer.clear(); // 清空 buffer，準備下一次讀取
                    read(index, client, latch, sb); // 遞迴呼叫 read 方法，繼續讀取
                })
                .exceptionally(ex -> { // 如果讀取失敗，執行此區塊
                    System.out.println("Read failed[" + index + "]: " + (ex == null ? "null" : ex.getMessage())); // 印出錯誤訊息
                    try {
                        Thread.sleep(100); // 延遲 100 毫秒，避免頻繁重試
                    } catch (InterruptedException e) {
                        e.printStackTrace(); // 印出例外堆疊
                    }
                    return null; // 返回 null 避免中斷 CompletableFuture 鏈
                });
    }
}

說明:

主要結構： 程式碼保持了多個連線的建立、訊息的發送和讀取、以及等待所有連線完成的整體結構。
CompletableFuture for write: 使用 CompletableFuture.supplyAsync 包裝 client.write() 操作，讓寫入操作非同步進行，並且使用了 thenAccept 串聯後續的 read 操作。
CompletableFuture for read: 使用 CompletableFuture 包裝 client.read() 操作，使用 thenCompose 傳遞 ByteBuffer，讓讀取操作非同步進行。
Lambda 表達式： 使用了 Lambda 表達式來簡化 CompletionHandler 的實作，使程式碼更簡潔易讀。
非同步處理： 所有的網路操作（建立連線，發送訊息、接收訊息）都使用非同步的方式執行，避免主線程被阻塞。
END_MESSAGE： 程式碼依然會持續讀取直到收到 END_MESSAGE，才結束該次連線的讀取流程。
try-catch： 在 CompletableFuture 的 supplyAsync 方法中使用 try-catch 區塊來處理例外。
錯誤處理： 在 exceptionally 方法中，加入了錯誤訊息的輸出，確保錯誤可以被記錄。
鏈式調用： 使用 thenCompose 和 thenAccept 方法來進行鏈式調用，使程式碼的邏輯更為清晰。

五、Java 9 及以後的版本：模組化與安全性

Java 9 引入了模組化 (Project Jigsaw) 系統，以及後續版本對安全性的持續改進，這些都對 Java 的網路程式設計產生了間接但重要的影響。讓我們深入探討這些方面的內容：

(5.1) 模組化 (Project Jigsaw)

Java 9 最大的變革之一就是引入了模組化系統，也稱為 Project Jigsaw。這項改進的主要目標是：

強化封裝： 模組化提供了更嚴格的封裝機制，允許開發者明確聲明哪些類別和套件 (package) 可以被其他模組存取，哪些則不允許，從而減少不必要的依賴和避免程式碼的隱性耦合。
提高程式碼的可維護性： 通過模組化，程式碼被分解為更小的、更具明確定義的單元，使得程式碼的組織和管理更加容易。
降低依賴衝突： 模組化讓程式碼依賴更明確，減少了不同函式庫之間版本衝突的可能性。
增強平台的安全性： 通過模組化，可以更精細地控制哪些模組可以存取底層系統資源，從而減少安全漏洞的潛在風險。

(5.1.1) 模組化與 Socket API

java.base 模組： java.base 模組是 Java 平台的核心模組，它包含了 Java 語言的基本 API，包括 java.net 包。因此，任何使用 Socket API 的程式碼都必須依賴於 java.base 模組。
明確的模組依賴： 在 Java 9 及以後的版本，你可以透過 module-info.java 文件，來明確聲明你的程式碼所依賴的模組。例如，如果你需要使用到 java.net 包中的 Socket 或 AsynchronousSocketChannel ，你的 module-info.java 文件中通常不需要顯示地加入 requires java.base ，因為它是預設的模組。但是如果你使用了其他模組的 API，你就必須明確聲明其相依性。

(5.1.2) `module-info.java` 範例

以下是一個簡單的 module-info.java 檔案範例，展示了如何聲明模組依賴：假設你的模組名稱是 com.example.network ，那麼你的 module-info.java 檔案可能如下所示：

module com.example.network {
    // 如果有使用到 httpclient 你需要加入
    // requires java.net.http;

    // 如果有使用到自定義的模組，也可以用 requires 加入。
   // requires com.example.util;

    // 表示此模組需要 export 的 package，其他模組才能使用
    // exports com.example.network.client;
}

module com.example.network : 聲明模組的名稱為 com.example.network 。
requires java.net.http; : 表示此模組需要依賴 java.net.http 模組的功能。
requires com.example.util; : 表示此模組需要依賴 com.example.util 模組的功能。
exports com.example.network.client; : 表示 com.example.network.client 這個 package 可以被其他模組使用。
預設依賴 java.base : 因為 Socket API 屬於 java.base 的範圍，所以沒有特別需要指定，因為這是預設的。

(5.1.3) 模組化帶來的影響

更細緻的依賴管理： 模組化系統讓開發者能夠更精確地控制程式碼的依賴，只依賴必要的模組，從而減少了程式碼的負擔。
程式碼組織： 使用模組化後，你可以將專案程式碼拆分成不同的模組，更好地進行程式碼的組織和管理。
安全性提升： 通過精細控制哪些模組可以存取哪些資源，模組化系統有助於減少安全風險。

(5.2) 安全性提升

除了模組化之外，Java 在後續的版本中也持續改進了網路相關的安全性：

(5.2.1) 安全性更新

安全補丁： Java 版本更新通常會包含針對已知網路安全漏洞的修補程式，例如在 SSL/TLS 協議中發現的漏洞。
安全協定： 新版本的 Java 可能會加入對新的安全協定的支援，例如對 TLS 1.3 或 QUIC 等新網路協定的支援，這些新協定能提高網路連線的安全性。
更嚴格的預設設定： 新版本的 Java 可能會採用更嚴格的預設安全設定，例如預設禁用某些不安全的加密演算法。

(5.2.2) 使用最新版本 Java

保持更新： 建議開發者定期將 Java 應用程式升級到最新的版本，以確保應用程式能受到最新的安全保護。
關注官方公告： 建議開發者定期關注 Java 官方的安全公告，以了解最新的安全漏洞和修復方案。

(5.2.3) 安全程式設計原則

輸入驗證： 對所有來自網路的輸入進行嚴格驗證，避免程式碼漏洞。
最小權限原則: 程式碼需要使用到的權限應該越小越好。
加密通訊： 對於需要保護的敏感資料，建議使用加密通訊 (例如 HTTPS)。
定期安全審查： 定期對程式碼進行安全審查，找出潛在的安全問題。

(5.3) 小結

雖然 Java 9 及以後的版本並沒有對 java.net 包中的 Socket API 進行重大的 API 修改，但模組化和安全性方面的改進，仍然對 Java 網路程式設計產生了重要的影響：

模組化： 可以更好地管理依賴、組織程式碼、並提高安全性。
安全性： 透過持續的安全更新和更嚴格的預設設定，可以提高 Java 網路程式的安全性。
持續更新： 建議開發者保持對 Java 版本更新的關注，確保應用程式的安全性。

六、Java 13 - JEP 353

JEP 353 提案，即 "Reimplement the Legacy Socket API" (重構傳統的 Socket API)。這個提案並不是對 public API 進行修改，而是針對底層實作進行了徹底的重構。這個重構的主要目標是：

現代化程式碼: 將原本基於 C 語言的原始碼換成 Java 語言。
提升可維護性: 提高程式碼的可讀性和可修改性。
為未來改進鋪路: 為未來可能引入的 Socket 新特性奠定基礎。

(6.1) 重構的動機：為什麼需要重構？

在 Java 13 之前，TCP Socket API 的底層實作主要依賴於 native C 程式碼。這種方式雖然在早期提供了較高的效能，但也帶來了一些問題：

可維護性差： C 程式碼難以除錯和修改，需要熟悉 C 語言的開發者才能參與維護。當 Java 版本更新時，也需要維護相對應的 C 程式碼，增加了維護的複雜度。
安全性風險： Native 程式碼可能存在潛在的安全漏洞，且難以被 Java 開發社群修復。由於 C 語言的特性，記憶體管理錯誤更容易導致安全性漏洞。
難以擴展：原有的 C 程式碼框架較為僵化，難以擴展新的網路功能和特性。
與 Java 生態系統脫節： Native 程式碼與 Java 生態系統的結合不夠緊密，無法充分利用 Java 的優勢。

基於上述原因，Java 社群決定重構 Socket API 的底層實作，使用 Java 語言來取代 native 程式碼。

(6.2) 技術細節：如何重構？

JEP 353 重構的主要技術細節包括：

純 Java 實作：將原本的 C 程式碼重寫為 Java 程式碼，使得 Socket 的實作完全在 JVM 的掌控之下，提高了可移植性。
利用 java.nio.channels：使用 NIO 框架中的 java.nio.channels 包來處理底層的 I/O 操作，例如 SocketChannel 和 Selector。NIO 提供了非阻塞 I/O 功能，並具有更好的效能和可擴展性。
重新設計網路 I/O 流程：使用 Java 的非阻塞 I/O 模型來取代原本的阻塞 I/O 模型，提高了資源利用率和效能。
改進錯誤處理：使用 Java 的異常處理機制，使得錯誤訊息更加清晰和易於除錯。
模組化設計：重構後的程式碼採用了模組化的設計，使得不同部分的程式碼可以更好地組織和管理。
性能：此次調整最大的風險就是性能。該次改動與 C 程式碼效能相當，是一次非常棒的調整。Java 團隊在 Ubuntu Linux 18.04 AMD Ryzen 7 1700 機器上運行了這些基準測試，使用 OpenJDK 專案維護著一組用於評估更改性能的微基準測試，比較 Java 8 和重寫的 Java 13 實現之間的 Socket API 性能。

▲逾時時的效能，1位元組到128,000位元組

▲無超時的性能，1位元組到128,000位元組

從這些基準測試中，您可以得出結論，許多 Java 專案不太可能注意到性能上的任何差異。差異很小，並且在 Measurement Harness 的誤差範圍內。

(6.3) 開發者影響：雖然無感知，但帶來潛在收益

正如之前所說，JEP 353 的重構並沒有直接修改 public API，因此對於絕大多數開發者來說，這個變更幾乎是「無感」的。但是，這個重構仍然帶來了潛在的收益：

潛在效能提升：雖然沒有直接聲明，但使用 NIO 和非阻塞 I/O 模型可能在某些情境下帶來更好的效能，特別是在處理大量並行連線時。
更穩定可靠：純 Java 實作和更好的錯誤處理可以提高程式的穩定性，減少潛在的 bug。
更容易維護和除錯：對於需要深入研究 Socket 底層實作的開發者，Java 程式碼比 native C 程式碼更容易理解和除錯。
為未來特性鋪路：重構後的程式碼為未來引入新的網路特性和功能奠定了基礎，例如更好的 HTTP/2 或 QUIC 支援。
更高的安全性：透過純 Java 的實作，降低了 native 程式碼可能帶來的安全風險。

(6.4) 與之前的 NAPI 的關聯

JEP 353 也與之前在 Java 中引入的 NAPI (Native Access API) 相關聯。NAPI 目的是為了建立 Java 和 native 程式碼溝通的橋樑。在 JEP 353 的重構中，雖然目標是移除 native 程式碼，但 JEP 353 的實現也考慮了 NAPI 的使用，儘管最終並沒有完全依賴於它。總的來說，NAPI 為 Java 應用程式提供了更安全、可靠地使用 native 程式碼的途徑。

(6.5) 一個比喻：引擎的更換

可以將 JEP 353 的重構比喻成汽車的引擎更換：

原來的汽車 (Java Socket API)：汽車的外觀和操作方式沒有改變。
原來的引擎 (Native C 程式碼)：引擎是汽車的核心，但難以維護和升級。
新的引擎 (純 Java 實作)：新的引擎更現代化、容易維護和升級，並且具有更好的效能和安全性。
駕駛員 (Java 開發者)：駕駛員仍然可以駕駛這輛汽車，無需學習新的操作方式，但會感受到汽車更平穩和可靠。

(6.6) 小結

Java 社群為追求更現代化、安全和可維護的 Java 平台所做的努力，也強調了此次重構並非僅僅是性能上的考量，更是對歷史技術債務的一次重大清理，確保 Java 在網絡编程領域的長期競爭力。

JEP 353 是一個重大且必要的重構：重構的目標不僅是替換 native 程式碼，更是為了解決歷史遺留問題，提升 Java 平台的安全性、可維護性和可擴展性。
核心變革是底層實現的現代化：將底層的阻塞 I/O 操作替換為基於 NIO 的非阻塞 I/O 操作，並利用 java.nio.channels.SocketChannel 實現。
安全性和效能是重構的間接收益：雖然重構的主要目標不是為了提升效能，但是通過使用純 Java 程式碼和 NIO 框架，可以帶來潛在的效能提升和更高的安全性。
對開發者透明但重要：雖然 API 沒有改變，但重構使得 Java 平台更加穩定和可信賴，也為未來的新功能奠定了基礎。
重構範圍廣泛：重構不僅影響了 Socket 類，也影響了整個 java.net 包的底層實現。

七、Java 15 - JEP 373

Datagram Socket API 重構。

(7.1) JEP 373 的背景與目標

如同 JEP 353，JEP 373 也旨在解決以下問題：

底層實作依賴 native 程式碼：舊的 DatagramSocket API 也是依賴於 native C 程式碼實作的，這造成了維護困難和安全風險。
不夠現代化：原有的實作較為陳舊，難以利用現代的非阻塞 I/O 技術。
潛在的安全性問題：原有的 C 程式碼可能存在緩衝區溢出等安全漏洞，不容易被 Java 社群修復。
難以擴展：舊的實作難以擴展新的 UDP 網路功能和特性。

因此，JEP 373 的主要目標是：

移除 native C 程式碼：使用純 Java 程式碼重新實作 DatagramSocket API。
現代化程式碼：利用 Java 的 NIO 框架和非阻塞 I/O 技術。
提升安全性：降低安全風險，並使得更容易維護。
為未來擴展鋪路：為未來加入新的 UDP 特性提供基礎。

(7.2) JEP 373 的技術細節

JEP 373 的重構方式與 JEP 353 類似，主要技術細節包括：

純 Java 實作：使用 Java 程式碼替換原本的 native C 程式碼。
利用 java.nio.channels：使用 NIO 框架中的 DatagramChannel 類處理底層的 I/O 操作。
非阻塞 I/O：利用 NIO 的非阻塞特性，提高 UDP 程式設計的效率和資源利用率。
改進錯誤處理：使用 Java 的異常處理機制，使得錯誤訊息更加清晰和易於除錯。
模組化設計：採用模組化的設計，方便程式碼的組織和維護。

(7.3) JEP 373 與 JEP 353 的比較

特性	JEP 353 (Java 13)	JEP 373 (Java 15)
目標 API	TCP Socket API	UDP DatagramSocket API
底層實現	原依賴 native C 程式碼	原依賴 native C 程式碼
重構策略	純 Java 實作，基於 SocketChannel	純 Java 實作，基於 DatagramChannel
IO 模型	轉換為 NIO 非阻塞 I/O	轉換為 NIO 非阻塞 I/O
對開發者影響	透明，無需修改程式碼	透明，無需修改程式碼
主要優點	提高安全性、可維護性和可擴展性	提高安全性、可維護性和可擴展性

主要共同點:

都是對 legacy Socket API 的底層實作進行重構。
都是將 native C 程式碼替換為純 Java 程式碼。
都使用了 NIO 框架，並轉換為非阻塞 I/O 模型。
都是為了提高安全性和可維護性，並為未來的擴展鋪路。
對現有 API 沒有任何破壞性的改動。

主要不同點:

一個針對 TCP 的 Socket API，一個針對 UDP 的 DatagramSocket API。
底層利用的 NIO Channel 不同：一個是 SocketChannel，一個是 DatagramChannel。

(7.4) JEP 373 的影響

與 JEP 353 類似，JEP 373 對於大多數開發者來說也是透明的，開發者不需要修改現有的程式碼。但是，它仍然會帶來以下潛在的影響：

效能提升：使用 NIO 和非阻塞 I/O 可能在某些情況下帶來效能提升。
更穩定可靠：純 Java 實作和更好的錯誤處理可以提高 UDP 程式設計的穩定性。
更易於維護和除錯：對於需要深入研究 UDP 底層實作的開發者，Java 程式碼比 native C 程式碼更容易理解。
為未來擴展鋪路：為未來引入新的 UDP 特性奠定了基礎。
更高的安全性：純 Java 實作降低了 native 程式碼可能帶來的安全風險。

(7.5) 小結

JEP 373 是 Java 15 中關於 UDP DatagramSocket API 的重大重構，它與 Java 13 的 JEP 353 類似，都是對 legacy Socket API 的底層實作進行現代化改造，將 native 程式碼替換為純 Java 程式碼，並使用了 NIO 框架。

雖然這兩個 JEP 都對開發者是透明的，但是它們都對 Java 平台的穩定性、安全性、效能和未來發展產生了深遠的影響。開發者應持續關注 Java 版本更新，以便及時了解這些底層變更，並利用這些新特性和改進來構建更高效、更可靠的網路應用程式。

八、總結

從 Java 7 到 Java 17，Socket API 的發展雖然沒有出現核心功能的變更，但透過一系列的改進，Java 在網路程式設計方面變得更具彈性、效能和安全性。以下是這些變革的主要方向：

阻塞式 Socket 的對比範例： 本文提供了一個簡單的阻塞式 Socket 範例，用來對比 AsynchronousSocketChannel 的非阻塞 I/O 特性，讓開發者能更容易理解兩者的差異。
非阻塞 I/O 的引入 (Java 7)： AsynchronousSocketChannel 的出現是網路程式設計的一大躍進，它使得 Java 可以高效地處理大量並行連線，顯著提升了網路應用程式的效能。傳統的阻塞式 Socket API 在應對高並行連線時會效率低下，而 AsynchronousSocketChannel 則利用了作業系統的非同步 I/O 機制，有效地解決了這個問題。
非同步程式設計的簡化 (Java 8)： Java 8 的 Lambda 表達式和 CompletableFuture 等新特性，讓非同步程式設計更加簡潔易讀。雖然這些新特性沒有直接改變 Socket API 本身，但它們有效地提升了開發者的開發效率，並降低了非同步程式設計的複雜度。
模組化與安全性 (Java 9 及以後)： Java 9 引入的模組化系統，使得可以更精確地管理網路相關模組的依賴，而後續版本也持續加強安全性，透過安全更新、支援新協議、以及更嚴格的預設設定，提高了 Java 網路應用程式的安全性。
底層實作的現代化 (Java 13 & 15)： JEP 353 和 JEP 373 分別重構了 TCP 和 UDP Socket API 的底層實作，將原本的 native C 程式碼替換為純 Java 程式碼，並利用了 NIO 框架。這些底層改進提高了程式碼的可維護性、安全性，也為未來的擴展鋪平了道路。雖然這些改動對開發者是透明的，但它們是 Java 平台在網路程式設計方面的重要基礎建設。

儘管底層的 TCP/IP 協議沒有發生變化，但這些改進讓 Java 開發者能夠以更現代化、高效和安全的方式構建網路應用程式。因此，建議開發者能深入了解這些新特性，並根據實際應用需求，選擇適合的 Socket API 和程式設計方式。

沒有留言:

張貼留言

訂閱：張貼留言 (Atom)