Java Web 实战 15 - 计算机网络之网络编程套接字

短命女 2024-03-25 22:06 42阅读 0赞

#### 文章目录 ####

*  一 . 网络编程中的基本概念
 *   *  1.1 网络编程
     *  1.2 客户端(client) / 服务器(server)
     *  1.3 请求(request) / 响应(response)
     *  1.4 客户端和服务器之间的交互数据
     *   *  1.4.1 一问一答
         *  1.4.2 多问一答
         *  1.4.3 一问多答
         *  1.4.4 多问多答
 *  二 . socket 套接字
 *   *  2.1 UDP 的 Socket API
     *   *  2.1.1 引子
         *  2.1.2 服务器代码
         *  2.1.3 客户端代码
         *  2.1.4 通过代码分析 UDP 的特点
         *  2.1.5 小结
         *  2.1.6 当我们发现某个端口 , 被其他进程占用了 , 单只咱们服务器启动不起来 , 怎么办 ?
     *  2.2 TCP 的 Socket API
     *   *  2.2.1 引子
         *  2.2.2 服务器的代码
         *  2.2.3 客户端的代码
         *  2.2.4 其他 Bug
         *  2.2.5 解决缺陷 : 频繁创建销毁
         *  2.2.6 TCP 版本的翻译服务器
 *  三 . 小结
 *   *  3.1 Socket API
     *  3.2 客户端/服务器 工作流程
     *  3.3 TCP 的 Socket API 中 , 服务器使用多线程

> 大家好 , 这篇文章给大家带来的是网络编程中的套接字 , 我们会着重讲解 socket 的套接字 , 包括了 UDP 的 Socket API 和 TCP 的 Socket API , 干货十足  
> 推荐大家跳转到[此链接][Link 1]查看文章  
> [上一篇文章][Link 2]的链接也给大家贴在这里了  
> [文章专栏][Link 3]在此  
> ![在这里插入图片描述][f1b23485b46f4039b2df372c241aebc3.png]

## 一 . 网络编程中的基本概念 ##

### 1.1 网络编程 ###

写代码 , 实现 两个/多个 进程 , 通过网络 , 来进行相互通信

我们之前介绍过 : 进程具有隔离性 (每个进程都有自己独立的虚拟地址空间)  
进程间通信 , 借助每一个进程都能访问到的公共区域 , 完成数据交换  
网络编程 , 也是一种进程间通信的方式 , 借助的公共区域就是网卡 , 这是当下最主流的方式 , 既能够让同一个主机的多个进程间通信 , 也可以让不同主机的多个进程间通信

### 1.2 客户端(client) / 服务器(server) ###

客户端 : **主动**发送网络数据的一方  
服务器 : **被动**接受网络数据的一方

> 因为服务器无法知道客户端什么时候发送来资源 , 因此就只能长时间运行 , 甚至 7\*24 小时运行

### 1.3 请求(request) / 响应(response) ###

请求 : 客户端给服务器发送的数据.  
响应 : 服务器给客户端返回的数据.

### 1.4 客户端和服务器之间的交互数据 ###

#### 1.4.1 一问一答 ####

客户端给服务器发个请求 , 服务器给客户端返回个响应  
这是最常见的方式 , 比如 : 浏览网页

#### 1.4.2 多问一答 ####

客户端发多个请求 , 服务器返回一个响应  
更少见一些 , 比如上传文件

#### 1.4.3 一问多答 ####

客户端发一个请求 , 服务器返回多个响应  
还比较常见 , 比如下载文件

#### 1.4.4 多问多答 ####

客户端发送多个请求 , 服务器返回多个响应  
比如 : 远程控制、游戏串流

> 所谓“**串流游戏**”，实际上是指通过有线或无线 WiFi 网络，将 PC / macOS / Linux 电脑上的游戏画面 实时“远程投射” 到另外一台设备屏幕上，如 iPhone、iPad、安卓手机、平板、智能电视或笔记本上，并进行远程游**玩**。

## 二 . socket 套接字 ##

进行网络编程 , 需要使用操作系统提供的网络编程 API  
![image.png][]  
在传输层提供了两个非常重要且截然不同的协议 : TCP 和 UDP  
这两个协议对应的 socket api 也是完全不同的  
先简单的给大家总结一下 TCP 和 UDP  
TCP : 有连接 , 可靠传输 , 面向字节流 , 全双工  
UDP : 无连接 , 不可靠传输 , 面向数据报 , 全双工

有连接 : 打电话 -> 先建立连接 , 然后再通信  
无连接 : 发微信 -> 不必建立连接 , 直接通信即可

网络通信无法保证 100% 到达的 (最糟糕的情况 : 网线被修狗咬断了)  
可靠传输 : 数据 对方收没收到 , 发送方能够有感知  
不可靠传输 : 数据 对方收没收到 , 发送方啥也不知道  
打电话就相当于可靠传输 , 发微信就相当于不可靠传输

面向字节流 : 这里的字节流和文件那里的字节流是一样的 , 像水流一样 , 想传多少就传多少  
面向数据报 : 以数据报作为传输的基本单位

全双工 : 双向通信 , 一个管道 , 能够 A -> B , 同时也能 B -> A (同时进行)  
半双工 : 单向通信 , 一个管道 , 同一时刻 , 只能够 A -> B , 要么 B -> A (合走各的)  
![image.png][image.png 1]  
类似 , 网络通信主要借助网线来进行通信 . 一个标准的以太网线 , 里面其实是 8 根铜线 , 就分成了两条路 : 4 条线用来上传 , 4 条路用来下载

### 2.1 UDP 的 Socket API ###

#### 2.1.1 引子 ####

