网络编程套接字(4)——Java套接字（TCP协议）

1.客户端和服务端：开发时,经常是基于一个主机开启两个进程作为客户端和服务端，但是真实的场景，一般是不同主机。

2.注意目的IP和目的端口号，标识了一次数据传输时要发送数据的终点主机和进程。

3.Socket编程我们是使用流套接字和数据报套接字，基于TCP或UDP协议，但应用层协议，也需要考虑。

二、TCP流套接字编程

TCP面向字节流，和UDP面向数据报不同，但是写的回显服务器中心思想是一样的，代码会有不同。以下API介绍。

1、ServerSocket

这个Socket类对应到网卡，只能给服务器使用。

ServerSocket是创建TCP服务端Socket的API。

ServerSocket构造方法：

|------------------------|----------------------------|
| 方法签名 | 方法说明 |
| ServerSocket(int port) | 创建一个服务端流套接字Socket,并绑定到指定端口 |

ServerSocket方法:

|-----------------|-------------------------------------------------------------------------|
| 方法签名 | 方法说明 |
| Socket accept() | 开始监听指定端口(创建时绑定的端口),有客户端连接后,返回一个服务端socket对象,并基于该 Socket建立与客户端的连接,否则阻塞等待 |
| void close() | 关闭此套接字 |

2、Socket

对应到网卡，既可以给客户端使用，也可以给服务器使用。

Socket是客户端Socket，或服务端接收到客户端建立的连接(accept方法)的请求后，返回的服务端Socket。

不管是客户端还是服务端Socket，都是双方建立连接之后，保存对端信息,及用来与对方收发数据的。

Socket构造方法：

|-------------------------------|-------------------------------------------|
| 方法签名 | 方法说明 |
| Socket(String host, int port) | 创建一个客户端流套接字Socket,并与对应IP的主机上,对应端口的进程进行连接 |

Socket方法：

|--------------------------------|-------------|
| 方法签名 | 方法说明 |
| InetAddress getInetAddress() | 返回套接字所连接的地址 |
| InputStream getInputStream() | 返回此套接字的输入流 |
| OutputStream getOutputStream() | 返回此套接字的输出流 |

三、代码示例：回显服务器

1、服务器代码

java 复制代码

public class TcpEchoServer {
    ServerSocket socket = null;

    public TcpEchoServer(int serverPort) throws IOException {
        socket = new ServerSocket(serverPort);
    }

