Java基础：网络编程

短命女 2024-03-30 10:13 84阅读 0赞

## **第一章 网络编程** ##

### 1.1 软件结构 ###

*  **`C/S`结构** ：全称为`Client/Server`结构，是指客户端和服务器结构。常见程序有`ＱＱ`、迅雷等软件。
 *  **`B/S`结构** ：全称为`Browser/Server`结构，是指浏览器和服务器结构。常见浏览器有谷歌、火狐等。

两种架构各有优势，但是无论哪种架构，都离不开网络的支持。**网络编程**，就是在一定的协议下，实现两台计算机的通信的程序。

### 1.2 网络通信协议 ###

*  **网络通信协议：** 通信协议是对计算机必须遵守的规则，只有遵守这些规则，计算机之间才能进行通信。这就好比在道路中行驶的汽车一定要遵守交通规则一样，协议中对数据的传输格式、传输速率、传输步骤等做了统一规定，通信双方必须同时遵守，最终完成数据交换。
 *  **`TCP/IP`协议：** 传输控制协议/因特网互联协议（`Transmission Control Protocol/Internet Protocol`），是`Internet`最基本、最广泛的协议。它定义了计算机如何连入因特网，以及数据如何在它们之间传输的标准。它的内部包含一系列的用于处理数据通信的协议，并采用了4层的分层模型，每一层都呼叫它的下一层所提供的协议来完成自己的需求。![在这里插入图片描述][81cef589075f41a498315a41690a9683.png_pic_center]

### 1.3 协议分类 ###

通信的协议还是比较复杂的，`java.net`包中包含的类和接口，它们提供低层次的通信细节。我们可以直接使用这些类和接口，来专注于网络程序开发，而不用考虑通信的细节。

`java.net`包中提供了两种常见的网络协议的支持：

*  **`TCP`**：传输控制协议（`Transmission Control Protocol`）。`TCP`协议是**面向连接**的通信协议，即传输数据之前，在发送端和接收端建立逻辑连接，然后再传输数据，它提供了两台计算机之间可靠无差错的数据传输。
    
     *  三次握手：`TCP`协议中，在发送数据的准备阶段，客户端与服务器之间的三次交互，以保证连接的可靠。
        
         *  第一次握手，客户端向服务器端发出连接请求，等待服务器确认。
         *  第二次握手，服务器端向客户端回送一个响应，通知客户端收到了连接请求。
         *  第三次握手，客户端再次向服务器端发送确认信息，确认连接。整个交互过程如下图所示。![在这里插入图片描述][8724136faa514d9cbb2f861d42fa2a80.png_pic_center]

完成三次握手，连接建立后，客户端和服务器就可以开始进行数据传输了。由于这种面向连接的特性，`TCP`协议可以保证传输数据的安全，所以应用十分广泛，例如下载文件、浏览网页等。

*  **`UDP`**：用户数据报协议（`User Datagram Protocol`）。`UDP`协议是一个**面向无连接**的协议。传输数据时，不需要建立连接，不管对方端服务是否启动，直接将数据、数据源和目的地都封装在数据包中，直接发送。每个数据包的大小限制在`64k`以内。它是不可靠协议，因为无连接，所以传输速度快，但是容易丢失数据。日常应用中，例如视频会议、`QQ`聊天等。

### 1.4 网络编程三要素 ###

#### **协议** ####

*  **协议：** 计算机网络通信必须遵守的规则，已经介绍过了，不再赘述。

#### `IP`地址 ####

*  **`IP`地址**：指互联网协议地址（`Internet Protocol Address`），俗称`IP`。`IP`地址用来给一个网络中的计算机设备做唯一的编号。假如我们把“个人电脑”比作“一台电话”的话，那么“`IP`地址”就相当于“电话号码”。

##### `IP`地址分类 #####

