Java 基础进阶篇（十九）：一文搞懂网络编程

朱雀 2023-10-12 19:42 53阅读 0赞

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

*  一、网络编程概述
 *  二、网络通信三要素
 *   *  2.1 IP 地址
     *  2.2 端口
     *  2.3 协议
     *   *  2.3.1 网络通信协议的两套参考模型
         *  2.3.2 UDP 协议
         *  2.3.3 TCP 协议
 *  三、UDP通信
 *   *  3.1 DatagramPacket：数据包对象（韭菜）
     *  3.2 DatagramSocket：发送端和接收端对象（人）
     *  3.3 案例：一发一收
     *  3.4 案例：多发多收
     *  3.5 案例：同时接受多个客户端消息
 *  四、TCP通信
 *   *  4.1 TCP通信模式模拟
     *  4.2 Socket（客户端）
     *  4.3 ServerSocket（服务端）
     *  4.4 案例：一发一收
     *  4.5 案例：多发多收
     *  4.6 案例：同时接受多个客户端消息
 *  五、TCP综合案例：群聊

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

## 一、网络编程概述 ##

网络编程可以让程序与网络上的其他设备中的程序进行数据交互。

网络通信基本模式：Client-Server(CS) 、rowser/Server(BS)

*  Client-Server(CS)
    
     *  客户端：需要程序员开发实现、用户需要安装客户端。
     *  服务端：需要程序员开发实现。
 *  Browser/Server(BS)
    
     *  客户端：采用浏览器，不需要程序员开发实现、用户需要安装浏览器。
     *  服务端：需要程序员开发实现。

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

## 二、网络通信三要素 ##

三要素：IP地址、端口、协议。

### 2.1 IP 地址 ###

**IP地址**：设备在网络中的地址，是唯一的标识。常见的 IP 分类为：

*  IPV4：32位（4字节）
 *  IPv6：128位（16字节）：IPv6 分成 8 个整数，每个整数用四个十六进制位表示， 数之间用冒号分开。

**地址形式**：公网地址、和私有地址（局域网使用），`192.168.` 开头的就是常见的局域网地址，范围即为 `192.168.0.0 ~ 192.168.255.255`，专门为组织机构内部使用。

**IP常用命令**：

*  `ipconfig`：查看本机IP地址
 *  `ping IP地址`：检查网络是否连通

**特殊 IP 地址**：如本机IP `127.0.0.1`或者 `localhost` 称为回送地址也可称本地回环地址，只会寻找当前所在本机。

**IP地址基本寻路**：电脑自带 dns 服务器，用于解析域名。  
![在这里插入图片描述][f51dfb682fb04cf7854ec22e5572696c.png_pic_left]

**IP地址操作类 InetAddress**：此类表示 Internet 协议（IP）地址。常用 API 如下：

![在这里插入图片描述][574f4df0a1214576a0f8596ada23702f.png_pic_left]  
举例：

public class InetAddressDemo01 {
        
        public static void main(String[] args) throws Exception {
        
            // 1.获取本机地址对象。
            InetAddress ip1 = InetAddress.getLocalHost(); // DESKTOP-Q8LL1E1/192.168.171.1
            System.out.println(ip1.getHostName());// 192.168.171.1
            System.out.println(ip1.getHostAddress());// DESKTOP-Q8LL1E1
    
            // 2.获取域名ip对象
            InetAddress ip2 = InetAddress.getByName("www.baidu.com");
            System.out.println(ip2.getHostName()); // www.baidu.com
            System.out.println(ip2.getHostAddress()); // 182.61.200.6
    
            // 3.获取公网IP对象。
            InetAddress ip3 = InetAddress.getByName("112.80.248.76");
            System.out.println(ip3.getHostName()); // 112.80.248.76
            System.out.println(ip3.getHostAddress()); // 112.80.248.76
    
            // 4.判断是否在指定毫秒内连通该IP地址对应的主机
            System.out.println(ip3.isReachable(5000));
        }
    }

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

### 2.2 端口 ###

**端口**：应用程序在设备中唯一的标识，被规定为一个 16 位的二进制，范围是 0~65535。

**端口类型**：

*  周知端口：0~1023，被预先定义的知名应用占用（如：HTTP占用 80，FTP占用21）
 *  注册端口：1024~49151，分配给用户进程或某些应用程序。（如：Tomcat占 用8080，MySQL占用3306）
 *  动态端口：49152~65535，之所以称为动态端口，是因为它 一般不固定分配某种进程，而是动态分配

