22. 网络编程（1）——UDP 协议

逃离我推掉我的手 2022-11-06 10:54 195阅读 0赞

网络编程需要依靠Socket API，在java标准库中有两种风格：  
1.（**UDP**）DatagramSocket：面向数据报（发送接收数据，必须以一定的数据报为单位进行传输）  
2.（**TCP**）ServerSocket：面向字节流

UDP和TCP就是传输层的两个最重要的协议

## UDP ##

实现一个最简单的服务器（回显服务器 echo server），客户端给服务器发送一个字符串，服务器把这个字符串返回显示出来

**对于一个服务器程序，核心流程分成两步**

> 1.进行初始化操作  
> 2，进入主循环，接收并处理请求（主循环就是死循环）  
> a）读取数据并解析  
> b）根据请求计算响应  
> c）把响应结果写回到客户端

服务器：

import java.io.IOException;
    import java.net.DatagramPacket;
    import java.net.DatagramSocket;
    import java.net.SocketException;
    
    /**
     * UDP 服务器
     */
    public class UdpEchoServer {
        
        //对于一个服务器程序，核心流程分成两步
        //1.进行初始化操作
        //2，进入主循环，接收并处理请求（主循环就是死循环）
        //  a）读取数据并解析
        //  b）根据请求计算响应
        //  c）把响应结果写回到客户端
        private DatagramSocket socket = null;
        //DatagramSocket 本质上是一个文件，这个文件是网卡的抽象
    
        //构造方法
        public UdpEchoServer(int port) throws SocketException {
        
            socket = new DatagramSocket(port);
            //new的时候就会让socket对象和一个端口号和一个IP地址关联在一起（绑定端口）
            //未来的客户端就按照这个IP和端口号来访问服务器
            //如果在构造socket的时候没有写IP，就是 0.0.0.0（会关联到这个主机的所有网卡IP）
            //IP是决定互联网的某个主机的位置，port是决定数据交给这个主机的哪个位置
        }
    
        public void start() throws IOException {
        
            System.out.println("服务器启动");
            while (true){
        
                //  a）读取数据并解析
                DatagramPacket requestPacket = new DatagramPacket(new byte[4096],4096);
                //new byte[4096],4096  相当于关联了缓冲区
                // DatagramPacket是发送和接收数据的基本单位
                socket.receive(requestPacket);
                //程序启动之后马上就能执行到receive
                //大多时候调用receive的时候，客户端还没有发送请求，这时receive就会阻塞，当真的有客户端数据过来之后，就会把收到的数据放入缓冲区
                String request = new String(requestPacket.getData(), 0,requestPacket.getLength()).trim();
                //此处需要把请求数据转成string（本来是byte[]）
                //requestPacket.getData()获取到缓冲区，也就是byte数组，然后从0开始，到缓冲区长度处结束
                //.trim()：用户实际发送的数据可能远远小于4096，此时getLength()获取到的都是4096，此时就可以通过trim来去掉一些空白空间
    
                //  b）根据请求计算响应
                String response = process(request);
                //  c）把响应结果写回到客户端
                DatagramPacket responsePacket = new DatagramPacket(response.getBytes(),
                        response.getBytes().length, requestPacket.getSocketAddress());
                //response.getBytes():响应数据就是response，需要包装成一个Packet对象
                //request.getBytes().length：获取长度,得到的是字符数
                //requestPacket.getSocketAddress()：指定当前数据发给谁，这个方法就把IP端口号全部获取到，就设置到了responsePacket里面
                socket.send(responsePacket);
    
                //以下部分可省略
                System.out.printf("[%s:%d] req: %s; resp: %s\n",requestPacket.getAddress().toString(),
                        requestPacket.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();
        }
    }

**对于一个客户端程序，核心流程分成两步**

> 1.从用户这里读取输入的数据  
> 2.构造一个请求发送给服务器  
> 3.从服务器读取响应  
> 4.把响应写回给客户端

客户端：

import java.io.IOException;
    import java.net.*;
    import java.util.Scanner;
    
    /**
     * UDP 客户端
     */
    public class UdpEchoClient {
        
        //客户端的主要流程分为4步
        //1.从用户这里读取输入的数据
        //2.构造一个请求发送给服务器
        //3.从服务器读取响应
        //4.把响应写回给客户端
    
        private DatagramSocket socket = null;
        private String serverIP;
        private int serverPort;
    
        //需要在启动客户端的时候指定需要连接哪个服务器
        public UdpEchoClient(String serverIP, int serverPort) throws SocketException {
        
            this.serverIP = serverIP;
            this.serverPort = serverPort;
            socket = new DatagramSocket();//客户端创建socket的时候不需要绑定端口号，由操作系统自动分配一个空闲端口
        }
    
        public void start() throws IOException {
        
            Scanner scanner = new Scanner(System.in);
            while (true){
        
                //1.读取用户输入的数据
                System.out.print("->");//提示符：提示用户输入字符
                String request = scanner.nextLine();//作为请求
                if (request.equals("exit")){
        
                    //结束
                    break;
                }
                
                //2.构造一个请求发送给服务器
                DatagramPacket requestPacket = new DatagramPacket(request.getBytes(),
                        request.getBytes().length, InetAddress.getByName(serverIP), serverPort);
                //InetAddress.getByName(serverIP), serverPort： 要把数据报发给哪个服务器：指定IP和端口号
                socket.send(requestPacket);
    
                //3.从服务器读取响应
                DatagramPacket responsePacket = new DatagramPacket(new byte[4096],4096);
                socket.receive(responsePacket);
                String response = new String(responsePacket.getData(),0,responsePacket.getLength()).trim();
                
                //4.把响应写回给客户端
                System.out.println(response);
            }
        }
    
    
        public static void main(String[] args) throws IOException {
        
            UdpEchoClient client = new UdpEchoClient("127.0.0.1",9090);
            //"127.0.0.1":是环回IP，因为此时客户端和服务器在一台主机上
            //9090：这个端口要和服务器绑定的端口相匹配
            client.start();
        }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MTM2MTg5_size_16_color_FFFFFF_t_70]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MTM2MTg5_size_16_color_FFFFFF_t_70 1]

如果想要完成较为复杂的逻辑，就可以通过继承，重写process方法实现  
例如现在想要完成词典翻译的服务器：

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("cat","小猫");
            dict.put("dog","小狗");
            dict.put("find","找到");
        }
    
        @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();
        }
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MTM2MTg5_size_16_color_FFFFFF_t_70]: /images/20221023/a398df827120404b9dadcdf471beb9d1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MTM2MTg5_size_16_color_FFFFFF_t_70 1]: /images/20221023/16325d3b1148483e952b772de53cd0dd.png