在 UDP 的 Socket API 中 , 有两个核心类 :  
DatagramSocket :  
叫做 socket 类 , 本质上相当于是一个 “文件” . 在系统中 , 还有一种特殊的 socket 文件 , 对应到网卡设备 .  
要想进行网络通信 , 就需要先打开 socket 文件 . 我们构造一个 DatagramSocket 对象 , 就相当于打开了一个内核中的 socket 文件 .  
打开之后 , 就可以传输数据了  
传输数据通过两个方法 : send(发送数据)、receive(接受数据)  
还有一个 close 操作关闭文件

DatagramPacket :  
表示一个 UDP 数据报 , UDP 是面向数据报的协议 , 传输数据 , 就是以 DatagramPacket 为基本单位

还有一个非常重要的类 : InetSocketAddress  
他描述了网络上的一个地址 , 也就是 IP 地址 + 端口号

接下来 , 我们来写一个 UDP版本的回显服务器-客户端 (echo server)

> 回显服务器 : 客户端发什么 , 服务器返回什么  
> 不涉及任何业务逻辑 , 单纯演示 API 的用法

我们创建两个类 : UdpEchoServer(回显服务器) 和 UdpEchoClient(回显客户端)  
先编写服务器代码

#### 2.1.2 服务器代码 ####

package network;
    
    import java.io.IOException;
    import java.net.DatagramPacket;
    import java.net.DatagramSocket;
    import java.net.SocketException;
    
    public class UdpEchoServer {
        
        // 要想创建 UDP 服务器,就需要先打开一个 socket 文件
        // 先不进行初始化
        private DatagramSocket socket = null;
    
        // 在构造方法中进行初始化
        // 创建实例的同时指定端口号(绑定一个端口) -> 把一个进程和一个端口号关联起来
        public UdpEchoServer(int port) throws SocketException {
        
            socket = new DatagramSocket(port);
        }
    
        // 启动服务器
        public void start() throws IOException {
        
            System.out.println("服务器已经启动");
            // 服务器是 7*24 运行的
            while (true) {
        
                // 1. 读取客户端发来的请求
                // 尝试读取,并不是调用了就一定能读到
                // 如果客户端没有发来请求,就会阻塞等待
                // 直到真的有客户端的请求过来了,receive才会返回
                // receive 属于输出型参数
                // 我们需要先构造参数,然后将数据写入到输出型参数中
                DatagramPacket requestPacket = new DatagramPacket(new byte[4096], 4096);
                socket.receive(requestPacket);
    
                // 2. 对请求进行解析(把 DatagramPacket 转换成 String)
                // requestPacket 内部就是字节数组,用 getData 将内部的字节数组取出来
                // 再设置从哪到哪取出
                String request = new String(requestPacket.getData(), 0, requestPacket.getLength());
    
                // 3. 根据请求处理响应
                // 虽然咱们这里是个回显服务器,但是还是可以单独搞个方法处理响应
                String response = process(request);
    
                // 4. 把响应构造成 DatagramPacket 对象
                // 第一个参数:把 String 转换成字节数组
                // 第二个参数:返回的字节数组的长度
                // 第三个参数:构造响应对象->谁给咱们发来的请求,就把响应发给谁
                DatagramPacket responsePacket = new DatagramPacket(
                        response.getBytes(),
                        response.getBytes().length,
                        requestPacket.getSocketAddress()
                );
    
                // 5. 把 DatagramPacket 返回
                socket.send(responsePacket);
    
                // 打印日志
                // IP地址+端口号+请求+响应
                System.out.printf("[%s:%d] req=%s resp=%s\n",
                        requestPacket.getAddress().toString(),
                        requestPacket.getPort(),
                        request,
                        response);
            }
        }
    
        // 根据请求处理响应
        // 回显服务器:不用处理任何逻辑
        public String process(String request) {
        
            return request;
        }
    
        // 启动服务器
        public static void main(String[] args) throws IOException {
        
            // 端口号可以在一定范围内(0~65535)随便写
            // 一般来说,1024以下的端口是系统留着自己用的,我们就不跟他抢了
            UdpEchoServer server = new UdpEchoServer(8000);
            server.start();
        }
    }

其中 , 服务器的代码中有许多问题 , 我们也在这张图片里面给大家讲解了  
![image.png][image.png 2]

再去编写客户端的代码

#### 2.1.3 客户端代码 ####

package network;
    
    import java.io.IOException;
    import java.net.*;
    import java.util.Scanner;
    
    public class UdpEchoClient {
        
        // 还是一样,先设置成 null
        private DatagramSocket socket = null;
    
        // 客户端的端口号一般都是操作系统自动分配的
        public UdpEchoClient() throws SocketException {
        
            socket = new DatagramSocket();
        }
    
        public void start() throws IOException {
        
            // 前置工作:让用户往控制台中输入请求内容
            Scanner sc = new Scanner(System.in);
    
            while (true) {
        
                // 1. 让客户端从控制台读取一个请求数据
                System.out.print("> ");
                String request = sc.next();
    
                // 2. 把这个字符串请求发送给服务器
                // 就需要构造 DatagramPacket
                // 构造的 DatagramPacket 既要包含要传输的数据,还要指定要把数据传输到哪里
                DatagramPacket requestPacket = new DatagramPacket(
                        request.getBytes(),
                        request.getBytes().length,
                        InetAddress.getByName("127.0.0.1")
                        , 8000
                );
    
                // 3. 把数据报发给服务器
                socket.send(requestPacket);
    
                // 4. 从服务器读取响应数据
                DatagramPacket responsePacket = new DatagramPacket(new byte[4096], 4096);
                socket.receive(responsePacket);
    
                // 5. 把响应的数据获取出来,转成字符串
                String response = new String(responsePacket.getData(), 0, responsePacket.getLength());
    
                // 6. 打印报文
                System.out.printf("req:%s,resp:%s\n", request, response);
    
            }
        }
    
        public static void main(String[] args) throws IOException {
        
            UdpEchoClient client = new UdpEchoClient();
            client.start();
        }
    }

我把客户端的代码中常见问题也展示在下方了  
![image.png][image.png 3]