*  `IPv4`：是一个32位的二进制数，通常被分为4个字节，表示成`a.b.c.d`的形式，例如`192.168.65.100`。其中`a`、`b`、`c`、`d`都是0~255之间的十进制整数，那么最多可以表示42亿个。
 *  `IPv6`：由于互联网的蓬勃发展，`IP`地址的需求量愈来愈大，但是网络地址资源有限，使得`IP`的分配越发紧张。有资料显示，全球`IPv4`地址在2011年2月分配完毕。为了扩大地址空间，拟通过`IPv6`重新定义地址空间，采用128位地址长度，每16个字节一组，分成8组十六进制数，表示成 `ABCD:EF01:2345:6789:ABCD:EF01:2345:6789` ，号称可以为全世界的每一粒沙子编上一个网址，这样就解决了网络地址资源数量不够的问题。

#### 常用命令 ####

查看本机`IP`地址，在控制台输入：

ipconfig

检查网络是否连通，在控制台输入：

ping 空格 IP地址
    ping 220.181.57.216

**特殊的`IP`地址**

*  本机`IP`地址：`127.0.0.1`、`localhost`。

#### 端口号 ####

网络的通信，本质上是两个进程（应用程序）的通信。每台计算机都有很多的进程，那么在网络通信时，如何区分这些进程呢？

如果说**IP地址**可以唯一标识网络中的设备，那么**端口号**就可以唯一标识设备中的进程（应用程序）了。

*  **端口号：用两个字节表示的整数，它的取值范围是`0~65535`**。其中，0~1023之间的端口号用于一些知名的网络服务和应用，普通的应用程序需要使用1024以上的端口号。如果端口号被另外一个服务或应用所占用，会导致当前程序启动失败。

利用`协议`\+`IP地址`\+`端口号`三元组合，就可以标识网络中的进程了，那么进程间的通信就可以利用这个标识与其它进程进行交互。

## 第二章 `TCP`通信程序 ##

### 2.1 概述 ###

`TCP`通信能实现两台计算机之间的数据交互，通信的两端，要严格区分为客户端（`Client`）与服务端（`Server`）。

**两端通信时步骤：**

1.  服务端程序，需要事先启动，等待客户端的连接。
2.  客户端主动连接服务器端，连接成功才能通信。服务端不可以主动连接客户端。

**在`Java`中，提供了两个类用于实现`TCP`通信程序：**

1.  客户端：`java.net.Socket`类表示。创建`Socket`对象，向服务端发出连接请求，服务端响应请求，两者建立连接开始通信。
2.  服务端：`java.net.ServerSocket`类表示。创建`ServerSocket`对象，相当于开启一个服务，并等待客户端的连接。

### 2.2 `Socket`类 ###

`Socket`类：该类实现客户端套接字，套接字指的是两台设备之间通讯的端点。

#### 构造方法 ####

`public Socket(String host, int port)`：创建套接字对象并将其连接到指定主机上的指定端口号。如果指

定的`host`是`null`，则相当于指定地址为回送地址。

> 小贴士：回送地址（`127.x.x.x`）是本机回送地址（`Loopback Address`），主要用于网络软件测试以及本地机进程间通信，无论什么程序，一旦使用回送地址发送数据，立即返回，不进行任何网络传输。

构造举例，代码如下：

Socket client = new Socket("127.0.0.1", 6666);

#### 成员方法 ####

*  `public InputStream getInputStream()`：返回此套接字的输入流。
    
     *  如果此`Scoket`具有相关联的通道，则生成的`InputStream`的所有操作也关联该通道。
     *  关闭生成的`InputStream`也将关闭相关的`Socket`。
 *  `public OutputStream getOutputStream()`：返回此套接字的输出流。
    
     *  如果此`Scoket`具有相关联的通道，则生成的`OutputStream`的所有操作也关联该通道。
     *  关闭生成的`OutputStream`也将关闭相关的`Socket`。
 *  `public void close()`：关闭此套接字。
    
     *  一旦一个`socket`被关闭，它不可再使用。
     *  关闭此`socket`也将关闭相关的`InputStream`和`OutputStream`。
 *  `public void shutdownOutput()`：禁用此套接字的输出流。
    
     *  任何先前写出的数据将被发送，随后终止输出流。

### 2.3 `ServerSocket`类 ###

`ServerSocket`类：这个类实现了服务器套接字，该对象等待通过网络的请求。

#### 构造方法 ####

*  `public ServerSocket(int port)`：使用该构造方法在创建`ServerSocket`对象时，就可以将其绑定到一个指定的端口号上，参数`port`就是端口号。