注：一个设备中不能出现两个程序的端口号一样，不同设备的相同程序，端口号要一样。

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

### 2.3 协议 ###

**协议**：数据在网络中传输的规则，常见的协议有 UDP 协议和 TCP 协议。

#### 2.3.1 网络通信协议的两套参考模型 ####

*  OSI参考模型：世界互联协议标准，全球通信规范，由于此模型过于理想化，未能在因特网上进行广泛推广。
 *  TCP/IP参考模型(或TCP/IP协议)：事实上的国际标准。

![在这里插入图片描述][1eab0e0a28e447df9f90c870ce57f6e7.png_pic_left]  
传输层的2个常见协议：TCP、UDP。

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

#### 2.3.2 UDP 协议 ####

**协议特点：**

*  UDP是一种无连接、不可靠传输的协议。
 *  将数据源IP、目的地IP和端口封装成数据包，不需要建立连接。
 *  每个数据包的大小限制在64KB内。
 *  发送不管对方是否准备好，接收方收到也不确认，故是不可靠的。
 *  可以广播发送 ，发送数据结束时无需释放资源，开销小，速度快。

**协议通信场景：** 语音通话，视频会话等。

**UDP协议比喻：**

数据包对象（韭菜）、发送端和接收端对象（人）  
![在这里插入图片描述][e0aa543c083746b08601146f752cb838.png_pic_left]

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

#### 2.3.3 TCP 协议 ####

**协议特点：**

*  使用TCP协议，必须双方先建立连接，它是一种面向连接的可靠通信协议。
 *  传输前，采用“三次握手”方式建立连接，所以是可靠的。
 *  在连接中可进行大数据量的传输。
 *  连接、发送数据都需要确认，且传输完毕后，还需释放已建立的连接，通信效率较低。

**协议通信场景：** 对信息安全要求较高的场景，例如：文件下载、金融等数据通信。

**三次握手确认连接：**  
![在这里插入图片描述][9cc2e60187b641b18098b959fe3a9778.png_pic_left]

![在这里插入图片描述][427c2ab1f1f4458cb208ac214657aa5e.png_pic_left]

**四次挥手断开连接：**  
![在这里插入图片描述][138a525ed6354fffbf82dc7dc0ef7095.png_pic_left]  
![在这里插入图片描述][99c107f43d864cdfbeb2d422a4b0d29b.png_pic_left]

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

## 三、UDP通信 ##

UDP是一种无连接、不可靠传输的协议，其将数据源IP、目的地IP和端口以及数据封装成数据包，大小限制在64KB内，直接发送出去即可。

### 3.1 DatagramPacket：数据包对象（韭菜） ###

构造器：  
![在这里插入图片描述][78ccffcf57fc417080ac4ad56ccbc45f.png_pic_left]

常用API：  
![在这里插入图片描述][f6bbae547980453fb308c03d6bc21a05.png_pic_left]

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

### 3.2 DatagramSocket：发送端和接收端对象（人） ###

构造器：  
![在这里插入图片描述][ceb5eb34942f45189770cd051c4ace50.png_pic_left]

常用API：  
![在这里插入图片描述][960647a709894159ab2d22bdf5d57242.png_pic_left]

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

### 3.3 案例：一发一收 ###

**发送消息：**

> ① 创建 DatagramSocket 对象（发送端对象）  
> ② 创建 DatagramPacket 对象封装需要发送的数据（数据包对象）  
> ③ 使用 DatagramSocket 对象的 send 方法传入 DatagramPacket 对象  
> ④ 释放资源

public class ClientDemo1 {
        
        public static void main(String[] args) throws Exception {
        
            // 1. 创建发送端对象，发送端自带默认端口号 （人）
            DatagramSocket socket = new DatagramSocket();
            // 2. 创建一个数据包对象封装数据（韭菜）
            byte[] bytes = "甜晕了".getBytes();
            DatagramPacket packet = new DatagramPacket(bytes, bytes.length, InetAddress.getLocalHost(), 8888);
            // 接收端需指定端口号8888
            // 3. 发送数据出去
            socket.send(packet);
            // 4. 释放资源
            socket.close();
        }
    }

**接收消息：**