我们来梳理一下客户端和服务器的工作流程  
![无标题2.png][2.png]  
这个事情 , 就相当于客户端想干一件事 , 但是不想亲力亲为 , 就要安排给别人做  
上述流程 , 不仅仅是回显服务器客户端如此 , 大部分的客户端服务器都是如此 . 这是一套基本套路

我们运行一下  
![image.png][image.png 4]  
另外 , 我们的服务器是可以给多个客户端提供服务的  
我们可以再运行一个客户端 , 不过需要设置  
![image.png][image.png 5]  
![image.png][image.png 6]  
![image.png][image.png 7]  
把这个选项勾选上 , 就可以启动多个客户端了  
![image.png][image.png 8]

一个服务器的灵魂所在 , 就是 process 方法  
一个服务器要完成的工作 , 都是通过 “根据请求计算相应” 来体现的 .  
不管是啥样的服务器 , 读取请求并解析 , 构造响应并返回 , 这两个步骤 , 大同小异  
唯有 “根据请求计算相应” 是千变万化的 , 是非常复杂的 , 可能一次处理请求就要经历 几w 几十w行 的代码来完成  
如果我现在不是想写一个回显服务器了 , 而是一个带有业务逻辑的服务器 , 基于上述框架 , 稍作修改即可  
![image.png][image.png 9]  
举个栗子 : 我们新建一个 UdpDictServer 类(字典服务器 / 翻译服务器)  
我们希望实现一个 英译汉 的效果  
请求是一个英文单词 , 响应是他对应的翻译  
UdpDictServer 只需要继承我们之前写过的 UdpEchoServer 即可

package network;
    
    // 翻译服务器
    // 我们希望实现一个 英译汉 的效果
    // 请求是一个英文单词 , 响应是他对应的翻译
    
    import java.io.IOException;
    import java.net.SocketException;
    import java.util.HashMap;
    
    // 我们之前已经实现过最基础的翻译服务器
    // 只需要继承这个最简单的服务器,然后在这基础上稍加改动即可
    public class UdpDictServer extends UdpEchoServer {
        
        private HashMap<String, String> dict = new HashMap<>();
    
        public UdpDictServer(int port) throws SocketException {
        
            super(port);
    
            // 我们在构造方法中构造数据
            dict.put("cat", "小猫");
            dict.put("dog", "小狗");
            dict.put("ox", "小牛");
        }
    
        // 和父类的 UdpEchoServer 相比
        // 只需要修改 process 方法
        @Override
        public String process(String request) {
        
            // getOrDefault:哈希表中,有就返回.没有,就返回"我也不会"
            return dict.getOrDefault(request, "这个词我也不会");
        }
    
        public static void main(String[] args) throws IOException {
        
            UdpDictServer udpDictServer = new UdpDictServer(8000);
            udpDictServer.start();
        }
    }

客户端还用我们刚才写好的即可  
运行一下  
![image.png][image.png 10]

#### 2.1.4 通过代码分析 UDP 的特点 ####

UDP 是无连接的  
![image.png][image.png 11]  
UDP 是不可靠传输 , 这个在我们的代码中是看不出来的 , 是操作系统就这样实现的  
UDP 是面向数据报的  
![image.png][image.png 12]  
UDP 是全双工的  
![image.png][image.png 13]

#### 2.1.5 小结 ####

总结一下 : UDP 版本的 Socket API 有两个核心类  
DatagramSocket : 表式内核里面的 socket 文件

*  send
 *  receive
 *  close

DatagramPacket : 发送接收数据的基本单位  
构造方法 :

1.  只包含缓冲区 , 用于接收数据的时候 , 构造了一个空的数据报.
2.  包含缓冲区和一个 InetAddress , 用于发送数据的时候 , 指定数据包含啥以及发到哪里去.
3.  包含缓冲区和一个 InetAddress + int , 用于发送数据的时候 , 指定数据包含啥以及发到哪里去.

但是我们刚才写的代码 , 并没有去 close 啊  
文件打开之后 , 用完了就要及时关闭啊 , 那上述代码中为啥没 close ?  
我们的服务器一般都是 7\*24 小时运行的 , 上述代码中的 socket 对象 , 生命周期应该是伴随整个进程的  
因此 , 进程结束之前 , 提前关闭 socket 对象是不合适的  
而且如果进程已经结束 , 对应的 PCB 也就没了 , PCB 中的文件描述符表也就没了 . 此时也就相当于是关闭了

#### 2.1.6 当我们发现某个端口 , 被其他进程占用了 , 单只咱们服务器启动不起来 , 怎么办 ? ####

使用 netstat 命令来找到是哪个进程占用的  
`netstat -ano | findstr "8000"`  
![image.png][image.png 14]  
通过这条指令 , 就可以找到对应进程的 PID 了  
我们就可以去任务管理器中找到对应线程然后关闭它

### 2.2 TCP 的 Socket API ###

#### 2.2.1 引子 ####

在 TCP 的 Socket API 中 , 主要涉及两个主要的类 :  
**ServerSocket API : 服务器端使用的 Socket**  
构造方法 : ServerSocket(int port) , 创建一个服务端流套接字Socket，并绑定到指定端口  
核心方法 :  
accept() : accept没有参数 , 返回值是一个 Socket 对象 , 功能是等待有客户端和服务器建立上连接.  
accept 则会把这个连接获取到进程中 , 进一步的通过返回值的 Socket 对象来和客户端进行交互

**Socket : 服务器和客户端都会使用的 Socket**  
通过 Socket 对象,就可以进行发送/接收数据了.  
核心方法 :  
InputStream getInputStream()  
OutputStream getOutputStream()  
通过这两个方法 , 传输数据不再通过 Socket 对象 , 而是 Socket 内部包含了输入流对象和输出流对象  
借助输入流对象来去读数据 , 也就是接收数据  
借助输出流对象来去写数据 , 也就是发送数据