构造举例，代码如下：

ServerSocket server = new ServerSocket(6666);

#### 成员方法 ####

*  `public Socket accept()`：侦听并接受连接，返回一个新的`Socket`对象，用于和客户端实现通信。该方法会一直阻塞直到建立连接。

### 2.4 简单的`TCP`网络程序 ###

#### `TCP`通信分析图解 ####

1.  【服务端】启动，创建`ServerSocket`对象，等待连接。
2.  【客户端】启动，创建`Socket`对象，请求连接。
3.  【服务端】接收连接，调用`accept`方法，并返回一个`Socket`对象。
4.  【客户端】`Socket`对象，获取`OutputStream`，向服务端写出数据。
5.  【服务端】`Scoket`对象，获取`InputStream`，读取客户端发送的数据。

到此，客户端向服务端发送数据成功。

![在这里插入图片描述][3cfc32bc32144e77b925c45a0f861b50.png_pic_center]

自此，服务端向客户端回写数据。

1.  【服务端】`Socket`对象，获取`OutputStream`，向客户端回写数据。
2.  【客户端】`Scoket`对象，获取`InputStream`，解析回写数据。
3.  【客户端】释放资源，断开连接。

#### 客户端向服务器发送数据 ####

##### 服务端实现： #####

package com.dcxuexi.java27;
    
    import java.io.IOException;
    import java.io.InputStream;
    import java.net.ServerSocket;
    import java.net.Socket;
    
    /***
     * @Title ServerTCP
     * @Description TOTD
     * @Auter DongChuang
     * @Date 2022/12/17 17:07
     * @Version 1.0.0
     */
    public class ServerTCP {
        
        public static void main(String[] args) throws IOException {
        
            System.out.println("服务端启动 , 等待连接 .... ");
            // 1.创建 ServerSocket对象，绑定端口，开始等待连接
            ServerSocket ss = new ServerSocket(6666);
            // 2.接收连接 accept 方法, 返回 socket 对象.
            Socket server = ss.accept();
            // 3.通过socket 获取输入流
            InputStream is = server.getInputStream();
            // 4.一次性读取数据
            // 4.1 创建字节数组
            byte[] b = new byte[1024];
            // 4.2 据读取到字节数组中.
            int len = is.read(b);
            // 4.3 解析数组,打印字符串信息
            String msg = new String(b, 0, len);
            System.out.println("msg = " + msg);
            //5.关闭资源.
            is.close();
            server.close();
        }
    }

![在这里插入图片描述][5e3c1bd97051453daf618aaa885103ba.png_pic_center]

##### 客户端实现： #####

package com.dcxuexi.java27;
    
    import java.io.IOException;
    import java.io.OutputStream;
    import java.net.Socket;
    
    /***
     * @Title ClientTCP
     * @Description TOTD
     * @Auter DongChuang
     * @Date 2022/12/17 17:16
     * @Version 1.0.0
     */
    public class ClientTCP {
        
        public static void main(String[] args) throws IOException {
        
            System.out.println("客户端 发送数据");
            // 1.创建 Socket ( ip , port ) , 确定连接到哪里.
            Socket client = new Socket("localhost", 6666);
            // 2.获取流对象 . 输出流
            OutputStream os = client.getOutputStream();
            // 3.写出数据.
            os.write("你好么? tcp ,我来了".getBytes());
            // 4. 关闭资源 .
            os.close();
            client.close();
        }
    }

![在这里插入图片描述][6f2a7eff0e404005a0ade3c0da267278.png_pic_center]

#### 服务器向客户端回写数据 ####

##### 服务端实现： #####