> ① 创建 DatagramSocket 对象并指定端口（接收端对象）  
> ② 创建 DatagramPacket 对象接收数据（数据包对象）  
> ③ 使用 DatagramSocket 对象的 receive 方法传入 DatagramPacket 对象  
> ④ 释放资源

public class ServerDemo2{
        
        public static void main(String[] args) throws Exception {
        
            // 1. 创建接收端对象：注册端口（人）
            DatagramSocket socket = new DatagramSocket(8888);
            // 2. 创建一个数据包对象接收数据（韭菜）
            byte[] buffer = new byte[1024 * 64];
            DatagramPacket packet = new DatagramPacket(buffer, buffer.length);
            // 3. 等待接收数据。
            socket.receive(packet);
            // 4. 取出数据即可
            int len = packet.getLength(); // 读取多少倒出多少
            String rs = new String(buffer, 0, len);
            System.out.println("收到了：" + rs);
            String ip = packet.getSocketAddress().toString(); // 获取发送端的 ip 和端口
            System.out.println("对方地址：" + ip);
            int port  = packet.getPort();
            System.out.println("对方端口：" + port);
            // 5. 释放资源
            socket.close();
        }
    }

**输出：**

![在这里插入图片描述][d5e6379175f1489786216b764dead72d.png]  
注：先运行服务端，在运行客户端。

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

### 3.4 案例：多发多收 ###

在上文案例的基础上添加 while 循环。

**客户端：**

public class ClientDemo1 {
        
        public static void main(String[] args) throws Exception {
        
            // 1、创建发送端对象：发送端自带默认的端口号（人）
            DatagramSocket socket = new DatagramSocket(7777);
            Scanner sc = new Scanner(System.in);
            while (true) {
        
                System.out.println("请说：");
                String msg = sc.nextLine();
                if("exit".equals(msg)){
        
                    System.out.println("离线成功！");
                    socket.close();
                    break;
                }
                // 2、创建一个数据包对象封装数据（韭菜盘子）
                byte[] buffer = msg.getBytes();
                DatagramPacket packet = new DatagramPacket( buffer, buffer.length,
                        InetAddress.getLocalHost() , 8888);
                // 3、发送数据出去
                socket.send(packet);
            }
        }
    }

**服务端：**

public class ServerDemo2 {
        
        public static void main(String[] args) throws Exception {
        
            System.out.println("=====服务端启动======");
            // 1、创建接收端对象：注册端口（人）
            DatagramSocket socket = new DatagramSocket(8888);
            // 2、创建一个数据包对象接收数据（韭菜）
            byte[] buffer = new byte[1024 * 64];
            DatagramPacket packet = new DatagramPacket(buffer, buffer.length);
            while (true) {
        
                // 3、等待接收数据。
                socket.receive(packet);
                // 4、取出数据即可
                // 读取多少倒出多少
                int len = packet.getLength();
                String rs = new String(buffer,0, len);
                System.out.println("收到了来自：" + packet.getAddress() +", 对方端口是" + packet.getPort() +"的消息：" + rs);
            }
        }
    }

注：接收端只负责接收数据包，无所谓是哪个发送端的数据包。

**输出：**

![在这里插入图片描述][2cf5c050e6e245af8d63343e447f4f5d.png]  
![在这里插入图片描述][acf0e3827fa8429bae5542c460cfa75e.png]

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

### 3.5 案例：同时接受多个客户端消息 ###

idea 默认一个程序开启一次，当重复运行同一个程序时，会有如下提示：  
![在这里插入图片描述][65706a15dc0d4f13a60bac876cbbc86f.png_pic_left]

因此，如果想实现客户端多开，需要修改配置，如下：

第一步：点击 Edit Configurations… 按钮。  
![在这里插入图片描述][eddc208dd07d42bda4073135eab8bef9.png_pic_left]  
第二步：点击 Modify options 修改参数。  
![在这里插入图片描述][8430d4033440412eb330a4dc033c9b99.png_pic_left]  
点击 Allow multiple instances 选项，即可实现客户端多开功能：  
![在这里插入图片描述][ff8052ca993a468bb46a9610f84e6a70.png_pic_left]  
其次，如果客户端指定端口号，会抛出端口号已经使用的异常。  
![在这里插入图片描述][e4e9c037583a44689a9bc15007e5b11d.png]  
![在这里插入图片描述][a23741a72d4d466abd5f751a94e31a03.png]

因此，需要不用写指定端口，使用其默认端口号，不会导致端口号冲突。

