基于UDP/TCP实现客户端服务器的网络通信程序

我会带着你远行 2024-03-27 11:53 89阅读 0赞

## 目录： ##

### 前言 ###

### 基于UDP实现客户端服务器的网络通信程序 ###

### 基于TCP实现客户端服务器的网络通信程序 ###

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

### 前言 ###

网络编程的核心是Socket API，它是操作系统给应用程序提供的网络编程API，可以认为是socket api是和传输层密切相关的。在传输层里面，提供了两个最核心的协议，UDP和TCP。因此，socket api 也提供了两种风格（UDP和TCP）。

先来对UDP和TCP做一个简单的总结：

**UDP：无连接、不可靠传输、面向数据报、全双工**

**TCP：有连接、可靠传输、面向字节流、全双工**

关于有无连接，可以用打电话和发微信来类比，打电话就是有连接，有无接通可以被感知，而发微信就是无连接，对方是否已经看到消息是无感知的。

关于可靠与不可靠传输，还是可以用打电话和发微信来类比，打电话就是可靠传输，对方接通并回应就是确认收到了，发微信就是不可靠传输，消息发送出去并不知道对方已经确认收到，就是不可靠传输。

面向字节流：数据传输就和文件读写类似，是“流式”的。

面向数据报：数据传输则以一个个的“数据报”为基本单位，一个数据报可能是若干个字节且带有一定格式。

全双工：一个通信通道，可以双向传输，既可以发送也可以接受。比如一根水管，是单向传输的，就是半双工。

### 基于UDP实现客户端服务器的网络通信程序 ###

使用DatagramSocket这个类，表示一个socket对象。在操作系统中，把这个socket对象也是当成一个文件来处理的，相当于是文件描述符表上的一项。其中普通的文件对应的硬件设备是硬盘，socket文件对应的硬件设备是网卡。一个socket对象就可以和另外一台主机进行网络通信了，如果需要和多个不同的主机通信，则需要创建多个socket对象。

**DatagramSocket():** 无参数就是没有指定端口，系统则会自动分配一个空闲的端口

**DatagramSocket(int port):** 传入了一个端口号，就是让当前的socket对象和这个指定的端口关联起来。从本质上来说，不是进程和端口来建立联系，而是进程中的socket对象和端口建立了联系。

**DatagramPacket：**表示UDP中传输的一个报文，也是UDP传输数据的基本单位。

**receive(DatagramPacket p)：**此处传入的是一个空的对象，空的报文，receive方法内部会对参数的这个空对象进行内容填充，从而构造出数据。

**send(DatagramPacket p):**  将构造好的报文发送出去。

下面这里将写一个简单的回显客户端服务器，当然对于服务器来说，对于请求的处理，即业务逻辑的处理是最核心最复杂的，我们这里就回显设置，重点在于理解整个通信过程。

##### 服务器端代码： #####

public class UdpEchoServer {
        // 网络编程, 本质上是要操作网卡.
        // 但是网卡在操作系统内核中，不方便直接操作，使用了"socket" 这样的文件来抽象表示网卡
        // 因此进行网络通信, 必需要先有一个 socket 对象
        private DatagramSocket socket = null;
    
        // 对于服务器来说, 创建 socket 对象的同时, 要让它绑定上一个具体的端口号，服务器一定要关联上一个具体的端口
        // 服务器在网络传输中才知道此时客户端的端口, 才能进行通信
        public UdpEchoServer(int port) throws SocketException {
            socket = new DatagramSocket(port);
        }
        public void start() throws IOException {
            System.out.println("服务器启动！");
            // 服务器不是只给一个客户端提供服务就完了，需要服务很多客户端，所以需要用到循环
            while (true){
                //1.读取客服端发来的请求
                //receive方法的参数是一个输出型参数, 需要先构造好个空白的 DatagramPacket 对象，交给 receive 来进行填充
                DatagramPacket requestPack = new DatagramPacket(new byte[4096],4096);
                socket.receive(requestPack);
                //把数据拿出来, 构造成一个字符串
                String request = new String(requestPack.getData(),0,requestPack.getLength());
    
                //2.根据请求计算响应，此时为回显服务器，所以写得比较简单，请求和响应相同
                String response = process(request);
    
                //3.把响应写回客户端
                //send 的参数也是 DatagramPacket,也是需要把这个 Packet 对象构造好
                //此处构造的响应对象, 不能是用空的字节数组构造了, 而是要使用响应数据来构造
                DatagramPacket responsePacket = new DatagramPacket(response.getBytes(),response.getBytes().length,
                        requestPack.getSocketAddress());
                socket.send(responsePacket);
    
                //4.打印当前这次请求响应的处理结果
                System.out.printf("[%s:%d] req: %s; resp: %s\n",requestPack.getAddress().toString(),
                        requestPack.getPort(),request,response);
            }
        }
    