package com.dcxuexi.java27;
    
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.OutputStream;
    import java.net.ServerSocket;
    import java.net.Socket;
    
    /***
     * @Title ServerTCP
     * @Description TOTD
     * @Auter DongChuang
     * @Date 2022/12/17 17:07
     * @Version 1.0.0
     */
    public class ServerTCP {
        
        public static void main(String[] args) throws IOException {
        
            System.out.println("服务端启动 , 等待连接 .... ");
            // 1.创建 ServerSocket对象，绑定端口，开始等待连接
            ServerSocket ss = new ServerSocket(6666);
            // 2.接收连接 accept 方法, 返回 socket 对象.
            Socket server = ss.accept();
            // 3.通过socket 获取输入流
            InputStream is = server.getInputStream();
            // 4.一次性读取数据
            // 4.1 创建字节数组
            byte[] b = new byte[1024];
            // 4.2 据读取到字节数组中.
            int len = is.read(b);
            // 4.3 解析数组,打印字符串信息
            String msg = new String(b, 0, len);
            System.out.println("msg = " + msg);
    
            // =================回写数据=======================
            // 5. 通过 socket 获取输出流
            OutputStream out = server.getOutputStream();
            // 6. 回写数据
            out.write("我很好,谢谢你".getBytes());
            //7.关闭资源.
            out.close();
            is.close();
            server.close();
        }
    }

![在这里插入图片描述][fe08b181368d4a54b2a3f3c234b552ae.png_pic_center]

##### 客户端实现： #####

package com.dcxuexi.java27;
    
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.OutputStream;
    import java.net.Socket;
    
    /***
     * @Title ClientTCP
     * @Description TOTD
     * @Auter DongChuang
     * @Date 2022/12/17 17:16
     * @Version 1.0.0
     */
    public class ClientTCP {
        
        public static void main(String[] args) throws IOException {
        
            System.out.println("客户端 发送数据");
            // 1.创建 Socket ( ip , port ) , 确定连接到哪里.
            Socket client = new Socket("localhost", 6666);
            // 2.获取流对象 . 输出流
            OutputStream os = client.getOutputStream();
            // 3.写出数据.
            os.write("你好么? tcp ,我来了".getBytes());
            // ==============解析回写=========================
            // 4. 通过Scoket,获取 输入流对象
            InputStream in = client.getInputStream();
            // 5. 读取数据数据
            byte[] b = new byte[1024];
            int len = in.read(b);
            System.out.println(new String(b, 0, len));
            // 4. 关闭资源 .
            os.close();
            client.close();
        }
    }

![在这里插入图片描述][0167cdd2633f40a590d1fc6ac837fa87.png_pic_center]

## 第三章 综合案例 ##

### 3.1 文件上传案例 ###

#### 文件上传分析图解 ####

1.  【客户端】输入流，从硬盘读取文件数据到程序中。
2.  【客户端】输出流，写出文件数据到服务端。
3.  【服务端】输入流，读取文件数据到服务端程序。
4.  【服务端】输出流，写出文件数据到服务器硬盘中。

![在这里插入图片描述][c39715e9c76847e7ab8f0e536bd41882.png_pic_center]

##### 基本实现 #####

**服务端实现：**

![在这里插入图片描述][167699cc355242019112d7ebe0e1ead6.png_pic_center]

**客户端实现：**

package com.dcxuexi.java27;
    
    import java.io.*;
    import java.net.Socket;
    
    /***
     * @Title FileUPload_Client
     * @Description TOTD
     * @Auter DongChuang
     * @Date 2022/12/17 17:47
     * @Version 1.0.0
     */
    public class FileUPload_Client {
        
        public static void main(String[] args) throws IOException {
        
            // 1.创建流对象
            // 1.1 创建输入流,读取本地文件
            BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:\\java\\javaCode\\fileUpload\\Client\\Java.png"));
            // 1.2 创建输出流,写到服务端
            Socket socket = new Socket("localhost", 6666);
            BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());
            //2.写出数据.
            byte[] b = new byte[1024 * 8 ];
            int len ;
            while (( len = bis.read(b))!= -1){
        
                bos.write(b,0,len);
            }
            System.out.println("文件发送完毕");
            // 3.释放资源
            bos.close();
            socket.close();
            bis.close();
            System.out.println("文件上传完毕 ");
        }
    }

![在这里插入图片描述][fe0d92b7a7a4439689c717201ed8ae87.png_pic_center]

#### **文件上传优化分析** ####

##### **文件名称写死的问题** #####

服务端，保存文件的名称如果写死，那么最终导致服务器硬盘，只会保留一个文件，建议使用系统时间优化，保证文件名称唯一，代码如下：