举个栗子 : 比如我们去万达吃饭 , 一般每个店铺都会让一个人专门在门口拉客  
一位小哥哥把我们叫住 , 问我们想不想吃火锅 , 我们就跟他进去了  
进去店铺之后 , 小哥哥就把我们交给一位小姐姐 , 接下来就是这个美女来服务我们  
这种店铺是有明确分工的 , 小哥哥是外场拉客的 , 小姐姐是内场提供服务的  
外场拉客就相当于 ServerSocket  
内场服务就相当于 Socket  
当外场小哥哥拉到了客人 (有连接过来了) , 就通过 accept 把连接交给了 Socket , 后续就通过 Socket 对象和客户端进行沟通

#### 2.2.2 服务器的代码 ####

package network;
    
    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 {
        
        private ServerSocket serverSocket = null;
    
        public TcpEchoServer(int port) throws IOException {
        
            serverSocket = new ServerSocket(port);
        }
    
        public void start() throws IOException {
        
            System.out.println("服务器已经启动");
            while (true) {
        
                // accept 干的活是拉客
                // 对于操作系统来说,建立一个 TCP 连接,是内核操作
                // accept 要干的就是等连接建立好了,把这个连接给拿到应用程序中
                // 如果当前连接还未建立,accpet就会阻塞等待
                // accept 相当于有人给你打电话了,你按下接听键.如果没人给你打电话,你就会阻塞等待直到有人给你打电话
                Socket clientSocket = serverSocket.accept();
    
                processConnect(clientSocket);
            }
        }
    
        // 通过这个方法,给当前连接上的客户端提供服务
        // 一个连接过来了,服务方式可能有两种
        // 1. 一个连接只进行一次数据交互(一个请求+一个响应)  短连接
        // 2. 一个连接进行多次数据交互(N个请求+N个响应)     长连接
        // 此处是长连接的版本
        public void processConnect(Socket clientSocket) throws IOException {
        
            // 在最开始获取一下 IP地址和端口号
            System.out.printf("[%s,%d] 建立连接\n", clientSocket.getInetAddress().toString(), clientSocket.getPort());
            /*
            // 接收数据
            InputStream inputStream = clientSocket.getInputStream();
            // 发送数据
            OutputStream outputStream = clientSocket.getOutputStream();
            */
    
            // 使用字节流是不方便的
            // 我们就可以用 Scanner PrintWriter 来对他们进行封装
            try (InputStream inputStream = clientSocket.getInputStream(); OutputStream outputStream = clientSocket.getOutputStream()) {
        
                // 接收数据
                Scanner scanner = new Scanner(inputStream);
                // 发送数据
                PrintWriter printWriter = new PrintWriter(outputStream);
                // 长连接的写法 -> 循环
                while (true) {
        
                    // 判断还有没有数据
                    // 读完了,后面没有数据,就相当于读到了 EOF
                    // 这个操作就代表客户端断开连接,此时 hasNext 返回 false
                    if (!scanner.hasNext()) {
        
                        // 连接断开
                        // 打印一下哪个 IP+端口 连接断开了
                        System.out.printf("[%s,%d] 断开连接\n", clientSocket.getInetAddress().toString(), clientSocket.getPort());
                        break;
                    }
                    // 1. 读取请求并解析
                    String request = scanner.next();
                    // 2. 根据请求计算响应
                    String response = process(request);
                    // 3. 把响应写回客户端
                    printWriter.write(response);
                    // 刷新一下缓冲区,避免数据真的没有发出去
                    printWriter.flush();
                    // 每次发送完毕,再来打印一下相关信息
                    System.out.printf("[%s,%d] req:%s,resp=%s\n", 
                            clientSocket.getInetAddress().toString(), 
                            clientSocket.getPort(), 
                            request, 
                            response);
                }
            }
        }
    
        // 回显服务器
        public String process(String request) {
        
            return request;
        }
    
        public static void main(String[] args) throws IOException {
        
            TcpEchoServer server = new TcpEchoServer(8000);
            server.start();
        }
    }

上面的代码跟文件操作非常类似  
因为 TCP 是面向字节流的 , Java 中就把 TCP 的相关方法设置成跟文件类似的操作了

#### 2.2.3 客户端的代码 ####

package network;
    
    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 {
        
        // 在 TcpEchoServer 中需要 ServerSocket Socket 对象全部用到
        // 在 TcpEchoClient 中只需要 Socket 对象即可
        private Socket socket = null;
    
        public TcpEchoClient() throws IOException {
        
            // new 对象的时候就需要和服务器建立连接了
            // 要想建立连接,就需要知道服务器在哪里(IP地址+端口)
            socket = new Socket("127.0.0.1", 8000);
        }
    
        public void start() throws IOException {
        
            // 用户从控制台输入
            Scanner scanner = new Scanner(System.in);
            // 由于我们是实现的是长连接,一个连接会处理 N 个请求和响应
            try (
                    InputStream inputStream = socket.getInputStream();
                    OutputStream outputStream = socket.getOutputStream();
            ) {
        
                // 从网络输入
                Scanner scannerNet = new Scanner(inputStream);
                PrintWriter printWriter = new PrintWriter(outputStream);
    
                while (true) {
        
                    // 1. 从控制台读取用户输入什么?
                    System.out.print("> ");
                    String request = scanner.next();
                    // 2. 把请求发送给服务器
                    printWriter.write(request);
                    printWriter.flush();
                    // 3. 从服务器读取响应
                    String response = scannerNet.next();
                    // 4. 把结果显示到界面上
                    System.out.printf("req:%s,resp:%s\n", request, response);
                }
            }
        }
    
        public static void main(String[] args) throws IOException {
        
            TcpEchoClient client = new TcpEchoClient();
            client.start();
        }
    }

![image.png][image.png 15]  
运行一下吧 (大家注意 : 要先启动服务器 , 再启动客户端)

