public class TcpEchoServer {
    // serverSocket 就是外場(chǎng)拉客的小哥
    // clientSocket 就是內(nèi)場(chǎng)服務(wù)的小姐姐.
    // serverSocket 只有一個(gè). clientSocket 會(huì)給每個(gè)客戶端都分配一個(gè)~
    private ServerSocket serverSocket = null;

    public TcpEchoServer(int port) throws IOException {
        serverSocket = new ServerSocket(port);
    }

    public void start() throws IOException {
        ExecutorService executorService = Executors.newCachedThreadPool();
        System.out.println("服務(wù)器啟動(dòng)!");
        while (true) {
            Socket clientSocket = serverSocket.accept();
            //服務(wù)器的主線程（main 線程）負(fù)責(zé)運(yùn)行 while 循環(huán)，用于接收客戶端的連接請(qǐng)求。
            // 與此同時(shí)，針對(duì)每個(gè)接收到的連接請(qǐng)求，都會(huì)創(chuàng)建一個(gè)新線程處理與該客戶端的數(shù)據(jù)通信。這些新線程與主線程是并發(fā)執(zhí)行的。
            //由于主線程和新創(chuàng)建的線程并發(fā)執(zhí)行，服務(wù)器可以在處理一個(gè)客戶端連接的同時(shí)，繼續(xù)接收其他客戶端的連接請(qǐng)求。
            // 這使得服務(wù)器可以并發(fā)處理多個(gè)客戶端連接，提高了服務(wù)器的處理能力。
            // 創(chuàng)建新的線程, 用新線程來調(diào)用 processConnection
//            Thread t = new Thread(() -> {
//                try {
//                    processConnection(clientSocket);
//                } catch (IOException e) {
//                    e.printStackTrace();
//                }
//            });
//            t.start();

            //使用線程池
            executorService.submit(new Runnable() {
                @Override
                public void run() {
                    try {
                        processConnection(clientSocket);
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
    }

    // 通過這個(gè)方法來處理一個(gè)連接.
    // 讀取請(qǐng)求
    // 根據(jù)請(qǐng)求計(jì)算響應(yīng)
    // 把響應(yīng)返回給客戶端
    private void processConnection(Socket clientSocket) throws IOException {
        System.out.printf("[%s:%d] 客戶端上線!\n", clientSocket.getInetAddress().toString(),
                clientSocket.getPort());
        try (InputStream inputStream = clientSocket.getInputStream();
             OutputStream outputStream = clientSocket.getOutputStream()) {
            // 沒有這個(gè) scanner 和 printWriter, 完全可以!! 但是代價(jià)就是得一個(gè)字節(jié)一個(gè)字節(jié)扣, 找到哪個(gè)是請(qǐng)求的結(jié)束標(biāo)記 \n
            // 不是不能做, 而是代碼比較麻煩.
            // 為了簡單, 把字節(jié)流包包裝成了更方便的字符流~~
            Scanner scanner = new Scanner(inputStream);
            PrintWriter printWriter = new PrintWriter(outputStream);
            while (true) {
                // 1. 讀取請(qǐng)求
                if (!scanner.hasNext()) {
                    // 讀取的流到了結(jié)尾了 (對(duì)端關(guān)閉了)
                    System.out.printf("[%s:%d] 客戶端下線!\n", clientSocket.getInetAddress().toString(),
                            clientSocket.getPort());
                    break;
                }
                // 直接使用 scanner 讀取一段字符串.
                String request = scanner.next();
                // 2. 根據(jù)請(qǐng)求計(jì)算響應(yīng)
                String response = process(request);
                // 3. 把響應(yīng)寫回給客戶端. 不要忘了, 響應(yīng)里也是要帶上換行的.
                printWriter.println(response);
                //數(shù)據(jù)此時(shí)還在緩存區(qū),使用 flush() 方法，可以確保數(shù)據(jù)立即發(fā)送
                printWriter.flush();
                //clientSocket.getInetAddress().toString() 返回客戶端的 IP 地址，clientSocket.getPort() 返回客戶端的端口號(hào)，
                // request 是客戶端發(fā)送的請(qǐng)求，response 是服務(wù)器響應(yīng)的數(shù)據(jù)。
                // 通過格式化輸出的方式將這些信息打印出來，方便程序員進(jìn)行調(diào)試和查看。
                System.out.printf("[%s:%d] req: %s; resp: %s\n", clientSocket.getInetAddress().toString(),
                        clientSocket.getPort(), request, response);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            clientSocket.close();
        }
    }

    private String process(String request) {
        return request;
    }

    public static void main(String[] args) throws IOException {
        TcpEchoServer tcpEchoServer = new TcpEchoServer(9090);
        tcpEchoServer.start();
    }
}

public class TcpEchoClient {
    private Socket socket = null;

    public TcpEchoClient(String serverIp, int port) throws IOException {
        // 這個(gè)操作相當(dāng)于讓客戶端和服務(wù)器建立 tcp 連接.
        // 這里的連接連上了, 服務(wù)器的 accept 就會(huì)返回.
        socket = new Socket(serverIp, port);
    }

    public void start() {
        Scanner scanner = new Scanner(System.in);
        try (InputStream inputStream = socket.getInputStream();
             OutputStream outputStream = socket.getOutputStream()) {
            //outputStream 是一個(gè)字節(jié)輸出流，通過 PrintWriter 對(duì)象的構(gòu)造方法將其包裝成字符輸出流，以便能夠方便地寫入字符數(shù)據(jù)。
            PrintWriter printWriter = new PrintWriter(outputStream);
            //scannerFromSocket 對(duì)象是將輸入流對(duì)象包裝成一個(gè) Scanner 對(duì)象，以便能夠方便地讀取輸入流中的數(shù)據(jù)。
            // Scanner 對(duì)象會(huì)自動(dòng)解析和分隔輸入流中的數(shù)據(jù)，并將其轉(zhuǎn)換為相應(yīng)的數(shù)據(jù)類型或字符串。
            Scanner scannerFromSocket = new Scanner(inputStream);

            while (true) {
                // 1. 從鍵盤上讀取用戶輸入的內(nèi)容.
                System.out.print("-> ");
                String request = scanner.next();
                // 2. 把讀取的內(nèi)容構(gòu)造成請(qǐng)求, 發(fā)送給服務(wù)器.
                //在 Java 中，可以通過 PrintWriter 對(duì)象的 println() 方法發(fā)送帶有換行符的數(shù)據(jù)包。
                // 該方法會(huì)將指定的字符串添加一個(gè)換行符，并將其發(fā)送到輸出流中。
                printWriter.println(request);
                //數(shù)據(jù)此時(shí)還在緩存區(qū),使用 flush() 方法，可以確保數(shù)據(jù)立即發(fā)送
                printWriter.flush();
                // 3. 從服務(wù)器讀取響應(yīng)內(nèi)容
                //next() 方法會(huì)讀取下一個(gè)標(biāo)記，而不是一行數(shù)據(jù)。標(biāo)記通常是以空格、制表符或換行符為分隔符的單詞或符號(hào)。
                // 因此，在讀取數(shù)據(jù)時(shí)，如果數(shù)據(jù)包中只有一個(gè)標(biāo)記，則可以使用 next() 方法讀取該標(biāo)記。
                String response = scannerFromSocket.next();
                // 4. 把響應(yīng)結(jié)果顯示到控制臺(tái)上.
                // request 是客戶端發(fā)送的請(qǐng)求，response 是服務(wù)器響應(yīng)的數(shù)據(jù)。
                // 通過格式化輸出的方式將這些信息打印出來，方便程序員進(jìn)行調(diào)試和查看。
                System.out.printf("req: %s; resp: %s\n", request, response);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) throws IOException {
        TcpEchoClient client = new TcpEchoClient("127.0.0.1", 9090);
        client.start();
    }
}

public class UdpEchoServer {
    // 需要先定義一個(gè) socket 對(duì)象.
    // 通過網(wǎng)絡(luò)通信, 必須要使用 socket 對(duì)象.
    private DatagramSocket socket = null;

    // 綁定一個(gè)端口, 不一定能成功!!
    // 如果某個(gè)端口已經(jīng)被別的進(jìn)程占用了, 此時(shí)這里的綁定操作就會(huì)出錯(cuò).
    // 同一個(gè)主機(jī)上, 一個(gè)端口, 同一時(shí)刻, 只能被一個(gè)進(jìn)程綁定.
    public UdpEchoServer(int port) throws SocketException {
        // 構(gòu)造 socket 的同時(shí), 指定要關(guān)聯(lián)/綁定的端口.
        socket = new DatagramSocket(port);
    }

    // 啟動(dòng)服務(wù)器的主邏輯.
    public void start() throws IOException {
        System.out.println("服務(wù)器啟動(dòng)!");
        while (true) {
            // 每次循環(huán), 要做三件事情:
            // 1. 讀取請(qǐng)求并解析
            //    構(gòu)造空飯盒
            DatagramPacket requestPacket = new DatagramPacket(new byte[4096], 4096);
            //    食堂大媽給飯盒里盛飯. (飯從網(wǎng)卡上來的)
            socket.receive(requestPacket);
            //    為了方便處理這個(gè)請(qǐng)求, 把數(shù)據(jù)包轉(zhuǎn)成 String
            String request = new String(requestPacket.getData(), 0, requestPacket.getLength());
            // 2. 根據(jù)請(qǐng)求計(jì)算響應(yīng)(此處省略這個(gè)步驟)
            String response = process(request);
            // 3. 把響應(yīng)結(jié)果寫回到客戶端
            //    根據(jù) response 字符串, 構(gòu)造一個(gè) DatagramPacket .
            //    和請(qǐng)求 packet 不同, 此處構(gòu)造響應(yīng)的時(shí)候, 需要指定這個(gè)包要發(fā)給誰.
            DatagramPacket responsePacket = new DatagramPacket(response.getBytes(), response.getBytes().length,
                    // requestPacket 是從客戶端這里收來的. getSocketAddress 就會(huì)得到客戶端的 ip 和 端口
                    requestPacket.getSocketAddress());
            socket.send(responsePacket);
            System.out.printf("[%s:%d] req: %s, resp: %s\n", requestPacket.getAddress().toString(),
                    requestPacket.getPort(), request, response);
        }
    }

    // 這個(gè)方法希望是根據(jù)請(qǐng)求計(jì)算響應(yīng).
    // 由于咱們寫的是個(gè) 回顯 程序. 請(qǐng)求是啥, 響應(yīng)就是啥!!
    // 如果后續(xù)寫個(gè)別的服務(wù)器, 不再回顯了, 而是有具體的業(yè)務(wù)了, 就可以修改 process 方法,
    // 根據(jù)需要來重新構(gòu)造響應(yīng).
    // 之所以單獨(dú)列成一個(gè)方法, 就是想讓同學(xué)們知道, 這是一個(gè)服務(wù)器中的關(guān)鍵環(huán)節(jié)!!!
    public String process(String request) {
        return request;
    }

    public static void main(String[] args) throws IOException {
        UdpEchoServer udpEchoServer = new UdpEchoServer(9090);
        udpEchoServer.start();
    }
}

public class UdpEchoClient {
    private DatagramSocket socket = null;
    private String serverIP;
    private int serverPort;

    // 客戶端啟動(dòng), 需要知道服務(wù)器在哪里!!
    public UdpEchoClient(String serverIP, int serverPort) throws SocketException {
        // 對(duì)于客戶端來說, 不需要顯示關(guān)聯(lián)端口.
        // 不代表沒有端口, 而是系統(tǒng)自動(dòng)分配了個(gè)空閑的端口.
        socket = new DatagramSocket();
        this.serverIP = serverIP;
        this.serverPort = serverPort;
    }

    public void start() throws IOException {
        // 通過這個(gè)客戶端可以多次和服務(wù)器進(jìn)行交互.
        Scanner scanner = new Scanner(System.in);
        while (true) {
            // 1. 先從控制臺(tái), 讀取一個(gè)字符串過來
            //    先打印一個(gè)提示符, 提示用戶要輸入內(nèi)容
            System.out.print("-> ");
            String request = scanner.next();
            // 2. 把字符串構(gòu)造成 UDP packet, 并進(jìn)行發(fā)送.
            DatagramPacket requestPacket = new DatagramPacket(request.getBytes(), request.getBytes().length,
                    InetAddress.getByName(serverIP), serverPort);
            socket.send(requestPacket);
            // 3. 客戶端嘗試讀取服務(wù)器返回的響應(yīng)
            DatagramPacket responsePacket = new DatagramPacket(new byte[4096], 4096);
            socket.receive(responsePacket);
            // 4. 把響應(yīng)數(shù)據(jù)轉(zhuǎn)換成 String 顯示出來.
            //這行代碼將接收到的字節(jié)流數(shù)據(jù)按照指定的編碼格式轉(zhuǎn)換成字符串，方便我們查看和處理數(shù)據(jù)。
            String response = new String(responsePacket.getData(), 0, responsePacket.getLength());
            System.out.printf("req: %s, resp: %s\n", request, response);
        }
    }

    public static void main(String[] args) throws IOException {
        UdpEchoClient udpEchoClient = new UdpEchoClient("127.0.0.1", 9090);
        udpEchoClient.start();
    }
}