![在这里插入图片描述][d09a3454b52241c6af051d93a7553eae.png]

![在这里插入图片描述][ae077e06629944d1bacd358d75fb43b3.png]

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

## 四、TCP通信 ##

TCP 是一种面向连接，安全、可靠的传输数据的协议。 数据传输前，采用 “三次握手” 方式，点对点通信，是可靠的。 并且在连接中可进行大数据量的传输。

### 4.1 TCP通信模式模拟 ###

![在这里插入图片描述][efb3b4b383464150b884a9ffad156124.png_pic_left]  
注意：在 java 中只要是使用 java.net.Socket 类实现通信，其底层使用了 TCP 协议。

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

### 4.2 Socket（客户端） ###

构造器：  
![在这里插入图片描述][8f2c84d54c5349eab3474421469da8b5.png_pic_left]  
常用 API：  
![在这里插入图片描述][b2731a171ae342f1b4552cc1b63ce18d.png_pic_left]

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

### 4.3 ServerSocket（服务端） ###

构造器：  
![在这里插入图片描述][48b332bec3c74cfaa6d985aa2041c708.png_pic_left]  
常用 API：  
![在这里插入图片描述][f0b846b0dad040bfb6e8a17638bc5a1b.png_pic_left]

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

### 4.4 案例：一发一收 ###

**发送消息：**

> ① 创建客户端的 Socket 对象，请求与服务端的连接。  
> ② 使用 Socket 对象调用 getOutputStream() 方法得到字节输出流。  
> ③ 使用字节输出流完成数据的发送。  
> ④ 释放资源：关闭 Socket 管道。（程序结束，管道自动关闭）

public class ClientDemo1 {
        
        public static void main(String[] args) {
        
            try {
        
                System.out.println("====客户端启动===");
                // 1、创建Socket通信管道请求有服务端的连接
                // public Socket(String host, int port)
                // 参数一：服务端的IP地址
                // 参数二：服务端的端口
                Socket socket = new Socket("127.0.0.1", 7777);
    
                // 2、从socket通信管道中得到一个字节输出流 负责发送数据
                OutputStream os = socket.getOutputStream();
    
                // 3、把低级的字节流包装成数据输出流
                DataOutputStream dos = new DataOutputStream(os);
    
                // 4、发送消息
                dos.writeUTF("我是TCP的客户端，我已经与你对接，并发出邀请：约吗？");
                dos.close();
    
                // 关闭资源
                socket.close();
    
            } catch (Exception e) {
        
                e.printStackTrace();
            }
        }
    }

**接收消息：**

> ① 创建 ServerSocket 对象，注册服务端端口。  
> ② 调用 ServerSocket 对象的 accept() 方法，等待客户端的连接，并得到 Socket 管道对象。  
> ③ 通过 Socket 对象调用 getInputStream() 方法得到字节输入流、完成数据的接收。  
> ④ 释放资源：关闭 Socket 管道

public class ServerDemo2 {
        
        public static void main(String[] args) {
        
            try {
        
                System.out.println("===服务端启动成功===");
                // 1、注册端口
                ServerSocket serverSocket = new ServerSocket(7777);
                
                // 2、必须调用accept方法：等待接收客户端的Socket连接请求，建立Socket通信管道
                Socket socket = serverSocket.accept();
                
                // 3、从socket通信管道中得到一个字节输入流
                InputStream is = socket.getInputStream();
                
                // 4、把原始字节输入流包装成 数据输入流进行消息的接收
                DataInputStream dis = new DataInputStream(is);
                
                // 5、使用数据输入流读取客户端发送过来的消息
                String msg = dis.readUTF();
                System.out.println(msg);
    
                // 补充：获取客户端的地址
                System.out.println(socket.getRemoteSocketAddress());
    
                // 6、关闭流
                dis.close();
                socket.close();
            } catch (Exception e) {
        
                e.printStackTrace();
            }
        }
    }

输出：

![在这里插入图片描述][1e94fb9819b4486fb305294e798e85d2.png]

**TCP 通信原理：**

客户端怎么发，服务端就应该怎么收。  
客户端如果没有消息，服务端会进入阻塞等待。  
Socket 一方关闭或者出现异常、对方 Socket 也会失效或者出错。

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

### 4.5 案例：多发多收 ###

步骤：

