ServerSocket(int port)       創(chuàng)建一個服務(wù)端流套接字Socket，并綁定到指定端口

Socket accept() 開始監(jiān)聽指定端口(創(chuàng)建時綁定的端口)有客戶端連接后，返回一個服務(wù)端Socket對象，并基于該Socket建立與客戶端的連接，否則阻塞等待
void close()    關(guān)閉此套接字

Socket(String host, int port) 創(chuàng)建一個客戶端流套接字Socket，并與對應(yīng)IP的主機上，對應(yīng)端口的進程建立連接

InetAddress getInetAddress() 返回套接字所連接的地址
InputStream getInputStream() 返回此套接字的輸入流
OutputStream getOutputStream() 返回此套接字的輸出流

長連接：不關(guān)閉連接，一直保持連接狀態(tài)，雙方不停的收發(fā)數(shù)據(jù)，即是長連接。也就是說，長連接可以多次收發(fā)數(shù)據(jù)。

?

package io;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.Socket;
import java.util.Scanner;


public class TcpEchoClient {
    private Socket socket = null;

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

    //啟動客戶端程序
    public void start() {
        Scanner scanner = new Scanner(System.in);
        try (InputStream inputStream = socket.getInputStream();
             OutputStream outputStream = socket.getOutputStream()) {
            PrintWriter printWriter = new PrintWriter(outputStream);
            Scanner scannerFromSocket = new Scanner(inputStream);
            while (true) {
                // 1. 從鍵盤上讀取用戶輸入的內(nèi)容.
                System.out.print("-> ");
                String request = scanner.next();
                // 2. 把讀取的內(nèi)容構(gòu)造成請求, 發(fā)送給服務(wù)器.
                //    注意, 這里的發(fā)送, 是帶有換行的!!
                printWriter.println(request);//這里只是把數(shù)據(jù)寫入內(nèi)存的緩沖區(qū)中，等待緩沖區(qū)滿了，才會真正寫網(wǎng)卡
                // 3. 從服務(wù)器讀取響應(yīng)內(nèi)容
                String response = scannerFromSocket.next();
                // 4. 把響應(yīng)結(jié)果顯示到控制臺上.
                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();
    }
}

package io;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;

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

    //端口號綁定
    public TcpEchoServer(int port) throws IOException {
        serverSocket = new ServerSocket(port);
    }

    public void start() throws IOException {
        System.out.println("服務(wù)器啟動!");
        while (true) {
            Socket clientSocket = serverSocket.accept();
            processConnection(clientSocket);
        }
    }

    // 通過這個方法來處理一個連接.
    // 讀取請求
    // 根據(jù)請求計算響應(yīng)
    // 把響應(yīng)返回給客戶端
    private void processConnection(Socket clientSocket) throws IOException {
        System.out.printf("[%s:%d] 客戶端上線!\n", clientSocket.getInetAddress().toString(),
                clientSocket.getPort());
        // try () 這種寫法, ( ) 中允許寫多個流對象. 使用 ; 來分割
        try (InputStream inputStream = clientSocket.getInputStream();
             OutputStream outputStream = clientSocket.getOutputStream()) {
            // 沒有這個 scanner 和 printWriter, 完全可以!! 但是代價就是得一個字節(jié)一個字節(jié)扣, 找到哪個是請求的結(jié)束標記 \n
            // 不是不能做, 而是代碼比較麻煩.為了簡單, 把字節(jié)流包裝秤了更方便的字符流~~
            Scanner scanner = new Scanner(inputStream);
            //Scanner 相當于 字符流，上述約定了請求是字符串，所以就可以使用字符流來處理

            PrintWriter printWriter = new PrintWriter(outputStream);
            while (true) {
                // 1. 讀取請求：
                //hasNext 判定接下來還有沒有數(shù)據(jù)了，如果對端關(guān)閉連接(客戶端關(guān)閉連接)，此時 hasNext 就會返回 false，循環(huán)就讓它結(jié)束
                //如果對端有數(shù)據(jù)，hasNxet 返回 true，進一步就可以使用 next 方法來讀出這一段字符串的內(nèi)容了

                if (!scanner.hasNext()) {
                    // 讀取的流到了結(jié)尾了 (對端關(guān)閉了)
                    System.out.printf("[%s:%d] 客戶端下線!\n", clientSocket.getInetAddress().toString(),
                            clientSocket.getPort());
                    break;
                }
                // 直接使用 scanner 讀取一段字符串.
                String request = scanner.next();
                //next：一直往后讀，讀到空白符結(jié)束——空格，換行，制表符，翻頁符..都算空白符
                //nextLine 只是讀到換行符結(jié)束
                //這里不要用nextLine


                // 2. 根據(jù)請求計算響應(yīng)
                String response = process(request);
                // 3. 把響應(yīng)寫回給客戶端. 不要忘了, 響應(yīng)里也是要帶上換行的.
                printWriter.println(response);
                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();//clientSocket 只是給一個連接提供服務(wù)的，還是要能夠進行關(guān)閉
        }
    }

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

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

// 2. 把讀取的內(nèi)容構(gòu)造成請求, 發(fā)送給服務(wù)器.
//    注意, 這里的發(fā)送, 是帶有換行的!!
printWriter.println(request);

    public void start() throws IOException {
        System.out.println("服務(wù)器啟動!");
        while (true) {
            Socket clientSocket = serverSocket.accept();
            //如果直接調(diào)用，該方法回影響這個循環(huán)的二次執(zhí)行，導(dǎo)致 accept 不及時了
            //這個時候就需要 創(chuàng)建新的線程，用新線程來調(diào)用 processConnection；每次來一個新的客戶端都搞一個新的線程即可??！!
            Thread t = new Thread(() -> {
                try {
                    processConnection(clientSocket);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            });
            t.start();
        }
    }