    public void start() throws IOException {
        System.out.println("服务器启动");
        ExecutorService pool = Executors.newCachedThreadPool();
        while (true) {
            //通过 accept 这个方法来 "接听电话"，然后才能通信
            Socket clientSocket = socket.accept();
//            Thread t = new Thread(() -> {
//                //通过这个方法来处理一次连接，连接的过程会涉及到多次请求响应交互
//                processConnection(clientSocket);
//            });
//            t.start();
            pool.submit(new Runnable() {
                @Override
                public void run() {
                    processConnection(clientSocket);
                }
            });
        }
    }
    //通过这个方法来处理一次连接，连接的过程会涉及到多次请求响应交互
    private void processConnection(Socket clientSocket) {
        System.out.printf("[%s : %d] 客户端上线\n", clientSocket.getInetAddress(), clientSocket.getPort());
        //循环读取客户端请求并返回响应
        try(InputStream inputStream = clientSocket.getInputStream();
            OutputStream outputStream = clientSocket.getOutputStream()) {
            while (true) {
                Scanner scanner = new Scanner(inputStream);
                if(!scanner.hasNext()) {
                    //读取完毕，客户端断开连接，就会产生读取完毕
                    System.out.printf("[%s : %d] 客户端下线\n", clientSocket.getInetAddress(), clientSocket.getPort());
                    break;
                }
                //1、接受从客户端发来的请求,解析请求（将请求转换为字符串）为了方便，直接使用Scanner读取
                //  读取请求并解析. 这里注意隐藏的约定. next 读的时候要读到空白符才会结束.
                //    因此就要求客户端发来的请求必须带有空白符结尾. 比如 \n 或者空格.
                //客户端发来的请求要包含 "\n"
                String request = scanner.next();
                //2、计算请求
                String response = process(request);
                //3、把计算的响应返回给客户端
                //也可以通过下面的这种方式写回，但下面这种方式不好添加 "\n"
                //outputStream.write(response.getBytes(), 0, response.getBytes().length);
                // 也可以给outputStream套上一层，可以更方便的加上 "\n"
                PrintWriter writer = new PrintWriter(outputStream);
                writer.println(response);
                //刷新缓冲器
                writer.flush();
                //打印日志
                System.out.printf("[%s : %d] res: %s resp: %s\n", clientSocket.getInetAddress(),
                        clientSocket.getPort(), request, response);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            try {
                clientSocket.close();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }

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

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

代码解析

服务器通过accept方法 ，和客户端建立联系

如上图，应用程序代码中调用对应的 api 和服务器尝试建立连接，内核就会发起连接的流程。

服务器的内核就会配合客户端这边的工作来完成连接的建立。

这个连接建立的过程，就相当于：电话这边在拨号，另一边在响铃；但是要等到用户点击了接听，然后才能进行后续的通信。

内核建立的连接不上决定性的，还需要用户程序 ，把这个连接进行 "接听" / accept 操作，然后才能进行后续的通信。

注意： accept也是一个可能会产生阻塞的操作，如果当前没有客户端连过来，此时 accept 就会阻塞。

有一个客户端连过来，accept 一次就能返回一次。

有若干个客户端连过来，accept 就需要执行多次。

第一个socket是负责客户端的连接 ，第二个clientSocket是负责操作服务器内部的业务。

接下来的方法是处理连接的交互，新创建多出来线程后面讲

TCP是有连接的和面向字节流的，从下面代码就可以看出来

TCP的 socket 是可以保存对端的信息 ，InputStream是从网卡读数据，outputStream是从网卡写数据。

TCP面向字节流，这里的字节流和文件中的字节流完全一样，使用文件操作一样的方法和类的对 TCP 的 socket 进行读写。

如图：

此处的读操作完全可以通过 read 来完成，read 是把收到的数据放到 byte 数组中，后续根据请求处理响应还需要把这个 byte 数组转成 String，比较麻烦，还有一个更简单的方法：Scanner，如上图。

如图：

客户端退出之后，服务器就能感知到 "客户端下线" 的操作 ；客户端退出的时候，就会触发TCP的"断开连接"流程，服务器这边的代码就能感知到，对应的Scanner就能够在hasNext这里返回false。

这里要用 scanner.next() ，因为接受来的请求的字节流，要知道什么时候结束 ，发送过来的请求会带有 "\n"，发来的请求中有空白符，比如 \n 或空格。

接下来是计算请求，如图：

因为这里是简单的回显服务器，所以计算就直接返回请求的内容，process方法如图：

返回响应

记得要刷新缓冲器。

2、客户端代码

java 复制代码

public class TchEchoClient {
    Socket socket = null;

    public TchEchoClient(String serverIp, int serverPort) throws IOException {
        //这里的ip和port是直接发给socket的对象
        // 因为TCP是有连接的，所以socket会保存ip和port这些信息
        //因此TcpEchoClient不必保存ip和port
        socket = new Socket(serverIp, serverPort);
    }

    public void start() {
        System.out.println("客户端启动");

        try(InputStream inputStream = socket.getInputStream();
            OutputStream outputStream = socket.getOutputStream();
            Scanner scannerConsole = new Scanner(System.in);
            Scanner scannerNetwork = new Scanner(inputStream);
            PrintWriter writer = new PrintWriter(outputStream)) {
            while (true) {
                System.out.print("->");
                //1、从控制台输入请求，构造请求
                if(!scannerConsole.hasNext()) {
                    break;
                }
                //发送给服务器的字符串要带有 "\n"
                String request = scannerConsole.next();
                //2、把请求发给发送给服务器，这里需要用println来发生，确保信息里面有 "\n"
                //这里是和服务器的scanner.next()对应的
                writer.println(request);
                //通过flush刷新缓冲器，确保数据真的发出去了
                writer.flush();
                //3、接收服务器返回的响应
                //这里也是和服务器返回的响应逻辑对应，返回的响应带有 "\n"
                String response = scannerNetwork.next();
                //4、把返回的响应显示到控制台
                System.out.println(response);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }

    }

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

代码解析

构造方法里面，如图：

执行客户端里的构造方法，就会和对应的服务器进行TCP的连接建立流程 。（系统内核完成的）。

这边把内核中连接的流程走完了，服务器这边就能够从 accept 返回。

服务器的建立连接，如图

processConnection方法内部

然后进入while循环，执行服务器的内部逻辑，如图：

3、注意事项

（1）缓冲区

文件的IO操作都是比较低效的，所以就希望能够让低效的操作，进行的尽量少一些。

解决方案： 引入缓冲区(内存)，先把写入网卡的数据放到内存缓冲区中，等攒一波再统一进行发送（把多次IO合并成一次）。

但也有个问题，如果发送的数据很少。此时由于缓冲区还没满，数据就待在缓冲区里，没有被真正发送出去。所以上面的代码中要加入刷新缓冲区的代码 。（不然就连数据都发送不出去），如图：不管数据有没有真的发送出去，都要进行刷新缓冲器。

（2）socket的close，释放文件描述符表

如图：

clientSocket对象要释放掉 ，因为客户端不止一个，会有很多个，一个客户端发来请求就会占用一个文件描述符表，我们不确定客户端什么时候下线，就可能会一直占用着这些资源（文件描述符表），随着客户端越来越多，又无法释放，文件描述符表就可能占满。

而服务器的sock就不用释放，调用close方法，如图：

因为这个socket会伴随着服务器的生命周期很长，整个生命周期都会使用到它，而且也只有一个 ，就不用担心占不占满文件描述符表了，像这种情况就不用释放；只要程序退出，socket也会随着进程的销毁一起被释放；UDP的回显服务器的socket不用释放也是因为这个原因。

因为有finally最后会执行socket的释放，所以，释放了 socket 对象，上述流对象不释放，也问题不大。 这两流对象内部不持有文件描述符，只是只有一些内存结构。内存结构可以被 gc 释放。

但是只释放了流对象，不释放socket，就不行了 。socket持有了文件描述符表，本质还是要释放文件描述符资源。

不过这里使用try with resources 的版本，也给它close了，更保险一点。

（3）多线程的应用

服务器支持多个客户端同时访问是天经地义的，但如果不加多线程方案执 processConnection方法，如图：

当有多个客户端想同时访问时，第一个客户端先访问服务器，服务器就会从accept这返回（解除阻塞），进入到processConnection中了，接下来就会在scanner.hasNext返回，继续执行服务器逻辑，因为有while循环，完成服务器的逻辑后，把响应返回给客户端执行完上述一轮操作后，循环回来继续再hasNext阻塞，等待下一次循环，知道客户端退出，连接结束，服务器中的循环才会结束、退出，如图：

当有第二个客户端想访问服务器时，因为第一个客户端还没执行完 ，服务器还在里面的while循环转圈圈呢 ，就无法第二次执行到accept。

这里虽然第二个客户端和服务器在内核层面上建立了TCP连接，但是应用程序这里，无法把连接拿到的应用程序，在服务器程序里面进行处理（像是别人给你打电话，你手机一直在响，但是你没接）。

如果第一个客户端退出了，第二个客户端之前的请求为啥就会被立即出来，而没有丢弃呢？这是因为当前TCP在内核中，每个 socket 都是有缓冲区的 。客户端发送的数据确实是发了，服务器也收到了，只不过数据是在服务器的接受缓冲区中。

一旦第一个客户端退出了，回到第一层循环，继续执行第二次 accept ，继续执行 next 就能把之前缓冲区的内容给读出来 （像是菜鸟驿站，可以存放快递包裹）。

单个线程，无法既能给客户端提供循环提供服务，又能快速的调用到第二次accept

所以这里的核心思路就是使用多线程 ，也是简单的办法，引入多线程，主线程负责执行 accept；每次有一个客户端连上来，就分配一个新的线程，由新的线程负责给客户端提供服务。如图：

而上述没有引用多线程而造成的问题，并不是 TCP 的问题，而是代码本身的问题，因为两层循环嵌套而导致的问题。 UDP只有一层循环，所以就不涉及到这种问题，之前的UDP天然的就能处理多个客户端的请求。

（4）引入线程池的改进

如图：

这里每次来一个客户端，就会创建一个新的线程；每次这个客户端结束，就要销毁这个线程。如果客户端比较多，就会使服务器频繁创建、销毁线程。

因此，这里我们可以引入线程池，代码如图：

线程池，解决的事频繁创建销毁的问题。

如果当前场景是线程频繁创建，但是不销毁呢？（扩展话题）

每个客户端如果处理过程都很短(网站)，线程池可以解决这种频繁创建消耗的问题。

但是每个客户端处理过程都很长呢 （例如吃鸡、王者、LOL等待），如果继续使用线程池 / 多线程，此时就会导致当前的服务器上一下积累了大量线程 ，此时对于服务器的负担就会非常重！！

为了解决上述积累大量线程的问题，可以引入以下的方案：

1、协程

轻量级线程。本质还是一个线程，用户态可以通过手动调度的方式，让这一个线程 "并发" 的做多个任务。（Go / Python）

2、IO多路复用

系统内核级别的机制，本质上是让一个线程同时去负责处理多个 socket 。本质在于这些 socket 数据并非是同一时刻都需要处理。

基本盘在于，虽然有多个 socket ，但是同一时刻活跃的 socket 只是少数（需要读写数据的 socket），大部分 socket 都是在等，使用一个线程来等多个 socket。 就像去路边摊吃小吃，有很多小吃，我可以在我想吃的小吃店，依次都付款，然后站在这些店的中间，哪个路边摊先做好就去哪个路边摊拿小吃，这样等的过程，就可以节约出很多时间。