> ① 客户端也可以使用死循环等待用户不断输入消息。  
> ② 可以使用死循环控制服务端收完消息继续等待接收下一个消息。  
> ③ 客户端一旦输入了 exit ，则关闭客户端程序，并释放资源。

客户端：

public class ClientDemo1 {
        
        public static void main(String[] args) {
        
            try {
        
                System.out.println("====客户端启动===");
                // 1、创建Socket通信管道请求有服务端的连接
                // public Socket(String host, int port)
                // 参数一：服务端的IP地址
                // 参数二：服务端的端口
                Socket socket = new Socket("127.0.0.1", 7777);
    
                // 2、从socket通信管道中得到一个字节输出流 负责发送数据
                OutputStream os = socket.getOutputStream();
    
                // 3、把低级的字节流包装成数据输出流
                DataOutputStream dos = new DataOutputStream(os);
    
                Scanner sc =  new Scanner(System.in);
                while (true) {
        
                    System.out.print("请说：");
                    String msg = sc.nextLine();
                    if("exit".equals(msg)){
        
                        System.out.println("离线成功");
                        // 关闭资源
                        dos.close();
                        socket.close();
                        break;
                    }
                    // 4、发送消息
                    dos.writeUTF(msg);
                    dos.flush();
                }
            } catch (Exception e) {
        
                e.printStackTrace();
            }
        }
    }

服务端：

public class ServerDemo2 {
        
        public static void main(String[] args) throws Exception {
               
            System.out.println("===服务端启动成功===");
            // 1、注册端口
            ServerSocket serverSocket = new ServerSocket(7777);
    
            // 2、必须调用accept方法：等待接收客户端的Socket连接请求，建立Socket通信管道
            Socket socket = serverSocket.accept();
    
            // 3、从socket通信管道中得到一个字节输入流
            InputStream is = socket.getInputStream();
    
            // 4、把字节输入流包装成缓冲字符输入流进行消息的接收
            DataInputStream dis = new DataInputStream(is);
    
            while(true){
        
                // 5、使用数据输入流读取客户端发送过来的消息
                String msg = dis.readUTF();
                System.out.println(socket.getRemoteSocketAddress()+ "说：" + msg);
            }
        }
    }

输出：  
![在这里插入图片描述][d353c73a86a445aeb2637d2cb1fa92e7.png]

![在这里插入图片描述][827c7d932bc34cba8a26f5689da5289a.png]

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

注意：若此时关闭客服端，服务端会报错！原因客户端与服务端建立的是同一个管道。  
![在这里插入图片描述][f81badee43904a71aa22b55e175f92c7.png_pic_left_500x]  
可以通过异常捕获来解决以上问题：

public class ServerDemo2 {
        
        public static void main(String[] args) throws Exception {
        
    
            System.out.println("===服务端启动成功===");
            // 1、注册端口
            ServerSocket serverSocket = new ServerSocket(7777);
    
            // 2、必须调用accept方法：等待接收客户端的Socket连接请求，建立Socket通信管道
            Socket socket = serverSocket.accept();
    
            // 3、从socket通信管道中得到一个字节输入流
            InputStream is = socket.getInputStream();
    
            // 4、把字节输入流包装成缓冲字符输入流进行消息的接收
            DataInputStream dis = new DataInputStream(is);
    
            while(true){
        
                try {
        
                    // 5、使用数据输入流读取客户端发送过来的消息
                    String msg = dis.readUTF();
                    System.out.println(socket.getRemoteSocketAddress()+ "说：" + msg);
                } catch (IOException e) {
        
                    System.out.println(socket.getRemoteSocketAddress() + "离线了！");
                    dis.close();
                    socket.close();
                    break;
                }
            }
        }
    }

![在这里插入图片描述][c2bf2340b5cd43a8a2a49f74dd6c00b9.png]

![在这里插入图片描述][08eb960656a24446815eeee21ca7db4e.png]

注意：服务端不可以同时接收多个客户端的消息，因为服务端现在只有一个线程，只能与一个客户端建立通信管道。

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

### 4.6 案例：同时接受多个客户端消息 ###

对于上文案例的问题，可以通过多线程的方式来解决。

![在这里插入图片描述][e654c73377794d7ab0c5e7507dc6fbdb.png_pic_left]

主线程定义了循环负责接收客户端 Socket 管道连接，每接收到一个Socket通信管道后分配一个独立的线程负责处理它。

