【JAVA】UDP与TCP套接字编程

一、UDP数据报套接字编程

[1、DatagramSocket API](#1、DatagramSocket API)

[2、DatagramPacket API](#2、DatagramPacket API)

[3、InetSocketAddress API](#3、InetSocketAddress API)

4、示例一

5、示例二

二、TCP流套接字编程

[1、ServerSocket API](#1、ServerSocket API)

[2、Socket API](#2、Socket API)

3、TCP中的长短连接

4、示例一

5、示例二

一、UDP数据报套接字编程

1、DatagramSocket API

DatagramSocket是UDP Socket，用于发送和接收UDP数据报。

DatagramSocket的构造方法有：

|--------------------------|---------------------------------------------|
| 方法签名 | 方法说明 |
| DatagramSocket() | 创建一个UDP数据报套接字的Socket，绑定到本机任意一个随机端口（一般用于客户端） |
| DatagramSocket(int port) | 创建一个UDP数据报套接字的Socket，绑定到本机指定的端口（一般用于服务端） |

DatagramSocket的方法有：

|--------------------------------|---------------------------------|
| 方法签名 | 方法说明 |
| void receive(DatagramPacket p) | 从此套接字接收数据报（如果没有接收到数据报，该方法会阻塞等待） |
| void send(DatagramPacket p) | 从此套接字发送数据报（不会阻塞等待，直接发送） |
| void close() | 关闭此数据报套接字 |

2、DatagramPacket API

DatagramPacket是UDP Socket发送和接收的数据报。

DatagramPacket的构造方法有：

|-----------------------------------------------------------------|--------------------------------------------------------------------------------------------|
| 方法签名 | 方法说明 |
| DatagramPacket(byte[] buf, int length) | 构造一个DatagramPacket以用来接收数据报，接收的数据保存在字节数组（第一个参数buf）中，接收指定长度（第二个参数length） |
| DatagramPacket(byte[] buf, int length, SocketAddress address) | 构造一个DatagramPacket以用来发送数据报，发送的数据为字节数组（第一个参数buf）中，从0到指定长度（第二个参数length）。address指定目的主机的IP和端口号 |

DatagramPacket的方法有：

|--------------------------|--------------------------------------------|
| 方法签名 | 方法说明 |
| InetAddress getAddress() | 从接收的数据报中，获取发送端主机IP地址；或从发送的数据报中，获取接收端主机IP地址 |
| int getPort() | 从接收的数据报中，获取发送端主机的端口号；或从发送的数据报中，获取接收端主机端口号 |
| byte[] getData() | 获取数据报中的数据 |

构造UDP发送的数据报时，需要传入SocketAddress，该对象可以使用InetSocketAddress来创建。

3、InetSocketAddress API

InetSocketAddress（SocketAddress的子类）构造方法有：

|-----------------------------------------------|-------------------------|
| 方法签名 | 方法说明 |
| InetSocketAddress(InetAddress addr, int port) | 创建一个Socket地址，包含IP地址和端口号 |

4、示例一

通过客户端向服务端发送数据，服务端接收数据之后将数据处理一下然后返回客户端。

UDP客户端

java 复制代码

import java.io.IOException;
import java.net.*;
import java.util.Scanner;

public class UdpEchoClient {
    private DatagramSocket socket = null;
    private String serverIp = "";
    private int serverport = 0;

    public UdpEchoClient(String ip,int port) throws SocketException {
        // 创建这个对象, 不能手动指定端口.
        socket = new DatagramSocket();
        // 由于 UDP 自身不会持有对端的信息. 就需要在应用程序里, 把对端的情况给记录下来.
        // 这里咱们主要记录对端的 ip 和 端口 .
        serverIp = ip;
        serverport = port;
    }

    public void start() throws IOException {
        System.out.println("客户端启动！");
        Scanner scanner = new Scanner(System.in);
        while(true){
            // 1. 从控制台读取数据, 作为请求
            System.out.print("->");
            String request = scanner.next();
            // 2. 把请求内容构造成 DatagramPacket 对象, 发给服务器.
            DatagramPacket packet = new DatagramPacket(request.getBytes(),request.getBytes().length, InetAddress.getByName(serverIp),serverport);
            socket.send(packet);
            // 3. 尝试读取服务器返回的响应了.
            DatagramPacket responsePacket = new DatagramPacket(new byte[4096],4096);
            socket.receive(responsePacket);
            // 4. 把响应, 转换成字符串, 并显示出来.
            String response = new String(responsePacket.getData(),0,responsePacket.getLength());
            System.out.println(response);
        }
    }

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

UDP服务端

java 复制代码

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.Socket;
import java.net.SocketException;

public class UdpEchoServer {
    // 创建一个 DatagramSocket 对象. 后续操作网卡的基础.
    private DatagramSocket socket = null;

    public UdpEchoServer(int port) throws SocketException {
        // 这么写就是手动指定端口
        socket = new DatagramSocket(port);
        // 这么写就是让系统自动分配端口
        // socket = new DatagramSocket();
    }

    public void start() throws IOException {// 通过这个方法来启动服务器.
        System.out.println("服务器启动!");
        while(true){
            // 1. 读取请求并解析.
            DatagramPacket requestPacket = new DatagramPacket(new byte[4096], 4096);
            socket.receive(requestPacket);
            // 当前完成 receive 之后, 数据是以 二进制 的形式存储到 DatagramPacket 中了.
            // 要想能够把这里的数据给显示出来, 还需要把这个二进制数据给转成字符串.
            String request = new String(requestPacket.getData(), 0, requestPacket.getLength());
            // 2. 根据请求计算响应(一般的服务器都会经历的过程)
            //    由于此处是回显服务器, 请求是啥样, 响应就是啥样.
            String response = process(request);
            // 3. 把响应写回到客户端.
            //    搞一个响应对象, DatagramPacket
            //    往 DatagramPacket 里构造刚才的数据, 再通过 send 返回.
            DatagramPacket responsePacket = new DatagramPacket(response.getBytes(), response.getBytes().length, requestPacket.getSocketAddress());
            socket.send(responsePacket);
            // 4. 打印一个日志, 把这次数据交互的详情打印出来.
            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 {
        UdpEchoServer server = new UdpEchoServer(9090);
        server.start();
    }
}

我们对上面的服务端进行封装一下，做一个非常简单的翻译器出来：

java 复制代码

import java.io.IOException;
import java.net.SocketException;
import java.util.HashMap;
import java.util.Map;

public class UdpDictServer extends UdpEchoServer{
    private Map<String,String> dict = new HashMap<>();

    public UdpDictServer(int port) throws SocketException {
        super(port);

        dict.put("dog", "小狗");
        dict.put("cat", "小猫");
        dict.put("pig", "小猪");
    }

    // 重写 process 方法, 在重写的方法中完成翻译的过程.
    // 翻译本质上就是 "查表"
    @Override
    public String process(String request){
        return dict.getOrDefault(request, "该词在词典中不存在!");
    }

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

5、示例二

构造一个展示服务端本地某个目录（BASE_PATH）的下一级子文件列表的服务：

客户端先接收键盘输入，表示要展示的相对路径（相对BASE_PATH的路径）

发送请求：将该相对路径作为数据报发送到服务端

服务端接收并处理请求：根据该请求数据，作为本地目录的路径，列出下一级子文件及子文件夹

服务端返回响应：遍历子文件和子文件夹，每个文件名一行，作为响应的数据报，返回给客户端

客户端接收响应：简单的打印输出所有的响应内容，即文件列表。

为了解决空字符或长度不足数据丢失的问题，客户端服务端约定好统一的协议：这里简单的设计为ASCII结束字符\3表示报文结束。以下为整个客户端服务端的交互执行流程：

以下为客户端与服务端的代码：

UDP服务端

java 复制代码

import java.io.File;
import java.io.IOException;
import java.lang.reflect.Array;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.nio.charset.StandardCharsets;
import java.util.Arrays;

public class UdpServer {
    private static final int PORT=8888;
    private static final String BASE_PATH = "E:/TMP";

    public static void main(String[] args) throws IOException{
        DatagramSocket  socket = new DatagramSocket(PORT);

        while(true){
            byte[] requestData = new byte[1024];
            DatagramPacket requestPacket = new DatagramPacket(requestData,requestData.length);

            System.out.println("------------------------------------------");
            System.out.println("等待接收UDP数据报...");
            socket.receive(requestPacket);

            System.out.printf("客户端IP：%s%n",requestPacket.getAddress().getHostAddress());
            System.out.printf("客户端端口号：%s%n", requestPacket.getPort());

            for(int i = 0;i< requestData.length;i++){
                byte b = requestData[i];
                if(b == '\3'){
                    String request = new String(requestData,0,i);

                    System.out.printf("客户端请求的文件列表路径为：%s%n", BASE_PATH + request);
                    File dir = new File(BASE_PATH + request);
                    File[] children = dir.listFiles();

                    StringBuilder response = new StringBuilder();

                    if(children != null){
                        for(File child : children){
                            response.append(child.getName()+'\n');
                        }
                    }

                    response.append("\3");
                    byte[] responseData = response.toString().getBytes(StandardCharsets.UTF_8);
                    System.out.println(response);
                    DatagramPacket responsePacket = new DatagramPacket(responseData,responseData.length,requestPacket.getSocketAddress());
                    socket.send(responsePacket);

                    break;
                }
            }
        }

    }
}

UDP客户端

java 复制代码

import java.io.File;
import java.io.IOException;
import java.lang.reflect.Array;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.nio.charset.StandardCharsets;
import java.util.Arrays;

public class UdpServer {
    private static final int PORT=8888;
    private static final String BASE_PATH = "E:/TMP";

    public static void main(String[] args) throws IOException{
        DatagramSocket  socket = new DatagramSocket(PORT);

        while(true){
            byte[] requestData = new byte[1024];
            DatagramPacket requestPacket = new DatagramPacket(requestData,requestData.length);

            System.out.println("------------------------------------------");
            System.out.println("等待接收UDP数据报...");
            socket.receive(requestPacket);

            System.out.printf("客户端IP：%s%n",requestPacket.getAddress().getHostAddress());
            System.out.printf("客户端端口号：%s%n", requestPacket.getPort());

            for(int i = 0;i< requestData.length;i++){
                byte b = requestData[i];
                if(b == '\3'){
                    String request = new String(requestData,0,i);

                    System.out.printf("客户端请求的文件列表路径为：%s%n", BASE_PATH + request);
                    File dir = new File(BASE_PATH + request);
                    File[] children = dir.listFiles();

                    StringBuilder response = new StringBuilder();

                    if(children != null){
                        for(File child : children){
                            response.append(child.getName()+'\n');
                        }
                    }

                    response.append("\3");
                    byte[] responseData = response.toString().getBytes(StandardCharsets.UTF_8);
                    System.out.println(response);
                    DatagramPacket responsePacket = new DatagramPacket(responseData,responseData.length,requestPacket.getSocketAddress());
                    socket.send(responsePacket);

                    break;
                }
            }
        }

    }
}

上述的代码中，我们为什么没有写close呢？

socket是文件描述符表中的一个表项。每次打开一个文件，就会占用一个位置。而文件描述符，是在pcb上的。(跟随进程的)

这个socket在整个程序运行过程中都是需要使用的（不能提前关闭）。当socket不需要使用的时候，程序就要结束了。进程结束，此时文件描述符表就会销毁了（PCB 都销毁了）。随着销毁的过程，套接字就被系统自动回收了。

那么什么时候会出现资源泄露呢？

代码中频繁的打开文件，但是不关闭。在一个进程的运行过程中，不断积累打开的文件，逐渐消耗掉文件描述符表里的内容，最终就消耗殆尽了。但是如果进程的生命周期很短，打开一下没多久就关闭了，谈不上泄露。

文件资源泄露这样的问题，在服务器这边是比较严重的，在客户端这边一般来说影响不大。

二、TCP流套接字编程

1、ServerSocket API

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

ServerSocket构造方法是：

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

ServerSocket的一般方法有：

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

2、Socket API

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

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

Socket的构造方法有：

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

Socket的一般方法有：

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

3、TCP中的长短连接

TCP发送数据时，需要先建立连接，什么时候关闭连接就决定它是短连接还是长连接：

短连接：每次接收到数据并返回响应后，都关闭连接，即是短连接。也就是说，短连接只能一次收发数据。

长连接：不关闭连接，一直保持连接状态，双方不停的收发数据，即是长连接。也就是说，长连接可以多次收发数据。

对比以上长短连接，两者区别如下：

建立连接、关闭连接的耗时：短连接每次请求、响应都需要建立连接，关闭连接；而长连接只需要第一次建立连接，之后的请求、响应都可以直接传输。相对来说建立连接，关闭连接也是要耗时的，长连接效率更高。

主动发送请求不同：短连接一般是客户端主动向服务端发送请求；而长连接可以是客户端主动发送请求，也可以是服务端主动发。

两者的使用场景有不同：短连接适用于客户端请求频率不高的场景，如浏览网页等。长连接适用于客户端与服务端通信频繁的场景，如聊天室，实时游戏等。

4、示例一

我们模仿UDP示例一来写一下TCP服务端与客户端：

TCP服务端

java 复制代码

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 方法, 把内核中已经建立好的连接拿到应用程序中.
            // 建立连接的细节流程都是内核自动完成的. 应用程序只需要 "捡现成" 的.
            Socket clientSocket = serverSocket.accept();
            // 此处不应该直接调用 processConnection, 会导致服务器不能处理多个客户端.
            // 创建新的线程来调用更合理的做法.
            // 这种做法可行, 不够好
//            Thread t = new Thread(() -> {
//                processConnection(clientSocket);
//            });
//            t.start();

            // 更好一点的办法, 是使用线程池.
            service.submit(new Runnable() {
                @Override
                public void run() {
                    processConnection(clientSocket);
                }
            });
        }
    }

    // 通过这个方法, 来处理当前的连接.
    public void processConnection(Socket clientSocket) {
        // 进入方法, 先打印一个日志, 表示当前有客户端连上了.
        System.out.printf("[%s:%d] 客户端上线!\n", clientSocket.getInetAddress(), clientSocket.getPort());
        // 接下来进行数据的交互.
        try (InputStream inputStream = clientSocket.getInputStream();
             OutputStream outputStream = clientSocket.getOutputStream()) {
            // 使用 try ( ) 方式, 避免后续用完了流对象, 忘记关闭.
            // 由于客户端发来的数据, 可能是 "多条数据", 针对多条数据, 就循环的处理.
            while (true) {
                Scanner scanner = new Scanner(inputStream);
                if (!scanner.hasNext()) {
                    // 连接断开了. 此时循环就应该结束
                    System.out.printf("[%s:%d] 客户端下线!\n", clientSocket.getInetAddress(), clientSocket.getPort());
                    break;
                }
                // 1. 读取请求并解析. 此处就以 next 来作为读取请求的方式. next 的规则是, 读到 "空白符" 就返回.
                String request = scanner.next();
                // 2. 根据请求, 计算响应.
                String response = process(request);
                // 3. 把响应写回到客户端.
                //    可以把 String 转成字节数组, 写入到 OutputStream
                //    也可以使用 PrintWriter 把 OutputStream 包裹一下, 来写入字符串.
                PrintWriter printWriter = new PrintWriter(outputStream);
                //    此处的 println 不是打印到控制台了, 而是写入到 outputStream 对应的流对象中, 也就是写入到 clientSocket 里面.
                //    自然这个数据也就通过网络发送出去了. (发给当前这个连接的另外一端)
                //    此处使用 println 带有 \n 也是为了后续 客户端这边 可以使用 scanner.next 来读取数据.
                printWriter.println(response);
                //    此处还要记得有个操作, 刷新缓冲区. 如果没有刷新操作, 可能数据仍然是在内存中, 没有被写入网卡.
                printWriter.flush();
                // 4. 打印一下这次请求交互过程的内容
                System.out.printf("[%s:%d] req=%s, resp=%s\n", clientSocket.getInetAddress(), clientSocket.getPort(),
                        request, response);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                // 在这个地方, 进行 clientSocket 的关闭.
                // processConnection 就是在处理一个连接. 这个方法执行完毕, 这个连接也就处理完了.
                clientSocket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    public String process(String request) {
        // 此处也是写的回显服务器. 响应和请求是一样的.
        return request;
    }

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

TCP客户端

java 复制代码

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

public class TcpEchoClient {
    private Socket socket = null;

    public TcpEchoClient(String serverIp, int serverPort) throws IOException {
        // 需要在创建 Socket 的同时, 和服务器 "建立连接", 此时就得告诉 Socket 服务器在哪里~~
        // 具体建立连接的细节, 不需要咱们代码手动干预. 是内核自动负责的.
        // 当我们 new 这个对象的时候, 操作系统内核, 就开始进行 三次握手 具体细节, 完成建立连接的过程了.
        socket = new Socket(serverIp, serverPort);
    }

    public void start() {
        // tcp 的客户端行为和 udp 的客户端差不多.
        // 都是:
        // 3. 从服务器读取响应.
        // 4. 把响应显示到界面上.
        Scanner scanner = new Scanner(System.in);
        try (InputStream inputStream = socket.getInputStream();
             OutputStream outputStream = socket.getOutputStream()) {
            PrintWriter writer = new PrintWriter(outputStream);
            Scanner scannerNetwork = new Scanner(inputStream);
            while (true) {
                // 1. 从控制台读取用户输入的内容
                System.out.print("-> ");
                String request = scanner.next();
                // 2. 把字符串作为请求, 发送给服务器
                //    这里使用 println, 是为了让请求后面带上换行.
                //    也就是和服务器读取请求, scanner.next 呼应
                writer.println(request);
                writer.flush();
                // 3. 读取服务器返回的响应.
                String response = scannerNetwork.next();
                // 4. 在界面上显示内容了.
                System.out.println(response);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

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

5、示例二

构造一个展示服务端本地某个目录（BASE_PATH）的下一级子文件列表的服务：

客户端先接收键盘输入，表示要展示的相对路径（相对BASE_PATH的路径）

发送请求：使用客户端Socket的输出流发送TCP报文。即输入的相对路径。

服务端接收并处理请求：使用服务端Socket的输入流来接收请求报文，根据请求的路径，列出下一级子文件及子文件夹。

服务端返回响应：使用服务端Socket的输出流来发送响应报文。即遍历子文件和子文件夹，每个文件名一行，返回给客户端。

客户端接收响应：使用客户端Socket的输入流来接收响应报文。简单的打印输出所有的响应内容，即文件列表。

以下为服务端和客户端代码：

TCP服务端

java 复制代码

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;

public class TCPsockServer {
    //服务器socket要绑定固定的端口
    private static final int PORT = 8888;
    //本地文件目录要展示的根路径
    private static final String BASE_PATH = "E:/TMP";

    public static void main(String[] args) throws IOException {
        // 1.创建一个服务端ServerSocket，用于收发TCP报文
        ServerSocket server = new ServerSocket(PORT);
        // 不停的等待客户端连接
        while(true) {
            System.out.println("---------------------------------------------------");
            System.out.println("等待客户端建立TCP连接...");

            // 2.等待客户端连接，注意该方法为阻塞方法
            Socket socket = server.accept();
            System.out.printf("客户端IP：%s%n", socket.getInetAddress().getHostAddress());
            System.out.printf("客户端端口号：%s%n", socket.getPort());

            // 5.接收客户端的数据，需要从客户端Socket中的输入流获取
            InputStream is = socket.getInputStream();
            // 为了方便获取字符串内容，可以将以上字节流包装为字符流
            BufferedReader br = new BufferedReader(new InputStreamReader(is, "UTF-8"));

            // 客户端请求只发送一行数据，我们也只需要读取一行
            String request = br.readLine();

            // 6.根据请求处理业务：本地目录根路径+请求路径，作为要展示的目录，列出下一级子文件
            //请求的文件列表目录
            System.out.printf("客户端请求的文件列表路径为：%s%n", BASE_PATH + request);
            File dir = new File(BASE_PATH + request);

            //获取下一级子文件，子文件夹
            File[] children = dir.listFiles();

            // 7.返回响应给客户端：通过客户端socket中的输出流发送响应数据
            OutputStream os = socket.getOutputStream();

            // 为了方便输出字符串作为发送的内容，可以将以上字节流包装为字符流
            PrintWriter pw = new PrintWriter(new OutputStreamWriter(os, "UTF-8"));
            // 7-1.返回的响应内容：每个文件及目录名称为一行
            if(children != null){
                for (File child : children) {
                    pw.println(child.getName());
                }
            }
            // 7-2.有缓冲区的IO操作，真正传输数据，需要刷新缓冲区
            pw.flush();
            // 7-3.双方关闭连接：服务端是关闭客户端socket连接
            socket.close();
        }
    }
}

TCP客户端

java 复制代码

import java.io.*;
import java.net.Socket;
import java.util.Scanner;

public class TCPsockClient {
    //服务端IP或域名
    private static final String SERVER_HOST = "localhost";

    //服务端Socket进程的端口号
    private static final int SERVER_PORT = 8888;

    public static void main(String[] args) throws IOException {
        // 准备要发送的数据：这里调整为键盘输入作为发送的内容
        Scanner scanner = new Scanner(System.in);

        while(true) {
            System.out.println("---------------------------------------------------");
            System.out.println("请输入要展示的目录：");
            // 每输入新行（回车），就作为发送的TCP请求报文
            String request = scanner.nextLine();
            // 3.创建一个客户端流套接字Socket，并与对应IP的主机上，对应端口的进程建立连接
            Socket socket = new Socket(SERVER_HOST, SERVER_PORT);

            // 发送TCP数据，是通过socket中的输出流进行发送
            OutputStream os = socket.getOutputStream();

            // 为了方便输出字符串作为发送的内容，可以将以上字节流包装为字符流
            PrintWriter pw = new PrintWriter(new OutputStreamWriter(os, "UTF-8"));
            // 发送数据：
            pw.println(request);

            // 有缓冲区的IO操作，真正传输数据，需要刷新缓冲区
            pw.flush();

            // 接收返回的响应数据：通过socket中的输入流获取
            System.out.println("接收到服务端响应：");
            InputStream is = socket.getInputStream();

            // 为了方便获取字符串内容，可以将以上字节流包装为字符流
            BufferedReader br = new BufferedReader(new InputStreamReader(is, "UTF-8"));
            String line;

            // 一直读取到流结束：TCP是基于流的数据传输，一定要服务端关闭Socket输出流才表示客户端接收的IO输入流结束
            while ((line = br.readLine()) != null) {
                System.out.println(line);
            }
            // 双方关闭连接：客户端关闭socket连接
            socket.close();
        }
    }
}