> 得先餐馆开业 , 咱们才能去吃饭

![Demo.png][]  
那改正好的代码也贴给大家  
TcpEchoServer

package network;
    
    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 {
        
        private ServerSocket serverSocket = null;
    
        public TcpEchoServer(int port) throws IOException {
        
            serverSocket = new ServerSocket(port);
        }
    
        public void start() throws IOException {
        
            System.out.println("服务器已经启动");
            while (true) {
        
                // accept 干的活是拉客
                // 对于操作系统来说,建立一个 TCP 连接,是内核操作
                // accept 要干的就是等连接建立好了,把这个连接给拿到应用程序中
                // 如果当前连接还未建立,accpet就会阻塞等待
                // accept 相当于有人给你打电话了,你按下接听键.如果没人给你打电话,你就会阻塞等待直到有人给你打电话
                Socket clientSocket = serverSocket.accept();
    
                processConnect(clientSocket);
            }
        }
    
        // 通过这个方法,给当前连接上的客户端提供服务
        // 一个连接过来了,服务方式可能有两种
        // 1. 一个连接只进行一次数据交互(一个请求+一个响应)  短连接
        // 2. 一个连接进行多次数据交互(N个请求+N个响应)     长连接
        // 此处是长连接的版本
        public void processConnect(Socket clientSocket) throws IOException {
        
            // 在最开始获取一下 IP地址和端口号
            System.out.printf("[%s,%d] 建立连接\n", clientSocket.getInetAddress().toString(), clientSocket.getPort());
            /*
            // 接收数据
            InputStream inputStream = clientSocket.getInputStream();
            // 发送数据
            OutputStream outputStream = clientSocket.getOutputStream();
            */
    
            // 使用字节流是不方便的
            // 我们就可以用 Scanner PrintWriter 来对他们进行封装
            try (InputStream inputStream = clientSocket.getInputStream(); OutputStream outputStream = clientSocket.getOutputStream()) {
        
                // 接收数据
                Scanner scanner = new Scanner(inputStream);
                // 发送数据
                PrintWriter printWriter = new PrintWriter(outputStream);
                // 长连接的写法 -> 循环
                while (true) {
        
                    // 判断还有没有数据
                    // 读完了,后面没有数据,就相当于读到了 EOF
                    // 这个操作就代表客户端断开连接,此时 hasNext 返回 false
                    if (!scanner.hasNext()) {
        
                        // 连接断开
                        // 打印一下哪个 IP+端口 连接断开了
                        System.out.printf("[%s,%d] 断开连接\n", clientSocket.getInetAddress().toString(), clientSocket.getPort());
                        break;
                    }
                    // 1. 读取请求并解析
                    String request = scanner.next();
                    // 2. 根据请求计算响应
                    String response = process(request);
                    // 3. 把响应写回客户端
                    printWriter.println(response);
                    // 刷新一下缓冲区,避免数据真的没有发出去
                    printWriter.flush();
                    // 每次发送完毕,再来打印一下相关信息
                    System.out.printf("[%s,%d] req:%s,resp=%s\n",
                            clientSocket.getInetAddress().toString(),
                            clientSocket.getPort(),
                            request,
                            response);
                }
            }
        }
    
        // 回显服务器
        public String process(String request) {
        
            return request;
        }
    
        public static void main(String[] args) throws IOException {
        
            TcpEchoServer server = new TcpEchoServer(8000);
            server.start();
        }
    }

TcpEchoClient

package network;
    
    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 {
        
        // 在 TcpEchoServer 中需要 ServerSocket Socket 对象全部用到
        // 在 TcpEchoClient 中只需要 Socket 对象即可
        private Socket socket = null;
    
        public TcpEchoClient() throws IOException {
        
            // new 对象的时候就需要和服务器建立连接了
            // 要想建立连接,就需要知道服务器在哪里(IP地址+端口)
            socket = new Socket("127.0.0.1", 8000);
        }
    
        public void start() throws IOException {
        
            // 用户从控制台输入
            Scanner scanner = new Scanner(System.in);
            // 由于我们是实现的是长连接,一个连接会处理 N 个请求和响应
            try (
                    InputStream inputStream = socket.getInputStream();
                    OutputStream outputStream = socket.getOutputStream();
            ) {
        
                // 从网络输入
                Scanner scannerNet = new Scanner(inputStream);
                PrintWriter printWriter = new PrintWriter(outputStream);
    
                while (true) {
        
                    // 1. 从控制台读取用户输入什么?
                    System.out.print("> ");
                    String request = scanner.next();
                    // 2. 把请求发送给服务器
                    printWriter.println(request);
                    printWriter.flush();
                    // 3. 从服务器读取响应
                    String response = scannerNet.next();
                    // 4. 把结果显示到界面上
                    System.out.printf("req:%s,resp:%s\n", request, response);
                }
            }
        }
    
        public static void main(String[] args) throws IOException {
        
            TcpEchoClient client = new TcpEchoClient();
            client.start();
        }
    }

代码出现 “卡死” 的情况 , 一定先不要慌 . 先冷静 , 然后仔细分析  
线程阻塞了 , 就得知道具体是在哪里阻塞的 , 可以使用 jconsole 或者使用其他工具 , 定位到是哪个代码阻塞的  
结合代码分析阻塞的原因 , 然后给出解决方案再次进行验证

#### 2.2.4 其他 Bug ####

1.  上述代码中,使用 clientSocket , 用完之后 , 是否要关闭呢 ?

当然要关闭  
和上面的 ServerSocket 不同 , ServerSocket 的生命周期 , 是跟随整个程序的 .  
clientSocket 的生命周期 , 只是当前连接 . 就应该在连接之后 , 把这里的 socket 进行关闭  
如果不关的话 , 就会造成内存泄漏  
ServerSocket，只有一个 , 但是 clientSocket 会有无数个 . 每个客户端的连接 , 都是一个 clientSocket  
![image.png][image.png 16]