FileOutputStream fis = new FileOutputStream(System.currentTimeMillis()+".jpg") // 文件名称
    BufferedOutputStream bos = new BufferedOutputStream(fis);

##### **循环接收的问题** #####

服务端，指保存一个文件就关闭了，之后的用户无法再上传，这是不符合实际的，使用循环改进，可以不断的接收不同用户的文件，代码如下：

// 每次接收新的连接,创建一个Socket
    while (true) {
        
    	Socket accept = serverSocket.accept();
    	......
    }

##### **效率问题** #####

服务端，在接收大文件时，可能耗费几秒钟的时间，此时不能接收其他用户上传，所以，使用多线程技术优化，代码如下：

while (true) {
        
    	Socket accept = serverSocket.accept();
    	// accept 交给子线程处理.
    	new Thread(() -> {
        
    		......
    		InputStream bis = accept.getInputStream();
    		......
    	}).start();
    }

##### **优化实现** #####

**服务端实现：**

package com.dcxuexi.java27;
    
    import java.io.BufferedInputStream;
    import java.io.BufferedOutputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.net.ServerSocket;
    import java.net.Socket;
    
    /***
     * @Title FileUpload_Server
     * @Description TOTD
     * @Auter DongChuang
     * @Date 2022/12/17 17:42
     * @Version 1.0.0
     */
    public class FileUpload_Server {
        
        public static void main(String[] args) throws IOException {
        
            System.out.println("服务器 启动..... ");
            // 1. 创建服务端ServerSocket
            ServerSocket serverSocket = new ServerSocket(6666);
            // 2. 循环接收,建立连接
            while (true){
        
                Socket accept = serverSocket.accept();
                //3. socket对象交给子线程处理,进行读写操作 Runnable接口中,只有一个run方法,使用lambda表达式简化格式
                new Thread(() ->{
        
                    try {
        
                        //3.1 获取输入流对象
                        BufferedInputStream bis = new BufferedInputStream(accept.getInputStream());
                        //3.2 创建输出流对象, 保存到本地
                        FileOutputStream fis = new FileOutputStream("D:\\java\\javaCode\\fileUpload\\Server\\" + System.currentTimeMillis() + ".jpg");
                        BufferedOutputStream bos = new BufferedOutputStream(fis);
                        // 3.3 读写数据
                        byte[] b = new byte[1024 * 8];
                        int len;
                        while ((len = bis.read(b)) != -1){
        
                            bos.write(b,0,len);
                        }
                        //4. 关闭 资源
                        bos.close();
                        fis.close();
                        accept.close();
                        System.out.println("文件上传已保存");
                    } catch (IOException e) {
        
                        e.printStackTrace();
                    }
                }).start();
            }
        }
    }

![在这里插入图片描述][eaab0d2d806f409cb9ce3257f2c11445.png_pic_center]

#### **信息回写分析图解** ####

前四步与基本文件上传一致。

1.  【服务端】获取输出流，回写数据。
2.  【客户端】获取输入流，解析回写数据。

![在这里插入图片描述][cadd9145c73b4df2a10a70f37fabb74a.png_pic_center]

##### **回写实现** #####

**服务端实现：**

package com.dcxuexi.java27;
    
    import java.io.*;
    import java.net.ServerSocket;
    import java.net.Socket;
    
    /***
     * @Title FileUpload_Server
     * @Description TOTD
     * @Auter DongChuang
     * @Date 2022/12/17 17:42
     * @Version 1.0.0
     */
    public class FileUpload_Server {
        
        public static void main(String[] args) throws IOException {
        
            System.out.println("服务器 启动..... ");
            // 1. 创建服务端ServerSocket
            ServerSocket serverSocket = new ServerSocket(6666);
            // 2. 循环接收,建立连接
            while (true){
        
                Socket accept = serverSocket.accept();
                //3. socket对象交给子线程处理,进行读写操作 Runnable接口中,只有一个run方法,使用lambda表达式简化格式
                new Thread(() ->{
        
                    try {
        
                        //3.1 获取输入流对象
                        BufferedInputStream bis = new BufferedInputStream(accept.getInputStream());
                        //3.2 创建输出流对象, 保存到本地
                        FileOutputStream fis = new FileOutputStream("D:\\java\\javaCode\\fileUpload\\Server\\" + System.currentTimeMillis() + ".jpg");
                        BufferedOutputStream bos = new BufferedOutputStream(fis);
                        // 3.3 读写数据
                        byte[] b = new byte[1024 * 8];
                        int len;
                        while ((len = bis.read(b)) != -1){
        
                            bos.write(b,0,len);
                        }
                        // 4.=======信息回写===========================
                        System.out.println("back ........");
                        OutputStream out = accept.getOutputStream();
                        out.write("上传成功".getBytes());
                        out.close();
                        //================================
                        //5. 关闭 资源
                        bos.close();
                        fis.close();
                        accept.close();
                        System.out.println("文件上传已保存");
                    } catch (IOException e) {
        
                        e.printStackTrace();
                    }
                }).start();
            }
        }
    }