public class ServerDemo2 {
        
        public static void main(String[] args) {
        
            try {
        
                System.out.println("===服务端启动成功===");
                // 1、注册端口
                ServerSocket serverSocket = new ServerSocket(7777);
                // a.定义一个死循环由主线程负责不断的接收客户端的Socket管道连接。
                while (true) {
        
                    // 2、每接收到一个客户端的Socket管道，交给一个独立的子线程负责读取消息
                    Socket socket = serverSocket.accept();
                    System.out.println(socket.getRemoteSocketAddress()+ " ta来了，上线了！");
                    // 3、开始创建独立线程处理socket
                    new ServerReaderThread(socket).start();
                }
            } catch (Exception e) {
        
                e.printStackTrace();
            }
        }
    }

输出：

![在这里插入图片描述][7307bba7f58b41e2a9289093de4f79dc.png]

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

## 五、TCP综合案例：群聊 ##

TCP 通信，需要实现 端口转发 的思想，即客户端是不能和客户端直接通信的，需要先发送到服务端，然后通过服务端，转发到客户端。

此外，还需要使用集合存储在线 socket，方便为哪些 socket 推送群聊信息。

**实现：**

public class Client {
        
        public static void main(String[] args) {
        
            try {
        
                System.out.println("====客户端启动===");
                // 1、创建Socket通信管道请求有服务端的连接
                // public Socket(String host, int port)
                // 参数一：服务端的IP地址
                // 参数二：服务端的端口
                Socket socket = new Socket("127.0.0.1", 7777);
    
                // F. 创建一个独立的线程，负责随机从 socket 中接收服务端发送过来的消息。
                new ClientReaderThread(socket).start();
    
                // 2、从socket通信管道中得到一个字节输出流 负责发送数据
                OutputStream os = socket.getOutputStream();
    
                // 3、把低级的字节流包装成数据输出流
                DataOutputStream dos = new DataOutputStream(os);
    
                Scanner sc =  new Scanner(System.in);
                while (true) {
        
                    System.out.println("请说：");
                    String msg = sc.nextLine();
                    if("exit".equals(msg)){
        
                        System.out.println("离线成功");
                        // 关闭资源
                        dos.close();
                        socket.close();
                        break;
                    }
                    // 4、发送消息
                    dos.writeUTF(msg);
                    dos.flush();
                }
            } catch (Exception e) {
        
                e.printStackTrace();
            }
        }
    }

// E. 创建 客户端线程 接收其他客户端的信息
    public class ClientReaderThread extends Thread{
        
    
        private Socket socket;
        public ClientReaderThread(Socket socket){
        
            this.socket = socket;
        }
    
        @Override
        public void run() {
        
            try {
        
                // 3、从socket通信管道中得到一个字节输入流
                InputStream is = socket.getInputStream();
    
                // 4、把字节输入流包装成缓冲字符输入流进行消息的接收
                DataInputStream dis = new DataInputStream(is);
    
                // 5、按照行读取消息
                while(true){
        
                    try {
        
                        // 5、使用数据输入流读取客户端发送过来的消息
                        String msg = dis.readUTF();
                        System.out.println(socket.getRemoteSocketAddress()+ " 说：" + msg);
                    } catch (IOException e) {
        
                        System.out.println("自己离线了！");
                        dis.close();
                        socket.close();
                        break;
                    }
                }
            } catch (Exception e) {
        
                e.printStackTrace();
            }
        }
    }

public class Server {
        
        // A. 在线 socket 集合
        public static List<Socket> onLineSockets = new ArrayList<>();
    
        public static void main(String[] args) {
        
            try {
        
                System.out.println("===服务端启动成功===");
                // 1、注册端口
                ServerSocket serverSocket = new ServerSocket(7777);
                // 定义一个死循环由主线程负责不断的接收客户端的Socket管道连接。
                while (true) {
        
                    // 2、每接收到一个客户端的Socket管道，交给一个独立的子线程负责读取消息
                    Socket socket = serverSocket.accept();
                    // B. 加入socket集合中
                    onLineSockets.add(socket);
    
                    System.out.println(socket.getRemoteSocketAddress()+ " ta来了，上线了！");
                    // 3、开始创建独立线程处理socket
                    new ServerReaderThread(socket).start();
                }
            } catch (Exception e) {
        
                e.printStackTrace();
            }
        }
    }

public class ServerReaderThread extends Thread{
        