package network;
    
    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 {
        
        private ServerSocket serverSocket = null;
    
        public TcpEchoServer(int port) throws IOException {
        
            serverSocket = new ServerSocket(port);
        }
    
        public void start() throws IOException {
        
            System.out.println("服务器已经启动");
            while (true) {
        
                // accept 干的活是拉客
                // 对于操作系统来说,建立一个 TCP 连接,是内核操作
                // accept 要干的就是等连接建立好了,把这个连接给拿到应用程序中
                // 如果当前连接还未建立,accpet就会阻塞等待
                // accept 相当于有人给你打电话了,你按下接听键.如果没人给你打电话,你就会阻塞等待直到有人给你打电话
                Socket clientSocket = serverSocket.accept();
    
                processConnect(clientSocket);
    
    
            }
        }
    
        // 通过这个方法,给当前连接上的客户端提供服务
        // 一个连接过来了,服务方式可能有两种
        // 1. 一个连接只进行一次数据交互(一个请求+一个响应)  短连接
        // 2. 一个连接进行多次数据交互(N个请求+N个响应)     长连接
        // 此处是长连接的版本
        public void processConnect(Socket clientSocket) throws IOException {
        
            // 在最开始获取一下 IP地址和端口号
            System.out.printf("[%s,%d] 建立连接\n", clientSocket.getInetAddress().toString(), clientSocket.getPort());
            /*
            // 接收数据
            InputStream inputStream = clientSocket.getInputStream();
            // 发送数据
            OutputStream outputStream = clientSocket.getOutputStream();
            */
    
            // 使用字节流是不方便的
            // 我们就可以用 Scanner PrintWriter 来对他们进行封装
            try (InputStream inputStream = clientSocket.getInputStream(); OutputStream outputStream = clientSocket.getOutputStream()) {
        
                // 接收数据
                Scanner scanner = new Scanner(inputStream);
                // 发送数据
                PrintWriter printWriter = new PrintWriter(outputStream);
                // 长连接的写法 -> 循环
                while (true) {
        
                    // 判断还有没有数据
                    // 读完了,后面没有数据,就相当于读到了 EOF
                    // 这个操作就代表客户端断开连接,此时 hasNext 返回 false
                    if (!scanner.hasNext()) {
        
                        // 连接断开
                        // 打印一下哪个 IP+端口 连接断开了
                        System.out.printf("[%s,%d] 断开连接\n", clientSocket.getInetAddress().toString(), clientSocket.getPort());
                        break;
                    }
                    // 1. 读取请求并解析
                    String request = scanner.next();
                    // 2. 根据请求计算响应
                    String response = process(request);
                    // 3. 把响应写回客户端
                    printWriter.println(response);
                    // 刷新一下缓冲区,避免数据真的没有发出去
                    printWriter.flush();
                    // 每次发送完毕,再来打印一下相关信息
                    System.out.printf("[%s,%d] req:%s,resp=%s\n",
                            clientSocket.getInetAddress().toString(),
                            clientSocket.getPort(),
                            request,
                            response);
                }
            } finally {
        
                // 加在这里更稳妥
                clientSocket.close();
            }
        }
    
        // 回显服务器
        public String process(String request) {
        
            return request;
        }
    
        public static void main(String[] args) throws IOException {
        
            TcpEchoServer server = new TcpEchoServer(8000);
            server.start();
        }
    }

1.  上述代码 , 无法处理多个客户端

![image.png][image.png 17]  
当我们断开第一个客户端  
![image.png][image.png 18]  
上述行为 , 当然是 Bug . 一个服务器 , 能处理多个客户端 , 这是天经地义的事情  
![无标题.png][.png]  
![image.png][image.png 19]

package network;
    
    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 {
        
        private ServerSocket serverSocket = null;
    
        public TcpEchoServer(int port) throws IOException {
        
            serverSocket = new ServerSocket(port);
        }
    
        public void start() throws IOException {
        
            System.out.println("服务器已经启动");
            while (true) {
        
                // accept 干的活是拉客
                // 对于操作系统来说,建立一个 TCP 连接,是内核操作
                // accept 要干的就是等连接建立好了,把这个连接给拿到应用程序中
                // 如果当前连接还未建立,accpet就会阻塞等待
                // accept 相当于有人给你打电话了,你按下接听键.如果没人给你打电话,你就会阻塞等待直到有人给你打电话
                Socket clientSocket = serverSocket.accept();
    
                // 我们在这里不再直接调用了,二是创建新的线程,让新的线程来调用
                // processConnect(clientSocket);
                Thread t = new Thread(() -> {
        
                    try {
        
                        processConnect(clientSocket);
                    } catch (IOException e) {
        
                        e.printStackTrace();
                    }
                });
                t.start();
            }
        }
    
        // 通过这个方法,给当前连接上的客户端提供服务
        // 一个连接过来了,服务方式可能有两种
        // 1. 一个连接只进行一次数据交互(一个请求+一个响应)  短连接
        // 2. 一个连接进行多次数据交互(N个请求+N个响应)     长连接
        // 此处是长连接的版本
        public void processConnect(Socket clientSocket) throws IOException {
        
            // 在最开始获取一下 IP地址和端口号
            System.out.printf("[%s,%d] 建立连接\n", clientSocket.getInetAddress().toString(), clientSocket.getPort());
            /*
            // 接收数据
            InputStream inputStream = clientSocket.getInputStream();
            // 发送数据
            OutputStream outputStream = clientSocket.getOutputStream();
            */
    
            // 使用字节流是不方便的
            // 我们就可以用 Scanner PrintWriter 来对他们进行封装
            try (InputStream inputStream = clientSocket.getInputStream(); OutputStream outputStream = clientSocket.getOutputStream()) {
        
                // 接收数据
                Scanner scanner = new Scanner(inputStream);
                // 发送数据
                PrintWriter printWriter = new PrintWriter(outputStream);
                // 长连接的写法 -> 循环
                while (true) {
        
                    // 判断还有没有数据
                    // 读完了,后面没有数据,就相当于读到了 EOF
                    // 这个操作就代表客户端断开连接,此时 hasNext 返回 false
                    if (!scanner.hasNext()) {
        
                        // 连接断开
                        // 打印一下哪个 IP+端口 连接断开了
                        System.out.printf("[%s,%d] 断开连接\n", clientSocket.getInetAddress().toString(), clientSocket.getPort());
                        break;
                    }
                    // 1. 读取请求并解析
                    String request = scanner.next();
                    // 2. 根据请求计算响应
                    String response = process(request);
                    // 3. 把响应写回客户端
                    printWriter.println(response);
                    // 刷新一下缓冲区,避免数据真的没有发出去
                    printWriter.flush();
                    // 每次发送完毕,再来打印一下相关信息
                    System.out.printf("[%s,%d] req:%s,resp=%s\n",
                            clientSocket.getInetAddress().toString(),
                            clientSocket.getPort(),
                            request,
                            response);
                }
            } finally {
        
                // 加在这里更稳妥
                clientSocket.close();
            }
        }
    
        // 回显服务器
        public String process(String request) {
        
            return request;
        }
    
        public static void main(String[] args) throws IOException {
        
            TcpEchoServer server = new TcpEchoServer(8000);
            server.start();
        }
    }