        private String process(String request) {
            return request;
        }
    
        public static void main(String[] args) throws IOException {
            UdpEchoServer server = new UdpEchoServer(9090);
            server.start();
        }
    }

##### 客户端代码： #####

public class UdpEchoClient {
        private DatagramSocket socket = null;
        private String serverIp = null;
        private int serverPort = 0;
    
        // 服务器 ip 和 端口 也需要告诉客户端. 才能顺利把消息发个服务器
        public UdpEchoClient(String serverIp,int serverPort) throws SocketException {
            socket = new DatagramSocket();
            this.serverIp = serverIp;
            this.serverPort = serverPort;
        }
    
        public void start() throws IOException {
            System.out.println("客户端启动！");
            Scanner scanner = new Scanner(System.in);
            while (true){
                //1.从控制台读取数据
                System.out.print("=>:");
                String request = scanner.next();
                if (request.equals("exit")){
                    System.out.println("goodBye!");
                    break;
                }
    
                //2.构造UDP请求并发送
                //构造这个 Packet 的时候, 需要把 serverIp 和 port 都传入过来，此处 IP 地址需要填写的是一个 32位的整数形式.
                //上述的 IP 地址是一个字符串，需要使用 InetAddress.getByName 来进行一个转换
                DatagramPacket requestPack = new DatagramPacket(request.getBytes(),request.getBytes().length,
                        InetAddress.getByName(serverIp),serverPort);
                socket.send(requestPack);
    
                //3.读取服务器的UDP响应并解析
                DatagramPacket responsePack = new DatagramPacket(new byte[4096],4096);
                socket.receive(responsePack);
                String response = new String(responsePack.getData(),0,responsePack.getLength());
    
                //4.打印解析的结果
                System.out.println(response);
            }
        }
    
        public static void main(String[] args) throws IOException {
            UdpEchoClient client = new UdpEchoClient("127.0.0.1",9090);
            client.start();
        }
    }

##### 通信逻辑顺序图： #####

![3a00a9b5101440a7bbce16f0a4bfb82b.png][]

### 基于TCP实现客户端服务器的网络通信程序 ###

TCP提供的API主要是两个类：

**ServerSocket：**专给服务器使用的Socket对象

**Socket：**既会给服务器使用，也会给客户端使用。

TCP的传输与UDP有所不同，它并不是以数据报为单位进行传输的，而是以字节的方式，流式传输。

// 使用这个 clientSocket 和具体的客户端进行交流
     Socket clientSocket = serverSocket.accept();

![c100f8ced714401e9c916bc2c92d1fa2.png][]

accept的作用就是接受连接，客户端在构造Socket对象的时候就会指定服务器的IP和端口，如果没有客户端来连接，此时accept就会阻塞。只要任意一个客户端连接上来，服务器这边都会创建一个Socket对象，每次创建一个Socket对象，就要占用一个文件描述符表的一个位置，因此在使用完毕后要进行释放。前面我们写的UDP就不存在这个情况，一方面是因为UDP中的Socket对象的生命周期是跟随整个程序的，声明周期更长，另一方面是Socket数量不是很多。

一次连接只能处理一个客户端的请求，那么同时有非常多的客户端发出请求，也就是高并发，此时可以用多线程来解决，为了避免线程频繁的创建和销毁，也可以用线程池。

while (true){
                // 使用这个 clientSocket 和具体的客户端进行交流
                Socket clientSocket = serverSocket.accept();
    
                //多线程版本
             /*   Thread t = new Thread(()->{
                    processConnection(clientSocket);
                });
                t.start();*/
    
                //线程池版本
                threadPool.submit(()->{
                    processConnection(clientSocket);
                });
            }