![在这里插入图片描述][569b0a57d0be4319ba802e6372c36202.png_pic_center]

**客户端实现：**

package com.dcxuexi.java27;
    
    import java.io.*;
    import java.net.Socket;
    
    /***
     * @Title FileUPload_Client
     * @Description TOTD
     * @Auter DongChuang
     * @Date 2022/12/17 17:47
     * @Version 1.0.0
     */
    public class FileUPload_Client {
        
        public static void main(String[] args) throws IOException {
        
            // 1.创建流对象
            // 1.1 创建输入流,读取本地文件
            BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:\\java\\javaCode\\fileUpload\\Client\\Java.png"));
            // 1.2 创建输出流,写到服务端
            Socket socket = new Socket("localhost", 6666);
            BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());
            //2.写出数据.
            byte[] b = new byte[1024 * 8];
            int len ;
            while (( len = bis.read(b))!= -1){
        
                bos.write(b,0,len);
            }
            // 关闭输出流,通知服务端,写出数据完毕
            socket.shutdownOutput();
            System.out.println("文件发送完毕");
            // 3. =====解析回写============
            InputStream in = socket.getInputStream();
            byte[] back = new byte[20];
            in.read(back);
            System.out.println(new String(back));
            in.close();
            // ============================
            // 4.释放资源
            //bos.close();
            socket.close();
            bis.close();
            System.out.println("文件上传完毕 ");
        }
    }

![在这里插入图片描述][7fea925156e94278a6f8a0b5aae535e6.png_pic_center]

[81cef589075f41a498315a41690a9683.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/478ed74abbe14635b8a8fea17dd8e69b.png
[8724136faa514d9cbb2f861d42fa2a80.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/65ae028c8d604c87809b33943e1615a1.png
[3cfc32bc32144e77b925c45a0f861b50.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/832c75af43524bc6b197150df3be3926.png
[5e3c1bd97051453daf618aaa885103ba.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/f99bde97e83b412c9b5097fba978a95c.png
[6f2a7eff0e404005a0ade3c0da267278.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/670a6a8f2ac245e0a368d81bcfa24b13.png
[fe08b181368d4a54b2a3f3c234b552ae.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/bd6af5f933384730975c8f8e463f598d.png
[0167cdd2633f40a590d1fc6ac837fa87.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/b227249473554db288d204611aab4f3d.png
[c39715e9c76847e7ab8f0e536bd41882.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/63c01598126f40c39a28c3a62c8e4974.png
[167699cc355242019112d7ebe0e1ead6.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/c97397050d614828bb7d0a2e9c6ba1ce.png
[fe0d92b7a7a4439689c717201ed8ae87.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/ac0c04695b50434a9334ffe43e90fb6f.png
[eaab0d2d806f409cb9ce3257f2c11445.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/16b7c99718934cfdb6b5fa88609c08b1.png
[cadd9145c73b4df2a10a70f37fabb74a.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/c9b142783bb44d1489e3cbfc446c7688.png
[569b0a57d0be4319ba802e6372c36202.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/36a76854d7cf4962b94faffe44d6db7b.png
[7fea925156e94278a6f8a0b5aae535e6.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/20295a722b5a47ac90bbbb67d568011f.png