#### 2.2.5 解决缺陷 : 频繁创建销毁 ####

我们目前的代码 : 来一个客户端 , 就要创建线程 . 客户端创建连接 , 就要销毁线程  
如果客户端很多 , 就是 **“频繁的创建和销毁线程”**  
我们就需要使用到\*\* 线程池\*\*

package network;
    
    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;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    public class TcpEchoServer {
        
        private ServerSocket serverSocket = null;
    
        public TcpEchoServer(int port) throws IOException {
        
            serverSocket = new ServerSocket(port);
        }
    
        public void start() throws IOException {
        
            System.out.println("服务器已经启动");
            // 线程池要放在外面
            ExecutorService service = Executors.newCachedThreadPool();// 可自动扩容版本
            while (true) {
        
                // accept 干的活是拉客
                // 对于操作系统来说,建立一个 TCP 连接,是内核操作
                // accept 要干的就是等连接建立好了,把这个连接给拿到应用程序中
                // 如果当前连接还未建立,accpet就会阻塞等待
                // accept 相当于有人给你打电话了,你按下接听键.如果没人给你打电话,你就会阻塞等待直到有人给你打电话
                Socket clientSocket = serverSocket.accept();
    
                // [版本1]单线程版本,存在 Bug,无法处理多个客户端
                // processConnect(clientSocket);
    
                // [版本2]多线程版本,主线程负责拉客,新线程负责通信
                // 我们在这里不再直接调用了,二是创建新的线程,让新的线程来调用
                // Thread t = new Thread(() -> {
        
                //     try {
        
                //         processConnect(clientSocket);
                //     } catch (IOException e) {
        
                //         e.printStackTrace();
                //     }
                // });
                // t.start();
    
                // [版本3]使用线程池来解决上面的频繁创建销毁线程的问题
                service.submit(new Runnable() {
        
                    @Override
                    public void run() {
        
                        try {
        
                            processConnect(clientSocket);
                        } catch (IOException e) {
        
                            e.printStackTrace();
                        }
                    }
                });
            }
        }
    
        // 通过这个方法,给当前连接上的客户端提供服务
        // 一个连接过来了,服务方式可能有两种
        // 1. 一个连接只进行一次数据交互(一个请求+一个响应)  短连接
        // 2. 一个连接进行多次数据交互(N个请求+N个响应)     长连接
        // 此处是长连接的版本
        public void processConnect(Socket clientSocket) throws IOException {
        
            // 在最开始获取一下 IP地址和端口号
            System.out.printf("[%s,%d] 建立连接\n", clientSocket.getInetAddress().toString(), clientSocket.getPort());
            /*
            // 接收数据
            InputStream inputStream = clientSocket.getInputStream();
            // 发送数据
            OutputStream outputStream = clientSocket.getOutputStream();
            */
    
            // 使用字节流是不方便的
            // 我们就可以用 Scanner PrintWriter 来对他们进行封装
            try (InputStream inputStream = clientSocket.getInputStream(); OutputStream outputStream = clientSocket.getOutputStream()) {
        
                // 接收数据
                Scanner scanner = new Scanner(inputStream);
                // 发送数据
                PrintWriter printWriter = new PrintWriter(outputStream);
                // 长连接的写法 -> 循环
                while (true) {
        
                    // 判断还有没有数据
                    // 读完了,后面没有数据,就相当于读到了 EOF
                    // 这个操作就代表客户端断开连接,此时 hasNext 返回 false
                    if (!scanner.hasNext()) {
        
                        // 连接断开
                        // 打印一下哪个 IP+端口 连接断开了
                        System.out.printf("[%s,%d] 断开连接\n", clientSocket.getInetAddress().toString(), clientSocket.getPort());
                        break;
                    }
                    // 1. 读取请求并解析
                    String request = scanner.next();
                    // 2. 根据请求计算响应
                    String response = process(request);
                    // 3. 把响应写回客户端
                    printWriter.println(response);
                    // 刷新一下缓冲区,避免数据真的没有发出去
                    printWriter.flush();
                    // 每次发送完毕,再来打印一下相关信息
                    System.out.printf("[%s,%d] req:%s,resp=%s\n",
                            clientSocket.getInetAddress().toString(),
                            clientSocket.getPort(),
                            request,
                            response);
                }
            } finally {
        
                // 加在这里更稳妥
                clientSocket.close();
            }
        }
    
        // 回显服务器
        public String process(String request) {
        
            return request;
        }
    
        public static void main(String[] args) throws IOException {
        
            TcpEchoServer server = new TcpEchoServer(8000);
            server.start();
        }
    }

