• 2023.9.8 基于传输层协议 UDP 和 TCP 编写网络通信程序

    目录

    UDP

    基于 UDP 编写网络通信程序

    服务器代码

    客户端代码

     TCP

    基于 TCP 编写网络通信程序

    服务器代码

    客户端代码

     IDEA 打开 支持多客户端模式 

    UDP

    特点：

    • 无连接性：发送端和接收端不需要建立连接也可相互通信，且每个 UDP 数据包都是独立的，它们之间没有顺序关系（无序性）
    • 不可靠性：不提供重传机制和数据包的确认，如果数据包在传输过程中丢失或损坏，接收端无法得知丢失的数据，并且不会进行重传，从而体现出传输时的不可靠性
    • 全双工通信：即发送端和接收端可以同时进行数据的发送和接收，不需要等待对方的响应
    • 面向数据报：UDP 将每个数据作为一个独立的数据单元进行处理，每个数据报都有自己的目标地址和源地址，没有关联性，也没有连接的概念
    • 适用于实时应用：由于 UDP 的无连接性和较低的延迟，其适用于如音频、视频流媒体、实时游戏等对实时性要求较高的应用场景，对于上述应用，即使有部分数据丢失也可接收，因为其实时性比数据完整性更重要
    • 简单高效性：UDP 的头部较小，没有 TCP 那么复杂，从而使得 UDP 在数据传输的开销上相对较小，传输效率更高
    • 没有拥塞控制：UDP 不会主动根据网络的拥塞情况来调整其发送速率，可能导致在网络拥堵的情况下，UDP 数据包丢失更多
    • 支持广播和多播：广播和多播都是 UDP 协议提供的数据传输方式，可在局域网或广域网中使用，它们都具有一对多的传输能力，能够将数据发送给多个目标主机。广播发送给整个网络，而多播发送给特定的多播组，只有加入该组的主机能够接收到数据

    基于 UDP 编写网络通信程序

    • 一个服务器包括三部分：收到请求、根据请求计算逻辑(业务逻辑)、返回响应
    • 这里我们编写一个简单逻辑的 服务器程序，即无业务逻辑，请求是啥就返回啥

    服务器代码

    1. //UDP 版本的服务器
    2. public class UdpEchoServer {
    3. //    网络编程，本质上是要操作网卡
    4. //    因此我们可以通过 操作系统内核所提供的一种叫做 “socket” 的文件来抽象表示和操作网卡
    5.     private DatagramSocket socket = null;
    6.  
    7. //    服务器一定要关联上一个具体的端口号
    8. //    所以在创建 socket 对象的同时，要让他绑上一个具体的端口号
    9. //    socket = new DatagramSocket() 这是创建一个 socket 对象，如果括号中不主动传入端口号，系统便会自动分配端口号
    10. //    服务器是网络传输中，被动的一方，如果是操作系统随机分配的端口，此时客户都安就知道这个端口是啥了，也就无法通信了
    11.  
    12.     public UdpEchoServer(int port) throws SocketException {
    13. //        这里我们主动传一个端口号
    14.         socket = new DatagramSocket(port);
    15.     }
    16.  
    17.     public void start() throws IOException {
    18.         System.out.println("服务器启动！");
    19. //        服务器需要服务多个客户端
    20.         while (true) {
    21. //            只要有客户端过来，就可以为其提供服务
    22. //            1.读取客户端发来的请求是什么
    23. //            这里相当于构造一个空白的 DatagramPacket 对象
    24.             DatagramPacket requestPacket = new DatagramPacket(new byte[4096],4096);
    25. //            这里的 receive 方法的参数是一个输出性参数，我们创建出来的空对象，在这里被其填充
    26.             socket.receive(requestPacket);
    27. //            此时这个 DatagramPacket 是一个特殊的对象，不方便直接进行处理，可以把这里包含的数据拿出来，构造成一个字符串
    28.             String request = new String(requestPacket.getData(), 0, requestPacket.getLength());
    29. //            2.根据请求计算响应，因为我们仅构造一个简单的服务器例子，所以此处响应和请求相同，也就是不做处理
    30.             String response = process(request);
    31. //            3. 把响应写回到客户端，send 的参数也是 DatagramPacket，需要把这个 Packet 对象构造好
    32.             DatagramPacket responsePacket = new DatagramPacket(response.getBytes(),response.getBytes().length,
    33.                     requestPacket.getSocketAddress());
    34. //              注意这里的  response.getBytes().length 计算的是字节的个数
    35. //              response.length 计算的是字符的个数，所以不能填入 response.length ，因为一个汉字由多个字节组成
    36. //            这里将响应数据进行发送
    37.             socket.send(responsePacket);
    38. //            4.打印一下日志，这次请求响应的处理中间结果
    39.             System.out.printf("[%s:%d] req: %s; resp: %s\n", requestPacket.getAddress().toString(),
    40.                     requestPacket.getPort(),request,response);
    41.         }
    42.     }
    43.  
    44. //    这个方法 表示 根据请求计算响应(处理业务逻辑)
    45.     private String process(String request) {
    46.         return request;
    47.     }
    48.  
    49.     public static void main(String[] args) throws IOException {
    50.         UdpEchoServer udpEchoServer = new UdpEchoServer(9090);
    51.         udpEchoServer.start();
    52.     }
    53. }

    客户端代码

    1. //UDP 版本的客户端
    2. public class UdpEchoClient {
    3.     private DatagramSocket socket = null;
    4.     private String serverIp;
    5.     private int serverPort;
    6.  
    7. //    通常情况下，端口号用来标识和区分一个进程，由于我们现在是同一个主机上编写服务器和客户端，所以不允许一个端口同时被多个进程使用
    8. //    但是一个进程可以绑定多个端口，即进程只需创建多个 socket 对象 就可以关联不同的端口
    9. //    相比服务器我们需要指定端口，因为是为了方便客户端找到服务器程序
    10. //    而客户端 我们无需指定端口号，只需让系统自动分配空闲端口号即可，自己指定可能因为该端口号已经被其他进程所占用，而导致无法使用该端口号
    11. //    一次通信有 两个ip 两个端口号 分别是 客户端ip 服务器ip 客户端端口号 服务器端口号
    12. //    因为客户端和服务器是在同一个主机上，所以 客户端ip 和 服务器ip 都是 127.0.0.1
    13. //    但我们需要将服务器的 ip 和 端口号 告诉客户端，才能顺利的将消息发送给服务器
    14.     public UdpEchoClient (String serverIp, int serverPort) throws SocketException {
    15.         socket = new DatagramSocket();
    16.         this.serverIp = serverIp;
    17.         this.serverPort = serverPort;
    18.     }
    19.  
    20.     public void start() throws IOException{
    21.         System.out.println("客户端启动！");
    22.         Scanner scanner = new Scanner(System.in);
    23.         while (true) {
    24. //            1.从控制台读取要发送的数据
    25.             System.out.println(">");
    26.             String request = scanner.next();
    27.             if(request.equals("exit")) {
    28.                 System.out.println("goodbye");
    29.                 break;
    30.             }
    31. //            2.构造 UDP 请求并 发送
    32. //            构造 packet 的时候 需要把 serverIp 和 port 都传入过来 但是此处 IP 地址需要填写的是一个 32位的整数形式
    33. //            
    34. //            因为 这里传入的 IP 地址是点分十进制形式字符串所表示的，但计算机内部是以 一个 32 位的整数来表示 IP 地址
    35. //            所以 需要使用 InetAddress.getByName 来将 IP 地址转换为 32 位整数
    36.             DatagramPacket requestPacket = new DatagramPacket(request.getBytes(),request.getBytes().length,
    37.                     InetAddress.getByName(serverIp),serverPort);
    38.             socket.send(requestPacket);
    39. //            3.读取服务器的 UDP 响应 并解析
    40.             DatagramPacket responsePacket = new DatagramPacket(new byte[4096],4096);
    41.             socket.receive(responsePacket);
    42.             String response = new String(responsePacket.getData(),0,requestPacket.getLength());
    43. //            4.把解析好的结果显示出来
    44.             System.out.println(response);
    45.         }
    46.     }
    47.  
    48.     public static void main(String[] args) throws IOException {
    49.         UdpEchoClient client = new UdpEchoClient("127.0.0.1",9090);
    50.         client.start();
    51.     }
    52. }

    交互过程：

    运行效果：

    • 客户端发送请求，并收到返回的响应

    • 服务器处理请求，并返回响应

     TCP

    特点：

    • 面向连接：在数据传输之前，发送端和接收端需要先建立一个连接，包括三次握手过程，连接的建立确保了双方的通信前提，并且在连接建立期间进行参数协商和初始化
    • 可靠性：TCP 使用确认机制和重传机制来确保数据的可靠性，如果接收端在接收每个数据包后会发送确认消息，发送方没有收到确认消息，会重新发送该数据包，保证数据在传输过程中不会丢失或损坏
    • 全双工通信：即发送端和接收端可以同时进行数据的发送和接收，不需要等待对方的响应
    • 面向字节流：将数据视为一个连续的字节流，并将字节流分割为适当的 TCP报文段，并在传输过程中对它们进行排序和重新组装
    • 有序性：每个 TCP报文 都有一个序列号，接收端根据序列号将数据包按照正确的顺序重新排列
    • 适用高可靠性要求应用：文件传输、Web浏览、电子邮件等
    • 流量控制和拥塞控制：流量控制用来控制发送端发送数据的速率，保证接收端能够及时处理接收到的数据，拥塞控制用于控制网络中的数据流量，避免网络拥塞

    基于 TCP 编写网络通信程序

    • 一个服务器包括三部分：收到请求、根据请求计算逻辑(业务逻辑)、返回响应
    • 这里我们编写一个简单逻辑的 服务器程序，即无业务逻辑，请求是啥就返回啥

    服务器代码

    1. // TCP 版本的服务器
    2. public class TcpEchoServer {
    3.     private ServerSocket serverSocket = null;
    4.  
    5.     public TcpEchoServer(int port) throws IOException {
    6.         serverSocket = new ServerSocket(port);
    7.     }
    8.  
    9.     public void start() throws IOException {
    10.         System.out.println("启动服务器！");
    11. //            此处使用 CachedTreadPool 使用 FixedThreadPool 是不合适的 因为线程数不应该是有固定值的
    12.         ExecutorService threadPool = Executors.newCachedThreadPool();
    13.         while (true) {
    14. //            使用这个 clientSocket 和 具体的客户端进行交流
    15.             Socket clientSocket = serverSocket.accept();
    16. //            此处使用多线程处理
    17. //            注意这里为什么要引入多线程 为了让多个客户端能同时跟服务器建立连接，并处理各自客户端的请求
    18. //            Thread t = new Thread(() ->{
    19. //                try {
    20. //                    processConnection(clientSocket);
    21. //                } catch (IOException e) {
    22. //                    e.printStackTrace();
    23. //                }
    24. //            });
    25. //            t.start();
    26. //            当很多客户端需要进行请求时，当然相比于频繁的创建线程和销毁线程 我们这里直接创建一个线程池效率会高很多
    27.  
    28. //            使用线程池
    29.             threadPool.submit(new Runnable() {
    30.                 @Override
    31.                 public void run() {
    32.                     try {
    33.                         processConnection(clientSocket);
    34.                     } catch (IOException e) {
    35.                         e.printStackTrace();
    36.                     }
    37.                 }
    38.             });
    39.         }
    40.     }
    41.  
    42.     private void processConnection(Socket clientSocket) throws IOException {
    43.         System.out.printf("[%s:%d] 客户端上线！\n",clientSocket.getInetAddress().toString(),clientSocket.getPort());
    44. //        基于上述 socket 对象和客户端进行通信
    45.         try (InputStream inputStream = clientSocket.getInputStream();
    46.              OutputStream outputStream = clientSocket.getOutputStream()){
    47.             
    48. //            概念：
    49. //            则客户端建立一次连接，服务器可处理多次请求并返回响应，到客户端短时间内不需要这个连接，便直接断开连接 这属于长连接
    50. //            则客户端建立一次连接，服务器也仅处理一次请求并返回响应，便直接断开连接 这属于短连接
    51.             
    52. //            这里我们写的是长连接，从而需要使用循环 来处理多个请求和响应
    53.             while (true) {
    54. //                1.读取请求
    55.                 Scanner scanner = new Scanner(inputStream);
    56.                 if (!scanner.hasNext()) {
    57. //                    没有下个数据 说明读完了 （客户端关闭了连接）
    58.                     System.out.printf("[%s:%d] 客户端下线！\n", clientSocket.getInetAddress().toString(),clientSocket.getPort());
    59.                     break;
    60.                 }
    61. //                此处使用 next 是一致读取到 换行符/空格/其他空白符结束，但是最终返回结果里不包含上述 空白符
    62.                 String request = scanner.next();
    63. //                2.根据请求构造响应
    64.                 String response = process(request);
    65. //                3.返回响应结果
    66. //                OutputStream 相当于对应着一个文件描述符（socket文件）
    67. //                通过 OutputStream 就可以往这个 文件描述符 中写数据
    68. //                但 OutputStream 没有 写字符串 这样的功能  但
    69. //                所以我们 将其转化为 字符流 PrintWriter 且其对应的文件描述符还是同一个 从而可以进行写入
    70.                 PrintWriter printWriter = new PrintWriter(outputStream);
    71. //                此处使用 println 来写入 让结果中带有 一个 \n 换行 方便对接收端来接收解析
    72. //                因为 TCP 是面向字节流的 所以 一次性读多少个字节都是可以的
    73. //                从而这里我们可以进行一个隐式约定 使用 \n 来作为当前代码的请求或响应分割约定 与上面代码的 scanner.next() 相对应
    74. //                从而该行代码这里使用 println 来相当于 TCP 发送数据，
    75.                 printWriter.println(response);
    76. //                flush 用来刷新缓冲区 保证当前写入的数据 确实发送出去了
    77.                 printWriter.flush();
    78.  
    79.                 System.out.printf("[%s:%d] req:%s; resp:%s\n",clientSocket.getInetAddress().toString(),clientSocket.getPort(),
    80.                         request,response);
    81.             }
    82.  
    83.         } catch (IOException e) {
    84.             e.printStackTrace();
    85.         }finally {
    86. //            每来一个客户端 就会创建一个 clientSocket ，每创建一个就要消耗一个文件描述符
    87. //            因此当完成该客户端的请求后 就需要释放掉其 clientSocket
    88.             clientSocket.close();
    89.         }
    90.     }
    91.  
    92.     private String process(String request) {
    93.         return request;
    94.     }
    95.  
    96.     public static void main(String[] args) throws IOException {
    97.         TcpEchoServer server = new TcpEchoServer(9090);
    98.         server.start();
    99.     }
    100. }

    客户端代码

    1. public class TcpEchoClient {
    2.     private Socket socket = null;
    3.  
    4.     public TcpEchoClient(String serverIp,int serverPort) throws IOException {
    5. //        Socket 构造方法 能够识别 点分十进制格式的 IP 地址 必 DatagramPacket 更方便
    6. //        new 这个对象的同时 就会进行 TCP 连接操作 如果客户端没有该行代码 服务器就会在 accept 堵塞
    7.         socket = new Socket(serverIp,serverPort);
    8.     }
    9.  
    10.     public void start() {
    11.         System.out.println("客户端启动！");
    12.         Scanner scanner = new Scanner(System.in);
    13.         try (InputStream inputStream = socket.getInputStream();
    14.              OutputStream outputStream = socket.getOutputStream()){
    15.  
    16.                 while (true) {
    17.     //            1.先从键盘上读取用户输入的内容
    18.                     System.out.println(">");
    19.                     String request = scanner.next();
    20.                     if(request.equals("exit")) {
    21.                         System.out.println("goodbye");
    22.                         break;
    23.                     }
    24.     //            2.把读到的内容构造成请求 发送给服务器
    25.                     PrintWriter printWriter = new PrintWriter(outputStream);
    26.                     printWriter.println(request);
    27. //                    此处的 flush 是确保数据确实发送出去了
    28.                     printWriter.flush();
    29.     //            3.读取服务器的响应
    30.                     Scanner respScanner = new Scanner(inputStream);
    31.                     String response = respScanner.next();
    32.     //            4.把响应内容显示到界面上
    33.                     System.out.println(response);
    34.                 }
    35.             }catch (IOException e){
    36.             e.printStackTrace();
    37.         }
    38.     }
    39.  
    40.     public static void main(String[] args) throws IOException {
    41.         TcpEchoClient client = new TcpEchoClient("127.0.0.1",9090);
    42.         client.start();
    43.     }
    44. }

    交互过程：

    运行效果：

    • 客户端发送请求，并收到返回的响应

    • 服务器处理请求，并返回响应

     IDEA 打开 支持多客户端模式 

    操作步骤：

    • 完成上述步骤，我们便打开了 IDEA 多客户端模式，此时我们仅需再点击一次客户端启动按钮，便会有两个客户端共存了！
  • 相关阅读:
    栈和队列java实现
    elasticsearch-reinde 实际操作步骤
    pyinstaller打包完整python项目
    Vue3 实现网页背景水印功能
    优先级队列
    Java专项进阶篇
    4.企业快速开发平台Spring Cloud+Spring Boot+Mybatis之Highcharts 配置选项详细说明
    入门Rabbitmq
    查询企业联系方式的途径有哪些？
    朋友圈为什么会被折叠？
  • 原文地址：https://blog.csdn.net/weixin_63888301/article/details/132783412