        private Socket socket;
        public ServerReaderThread(Socket socket){
        
            this.socket = socket;
        }
        @Override
        public void run() {
        
            try {
        
                // 3、从socket通信管道中得到一个字节输入流
                InputStream is = socket.getInputStream();
    
                // 4、把字节输入流包装成缓冲字符输入流进行消息的接收
                DataInputStream dis = new DataInputStream(is);
    
                // 5、按照行读取消息
                while(true){
        
                    try {
        
                        // 5、使用数据输入流读取客户端发送过来的消息
                        String msg = dis.readUTF();
                        System.out.println(socket.getRemoteSocketAddress()+ " 说：" + msg);
    
                        // D. 把这个消息分发给全部客户端进行接收！
                        sendMsgToAll(msg);
                    } catch (IOException e) {
        
                        System.out.println(socket.getRemoteSocketAddress() + " 离线了！");
                        // C. 在线 socket 集合删除当前 socket
                        Server.onLineSockets.remove(socket);
                        dis.close();
                        socket.close();
                        break;
                    }
                }
            } catch (Exception e) {
        
                e.printStackTrace();
            }
        }
    
        /**
         * 发送全部所有的socket的管道接收
         */
        private void sendMsgToAll(String msg) throws IOException {
        
            for (Socket onLineSocket : Server.onLineSockets) {
        
                OutputStream os = onLineSocket.getOutputStream();
                DataOutputStream dos = new DataOutputStream(os);
                dos.writeUTF(msg);
                dos.flush();
            }
        }
    }

**输出：**

![在这里插入图片描述][3d9c10b330eb446ebd200fae8863da07.png]

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

文章参考：[Java入门基础视频教程，java零基础自学就选黑马程序员Java入门教程（含Java项目和Java真题）][Java_java_Java_Java_Java]