但是目前还是存在一些缺陷 :  
当前是使用了线程池 , 来解决问题  
线程池解决的是频繁创建销毁 , 但是如果并发量太高了 , 就会导致池子里的线程特别特别多 .  
线程特别多就会导致内存等资源/调度过度开销  
再进一步的改进 , 就需要考虑能否减少线程的数目  
当前这是一个线程对应一个客户端 , 那能否想办法 , 让一个线程对应多个客户端呢 ?  
可以使用 “IO 多路复用” , 本质上就是一个线程处理多个 socket , 这是操作系统提供的机制  
在 Java 中封装之后 , 对应的东西叫做 NIO

#### 2.2.6 TCP 版本的翻译服务器 ####

package network;
    
    import java.io.IOException;
    import java.util.HashMap;
    
    public class TcpDictServer extends TcpEchoServer {
        
        private HashMap<String, String> dict = new HashMap<>();
    
        public TcpDictServer(int port) throws IOException {
        
            super(port);
    
            dict.put("cat", "小猫");
            dict.put("dog", "小狗");
            dict.put("ox", "小牛");
        }
    
        @Override
        public String process(String request) {
        
            return dict.getOrDefault(request,"我也不知道啥意思");
        }
    
        public static void main(String[] args) throws IOException {
        
            TcpDictServer server = new TcpDictServer(8000);
            server.start();
        }
    }

![image.png][image.png 20]

## 三 . 小结 ##

### 3.1 Socket API ###

UDP  
(1) DatagramSocket : 对应一个 socket 文件  
(2) DatagramPacket : 对应一个 UDP 数据报

TCP  
(1) ServerSocket : 只是在服务器这边使用 , 目的是拉客 . 其中有一个重要的方法 : accept , 他负责把操作系统内核建立好的连接拿到应用程序中 , 相当于别人给你打电话 , 你按下了接听键  
(2) Socket : 客户端和服务器都能够使用 , 负责给客人提供服务  
Socket 对象中能够获取到 InputStream (接收) 和 OutputStream (发送)

### 3.2 客户端/服务器 工作流程 ###

![image.png][image.png 21]

### 3.3 TCP 的 Socket API 中 , 服务器使用多线程 ###

TCP 服务器这里之所以使用了多线程 , 是因为在代码中处理的"长连接" (一个连接会处理 N 个请求和响应)  
客户端连接建立好了之后 , 啥时候断开连接不确定 . 这一个连接里要处理多少个请求 , 也不确定  
处理连接的循环 , 导致主循环无法继续执行到 accept 了.

大家不要误会成只要是 TCP 服务器就得使用多线程  
之前的代码如果是处理短连接 , 每次客户端一个连接只处理一个请求 . 不使用多线程也能处理多个客户端.

--------------------

那本篇文章到这里就讲解完毕了~  
如果对您有帮助的话 , 请一键三连嗷~  
![在这里插入图片描述][04ccf444000848a2849369810cd7ac08.png]

[Link 1]: https://www.yuque.com/jialebihaitao/study/quamqwbr9hkdm7fm?singleDoc#%20%E3%80%8A6.%20%E7%BD%91%E7%BB%9C%E7%BC%96%E7%A8%8B%E5%A5%97%E6%8E%A5%E5%AD%97%E3%80%8B
[Link 2]: https://blog.csdn.net/m0_53117341/article/details/129623609
[Link 3]: https://blog.csdn.net/m0_53117341/category_12186238.html?spm=1001.2014.3001.5482
[f1b23485b46f4039b2df372c241aebc3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/a3fd683e30134030a1fb684381feb341.png
[image.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/85b889de922844a3a731c6cca38c7047.png
[image.png 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/63483b6785204e96b12e8ef8641c5b39.png
[image.png 2]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/7d7d3cfa07bc45f9831c18b3bb9151d3.png
[image.png 3]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/47075e0daa4040dca76fcee136920e49.png
[2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/b00e687caca043fa90782882d10187fa.png
[image.png 4]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/1b7170a446354e539c3a87c55c082f1b.png
[image.png 5]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/e32e0133320d4ac9a2ce5106ddc04205.png
[image.png 6]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/cc8e7a2fde4c4a6ca3b3ff69f8563ea2.png
[image.png 7]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/029710ba62124b69aaef6174d01d8f60.png
[image.png 8]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/18b9a261b12c4f78a6367b10ccbf5326.png
[image.png 9]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/a82ff9ba34474839b536fdf69b95be7d.png
[image.png 10]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/7f48c1bac982443790f6e8d31ed229ef.png
[image.png 11]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/de4c2e0258d84bddbda8d2ad54d38e75.png
[image.png 12]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/8363f61e3b474c789fb6de00c37fee88.png
[image.png 13]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/07853104be2a4a269a37c7610aa6f3e6.png
[image.png 14]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/d8720eb547e6485caae0f03d748ce441.png
[image.png 15]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/d01b94db18974d838e9af8286d4ad774.png
[Demo.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/b6871b49f20a43caad3e1c50f3d1fb1c.png
[image.png 16]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/9b9a1044eb6047679bdd28be6adcaaae.png
[image.png 17]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/17fd72e2e54e47bd80b652c1c8c5dc8b.png
[image.png 18]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/1f2e3f55e658478590fc3f865d2e209c.png
[.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/c52909823be2483d944290517ed39440.png
[image.png 19]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/6816e6d0580543889f29c6422fdb937c.png
[image.png 20]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/98f7ce0863c04578806e75c3d2a61da6.png
[image.png 21]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/4100e19ee4fe49bd86cefc7cb5dc6a7b.png
[04ccf444000848a2849369810cd7ac08.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/b2f558c660ac4eabb70b1f484b7d8312.png