但是对于特别量大的客户端，多线程和线程池也是不行的，可以多开服务器可以解决，但是毕竟成本高，还有一种方式就是IO多路复用。大概逻辑就是：给一个线程安排一个集合，这个集合里面放了一堆连接，这个线程就负责监听这个集合，哪一个连接有数据来了，这个线程就先处理哪个连接。IO多路复用本质上来说，就是充分利用等待的时间来做别的事情。

##### 服务器端代码： #####

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("启动服务器！");
            // 此处使用 CachedThreadPool, 使用 FixedThreadPool的时候线程数是固定的，不太合适
            ExecutorService threadPool = Executors.newCachedThreadPool();
            while (true){
                // 使用这个 clientSocket 和具体的客户端进行交流
                Socket clientSocket = serverSocket.accept();
    
                //多线程版本
             /*   Thread t = new Thread(()->{
                    processConnection(clientSocket);
                });
                t.start();*/
    
                //线程池版本
                threadPool.submit(()->{
                    processConnection(clientSocket);
                });
            }
        }
    
        private void processConnection(Socket clientSocket) {
            System.out.printf("[%s:%d]客户端上线！\n",clientSocket.getInetAddress().toString(),clientSocket.getPort());
            // 基于上述 socket 对象和客户端进行通信
            try (InputStream inputStream = clientSocket.getInputStream();
                 OutputStream outputStream = clientSocket.getOutputStream()){
                // 由于要处理多个请求和响应, 也是使用循环来进行
                while (true){
                    //1.读取请求
                    Scanner scanner =new Scanner(inputStream);
                    if (!scanner.hasNext()){
                        System.out.printf("[%s:%d]客户端下线！\n",clientSocket.getInetAddress().toString(),clientSocket.getPort());
                        break;
                    }
                    //此处使用 next 是一直读取到换行符/空格/其他空白符结束, 但是最终返回结果里不包含上述换行符/空格/其他空白符
                    String request = scanner.next();
    
                    //2.根据请求构造响应
                    String response = process(request);
    
                    //3.返回响应结果
                    PrintWriter printWriter = new PrintWriter(outputStream);
                    // 此处使用 println 来写入,让结果中带有一个 \n 换行. 方便对端来接收解析
                    printWriter.println(response);
                    // flush 用来刷新缓冲区, 保证当前写入的数据是真正发送出去了
                    printWriter.flush();
    
                    //4.打印当前这次请求响应的处理结果
                    System.out.printf("[%s:%d] req: %s; resp: %s\n",clientSocket.getInetAddress().toString(),
                            clientSocket.getPort(),request,response);
                }
            } catch (IOException e) {
                e.printStackTrace();
            }finally {
                try {
                    clientSocket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    
        private String process(String request) {
            return request;
        }
    
        public static void main(String[] args) throws IOException {
            TcpEchoServer server = new TcpEchoServer(9090);
            server.start();
        }
    }

##### 客户端代码： #####

public class TcpEchoClient {
        private Socket socket = null;
        public TcpEchoClient(String serverIp,int serverPort) throws IOException {
            socket = new Socket(serverIp,serverPort);
        }
    
        public void start(){
            System.out.println("客户端启动！");
            Scanner scanner = new Scanner(System.in);
            try (InputStream inputStream = socket.getInputStream();
                 OutputStream outputStream = socket.getOutputStream()){
                while (true){
                    //1.从控制台读取数据
                    System.out.print("=>:");
                    String request = scanner.next();
                    if (request.equals("exit")){
                        System.out.println("goodBye!");
                        break;
                    }
    
                    //2.构造请求并发送
                    PrintWriter printWriter = new PrintWriter(outputStream);
                    printWriter.println(request);
                    printWriter.flush();
    
                    //3.读取服务器响应
                    Scanner respScanner = new Scanner(inputStream);
                    String response = respScanner.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();
        }
    }

### 总结 ###

在上面代码中，关于有无连接，面向字节流和面向数据报，以及全双工都能在代码中体现。但是，在TCP中的可靠传输是在代码层面感知不到的。从TCP诞生的意义来说，就是为了解决可靠传输的问题的。关于TCP能够保证可靠传输问题 ，后面再来总结。

[3a00a9b5101440a7bbce16f0a4bfb82b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/19f31d630f6c41dead87d8b15b2329ab.png
[c100f8ced714401e9c916bc2c92d1fa2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/89a92e920a04495dbc26f6cb1de2cbba.png