[f51dfb682fb04cf7854ec22e5572696c.png_pic_left]: https://img-blog.csdnimg.cn/f51dfb682fb04cf7854ec22e5572696c.png#pic_left
[574f4df0a1214576a0f8596ada23702f.png_pic_left]: https://img-blog.csdnimg.cn/574f4df0a1214576a0f8596ada23702f.png#pic_left
[1eab0e0a28e447df9f90c870ce57f6e7.png_pic_left]: https://img-blog.csdnimg.cn/1eab0e0a28e447df9f90c870ce57f6e7.png#pic_left
[e0aa543c083746b08601146f752cb838.png_pic_left]: https://img-blog.csdnimg.cn/e0aa543c083746b08601146f752cb838.png#pic_left
[9cc2e60187b641b18098b959fe3a9778.png_pic_left]: https://img-blog.csdnimg.cn/9cc2e60187b641b18098b959fe3a9778.png#pic_left
[427c2ab1f1f4458cb208ac214657aa5e.png_pic_left]: https://img-blog.csdnimg.cn/427c2ab1f1f4458cb208ac214657aa5e.png#pic_left
[138a525ed6354fffbf82dc7dc0ef7095.png_pic_left]: https://img-blog.csdnimg.cn/138a525ed6354fffbf82dc7dc0ef7095.png#pic_left
[99c107f43d864cdfbeb2d422a4b0d29b.png_pic_left]: https://img-blog.csdnimg.cn/99c107f43d864cdfbeb2d422a4b0d29b.png#pic_left
[78ccffcf57fc417080ac4ad56ccbc45f.png_pic_left]: https://img-blog.csdnimg.cn/78ccffcf57fc417080ac4ad56ccbc45f.png#pic_left
[f6bbae547980453fb308c03d6bc21a05.png_pic_left]: https://img-blog.csdnimg.cn/f6bbae547980453fb308c03d6bc21a05.png#pic_left
[ceb5eb34942f45189770cd051c4ace50.png_pic_left]: https://img-blog.csdnimg.cn/ceb5eb34942f45189770cd051c4ace50.png#pic_left
[960647a709894159ab2d22bdf5d57242.png_pic_left]: https://img-blog.csdnimg.cn/960647a709894159ab2d22bdf5d57242.png#pic_left
[d5e6379175f1489786216b764dead72d.png]: https://img-blog.csdnimg.cn/d5e6379175f1489786216b764dead72d.png
[2cf5c050e6e245af8d63343e447f4f5d.png]: https://img-blog.csdnimg.cn/2cf5c050e6e245af8d63343e447f4f5d.png
[acf0e3827fa8429bae5542c460cfa75e.png]: https://img-blog.csdnimg.cn/acf0e3827fa8429bae5542c460cfa75e.png
[65706a15dc0d4f13a60bac876cbbc86f.png_pic_left]: https://img-blog.csdnimg.cn/65706a15dc0d4f13a60bac876cbbc86f.png#pic_left
[eddc208dd07d42bda4073135eab8bef9.png_pic_left]: https://img-blog.csdnimg.cn/eddc208dd07d42bda4073135eab8bef9.png#pic_left
[8430d4033440412eb330a4dc033c9b99.png_pic_left]: https://img-blog.csdnimg.cn/8430d4033440412eb330a4dc033c9b99.png#pic_left
[ff8052ca993a468bb46a9610f84e6a70.png_pic_left]: https://img-blog.csdnimg.cn/ff8052ca993a468bb46a9610f84e6a70.png#pic_left
[e4e9c037583a44689a9bc15007e5b11d.png]: https://img-blog.csdnimg.cn/e4e9c037583a44689a9bc15007e5b11d.png
[a23741a72d4d466abd5f751a94e31a03.png]: https://img-blog.csdnimg.cn/a23741a72d4d466abd5f751a94e31a03.png
[d09a3454b52241c6af051d93a7553eae.png]: https://img-blog.csdnimg.cn/d09a3454b52241c6af051d93a7553eae.png
[ae077e06629944d1bacd358d75fb43b3.png]: https://img-blog.csdnimg.cn/ae077e06629944d1bacd358d75fb43b3.png
[efb3b4b383464150b884a9ffad156124.png_pic_left]: https://img-blog.csdnimg.cn/efb3b4b383464150b884a9ffad156124.png#pic_left
[8f2c84d54c5349eab3474421469da8b5.png_pic_left]: https://img-blog.csdnimg.cn/8f2c84d54c5349eab3474421469da8b5.png#pic_left
[b2731a171ae342f1b4552cc1b63ce18d.png_pic_left]: https://img-blog.csdnimg.cn/b2731a171ae342f1b4552cc1b63ce18d.png#pic_left
[48b332bec3c74cfaa6d985aa2041c708.png_pic_left]: https://img-blog.csdnimg.cn/48b332bec3c74cfaa6d985aa2041c708.png#pic_left
[f0b846b0dad040bfb6e8a17638bc5a1b.png_pic_left]: https://img-blog.csdnimg.cn/f0b846b0dad040bfb6e8a17638bc5a1b.png#pic_left
[1e94fb9819b4486fb305294e798e85d2.png]: https://img-blog.csdnimg.cn/1e94fb9819b4486fb305294e798e85d2.png
[d353c73a86a445aeb2637d2cb1fa92e7.png]: https://img-blog.csdnimg.cn/d353c73a86a445aeb2637d2cb1fa92e7.png
[827c7d932bc34cba8a26f5689da5289a.png]: https://img-blog.csdnimg.cn/827c7d932bc34cba8a26f5689da5289a.png
[f81badee43904a71aa22b55e175f92c7.png_pic_left_500x]: https://img-blog.csdnimg.cn/f81badee43904a71aa22b55e175f92c7.png#pic_left=500x
[c2bf2340b5cd43a8a2a49f74dd6c00b9.png]: https://img-blog.csdnimg.cn/c2bf2340b5cd43a8a2a49f74dd6c00b9.png
[08eb960656a24446815eeee21ca7db4e.png]: https://img-blog.csdnimg.cn/08eb960656a24446815eeee21ca7db4e.png
[e654c73377794d7ab0c5e7507dc6fbdb.png_pic_left]: https://img-blog.csdnimg.cn/e654c73377794d7ab0c5e7507dc6fbdb.png#pic_left
[7307bba7f58b41e2a9289093de4f79dc.png]: https://img-blog.csdnimg.cn/7307bba7f58b41e2a9289093de4f79dc.png
[3d9c10b330eb446ebd200fae8863da07.png]: https://img-blog.csdnimg.cn/3d9c10b330eb446ebd200fae8863da07.png
[Java_java_Java_Java_Java]: https://www.bilibili.com/video/BV1Cv411372m/?spm_id_from=333.976.top_right_bar_window_custom_collection.content.click&vd_source=66e56f67ae318dd01461810c59a6e2b5