263 - 基于UDP的网络编程

已于 2022-10-24 18:05:01 修改
阅读量748 收藏
点赞数
分类专栏： JavaSE 文章标签： 1024程序员节 java
于 2022-10-24 17:24:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhoulizhengZ/article/details/127495045
版权
本文详细介绍了如何使用UDP在Java中实现网站咨询聊天功能，包括单向通信、双向通信以及加入异常处理的完整过程。通过实例展示了DatagramSocket的使用和数据包的发送与接收，重点突出了双方地位平等的特点。
摘要由CSDN通过智能技术生成

小结 - 比较：

TCP:

客户端：Socket  -  程序感受到的 使用流  ：输出流

服务器端:ServerSocket -（获取）Socket     程序感受到的 使用流  ：输入流

（客户端和服务器端地位不平等。）

UDP:

发送方：DatagramSocket   发送：数据包  DatagramPacket

接收方：DatagramSocket   接收：数据包  DatagramPacket

（发送方和接收方的地址是平等的。）

UDP案例：  完成网站的咨询聊天

功能分解1：单向通信

发送方：

package test6_UDP_1;

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

/**
 * @Auther: zhoulz
 * @Description: test6_UDP_1
 * @version: 1.0
 */
public class TestSend { //发送方
    public static void main(String[] args) throws IOException {
        System.out.println("学生上线。。。");
        //1、准备套接字：指定发送方的端口号
        DatagramSocket ds = new DatagramSocket(8888);
        //2、准备数据包
        String str = "您好";
        byte[] bytes = str.getBytes(); //将String转为字节数组
        /*
        需要四个参数：
        1.指的是传送数据转为字节数组
        2.字节数组的长度
        3.封装接收方的ip
        4.指定接收方的端口号
        */
        DatagramPacket dp = new DatagramPacket(bytes,bytes.length, InetAddress.getByName("localhost"),9999);
        //要求传入的参数为：(byte[] buf, int length, InetAddress address,int port)

        //然后发送： —— 利用套接字进行发送
        ds.send(dp);

        //关闭资源
        ds.close();
    }
}

接收方：

package test6_UDP_1;

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

/**
 * @Auther: zhoulz
 * @Description: test6_UDP_1
 * @version: 1.0
 */
public class TestReceive {//接收方

    public static void main(String[] args) throws IOException {
        System.out.println("老师上线了。。。");
        //1、创建套接字：指定接收方的端口
        DatagramSocket ds = new DatagramSocket(9999);
        //2、有一个空的数据包，打算用来接收 对方传过来的数据包
        byte[] b = new byte[1024];
        DatagramPacket dp = new DatagramPacket(b,b.length); //传入空的数组
        //3.接收对方的数据包，然后放入我们的dp数据包中填充
        ds.receive(dp); //接收完以后,dp里面就填充好内容了

        //4、取出数据
        byte[] data = dp.getData(); // dp.getData()的返回值是字节数组
        //String s = new String(data);//将data字节数组转为字符串
        //取出数组包中的有效数据，dp.getLength() — 数组包中的有效长度
        String s = new String(data,0,dp.getLength());
        System.out.println("学生对我说："+s);

        //5、关闭资源
        ds.close();
    }
}

功能分解2：双向通信

发送方：

package test6_UDP_2;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.util.Scanner;

/**
 * @Auther: zhoulz
 * @Description: test6_UDP_1 —— 分解2：双向通信
 * @version: 1.0
 */
public class TestSend { //发送方
    public static void main(String[] args) throws IOException {
        System.out.println("学生上线。。。");
        //1、准备套接字：指定发送方的端口号
        DatagramSocket ds = new DatagramSocket(8888);
        //2、准备数据包
        //键盘输入获取数据包
        Scanner sc = new Scanner(System.in);
        System.out.print("学生："); //提示,且不换行
        String str = sc.next();
        byte[] bytes = str.getBytes(); //将String转为字节数组
        /*
        需要四个参数：
        1.指的是传送数据转为字节数组
        2.字节数组的长度
        3.封装接收方的ip
        4.指定接收方的端口号
        */
        DatagramPacket dp = new DatagramPacket(bytes,bytes.length, InetAddress.getByName("localhost"),9999);
        //要求传入的参数为：(byte[] buf, int length, InetAddress address,int port)

        //然后发送： —— 利用套接字进行发送
        ds.send(dp);

        //双向通信！！！

        //学生接收老师发送回来的信息：
        //同理，准备一个空的数据包，打算用来接收 对方(老师)传过来的数据包
        byte[] b = new byte[1024];
        DatagramPacket dp2 = new DatagramPacket(b,b.length); //传入空的数组
        //接收对方的数据包，然后放入我们的dp数据包中填充
        ds.receive(dp2); //接收完以后,dp里面就填充好内容了

        //4、取出数据
        byte[] data = dp2.getData(); // dp.getData()的返回值是字节数组
        //String s = new String(data);//将data字节数组转为字符串
        //取出数组包中的有效数据，dp.getLength() — 数组包中的有效长度
        String s = new String(data,0,dp2.getLength());
        System.out.println("老师对我说："+s);

        //关闭资源
        ds.close();
    }
}

接收方：

package test6_UDP_2;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.util.Scanner;

/**
 * @Auther: zhoulz
 * @Description: test6_UDP_1 —— 分解2：双向通信
 * @version: 1.0
 */
public class TestReceive {//接收方

    public static void main(String[] args) throws IOException {
        System.out.println("老师上线了。。。");
        //1、创建套接字：指定接收方的端口
        DatagramSocket ds = new DatagramSocket(9999);
        //2、有一个空的数据包，打算用来接收 对方传过来的数据包
        byte[] b = new byte[1024];
        DatagramPacket dp = new DatagramPacket(b,b.length); //传入空的数组
        //3.接收对方的数据包，然后放入我们的dp数据包中填充
        ds.receive(dp); //接收完以后,dp里面就填充好内容了

        //4、取出数据
        byte[] data = dp.getData(); // dp.getData()的返回值是字节数组
        //String s = new String(data);//将data字节数组转为字符串
        //取出数组包中的有效数据，dp.getLength() — 数组包中的有效长度
        String s = new String(data,0,dp.getLength());
        System.out.println("学生对我说："+s);

        //双向通信！！！

        //老师进行回复：
        //准备数据包
        //同样从 键盘输入获取数据包
        Scanner sc= new Scanner(System.in);
        System.out.print("老师：");
        String str = sc.next();//提示,且不换行
        byte[] bytes = str.getBytes(); //将String转为字节数组
        //封装数据，并且指定学生的ip和端口号
        DatagramPacket dp2 = new DatagramPacket(bytes,bytes.length, InetAddress.getByName("localhost"),8888);
        //发送：
        ds.send(dp2);

        //5、关闭资源
        ds.close();
    }
}

功能分解3：加入完整的处理异常方式

加入了 try-catch-finally 的异常处理。

发送方：

package test8_UDP_3_try_catch;

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

/**
 * @Auther: zhoulz
 * @Description: test6_UDP_1 —— 分解2：双向通信
 * @version: 1.0
 */
public class TestSend { //发送方
    public static void main(String[] args) {
        System.out.println("学生上线。。。");
        //1、准备套接字：指定发送方的端口号
        DatagramSocket ds = null;
        try {
            ds = new DatagramSocket(8888);

            //把下面的代码剪切到try中来
            //2、准备数据包
            //键盘输入获取数据包
            Scanner sc = new Scanner(System.in);
            System.out.print("学生："); //提示,且不换行
            String str = sc.next();
            byte[] bytes = str.getBytes(); //将String转为字节数组
        /*
        需要四个参数：
        1.指的是传送数据转为字节数组
        2.字节数组的长度
        3.封装接收方的ip
        4.指定接收方的端口号
        */
            DatagramPacket dp = new DatagramPacket(bytes,bytes.length, InetAddress.getByName("localhost"),9999);
            //要求传入的参数为：(byte[] buf, int length, InetAddress address,int port)

            //然后发送： —— 利用套接字进行发送
            ds.send(dp); //有异常 ，则继续追加

            //双向通信！！！

            //学生接收老师发送回来的信息：
            //同理，准备一个空的数据包，打算用来接收 对方(老师)传过来的数据包
            byte[] b = new byte[1024];
            DatagramPacket dp2 = new DatagramPacket(b,b.length); //传入空的数组
            //接收对方的数据包，然后放入我们的dp数据包中填充
            ds.receive(dp2); //接收完以后,dp里面就填充好内容了

            //4、取出数据
            byte[] data = dp2.getData(); // dp.getData()的返回值是字节数组
            //String s = new String(data);//将data字节数组转为字符串
            //取出数组包中的有效数据，dp.getLength() — 数组包中的有效长度
            String s = new String(data,0,dp2.getLength());
            System.out.println("老师对我说："+s);

        } catch (SocketException e) {
            e.printStackTrace();
        } catch (UnknownHostException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //关闭资源
            ds.close();
        }
    }
}

接收方：

package test8_UDP_3_try_catch;

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

/**
 * @Auther: zhoulz
 * @Description: test6_UDP_1 —— 分解2：双向通信
 * @version: 1.0
 */
public class TestReceive {//接收方

    public static void main(String[] args) {
        System.out.println("老师上线了。。。");
        //1、创建套接字：指定接收方的端口
        DatagramSocket ds = null;
        try {
            ds = new DatagramSocket(9999);

            //同样，把下面的代码剪切到try中来
            //2、有一个空的数据包，打算用来接收 对方传过来的数据包
            byte[] b = new byte[1024];
            DatagramPacket dp = new DatagramPacket(b,b.length); //传入空的数组
            //3.接收对方的数据包，然后放入我们的dp数据包中填充
            ds.receive(dp); //接收完以后,dp里面就填充好内容了

            //4、取出数据
            byte[] data = dp.getData(); // dp.getData()的返回值是字节数组
            //String s = new String(data);//将data字节数组转为字符串
            //取出数组包中的有效数据，dp.getLength() — 数组包中的有效长度
            String s = new String(data,0,dp.getLength());
            System.out.println("学生对我说："+s);

            //双向通信！！！

            //老师进行回复：
            //准备数据包
            //同样从 键盘输入获取数据包
            Scanner sc= new Scanner(System.in);
            System.out.print("老师：");
            String str = sc.next();//提示,且不换行
            byte[] bytes = str.getBytes(); //将String转为字节数组
            //封装数据，并且指定学生的ip和端口号
            DatagramPacket dp2 = new DatagramPacket(bytes,bytes.length, InetAddress.getByName("localhost"),8888);
            //发送：
            ds.send(dp2);

        } catch (SocketException e) {
            e.printStackTrace();
        } catch (UnknownHostException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //5、关闭资源
            ds.close();
        }
    }
}

功能分解4：正常通信

通信应该是连续的，不会一人说一句然后就中断/结束了（如上示代码）。

加入死循环 —— 可实现持续聊天

但是，怎么让停下来呢？

停止会话由谁结束呢？ 学生？老师？  ： 学生

发送方：

package test9_UDP_4_complete_communication;

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

/**
 * @Auther: zhoulz
 * @Description: test6_UDP_1 —— 分解2：双向通信
 * @version: 1.0
 */
public class TestSend { //发送方
    public static void main(String[] args) {
        System.out.println("学生上线。。。");
        //1、准备套接字：指定发送方的端口号
        DatagramSocket ds = null;
        try {
            ds = new DatagramSocket(8888);

            while (true){ //死循环
                //把下面的代码剪切到try中来
                //2、准备数据包
                //键盘输入获取数据包
                Scanner sc = new Scanner(System.in);
                System.out.print("学生："); //提示,且不换行
                String str = sc.next();

                /*//学生说了byebye，老师端就下线了，但是学生端还没下线呢
                //所以要：
                if (str.equals("byebye")){
                    System.out.println("学生也下线。。。");
                    break;
                }//运行后发现，学生端下线了，但是老师端没有正常下线
                 //原因：这段if判断的代码加错地方了，应该加在发送数据的代码后面*/

                byte[] bytes = str.getBytes(); //将String转为字节数组
            /*
            需要四个参数：
            1.指的是传送数据转为字节数组
            2.字节数组的长度
            3.封装接收方的ip
            4.指定接收方的端口号
            */
                DatagramPacket dp = new DatagramPacket(bytes,bytes.length, InetAddress.getByName("localhost"),9999);
                //要求传入的参数为：(byte[] buf, int length, InetAddress address,int port)

                //然后发送： —— 利用套接字进行发送
                ds.send(dp); //有异常 ，则继续追加

                //学生说了byebye，老师端就下线了，但是学生端还没下线呢
                //所以要：
                if (str.equals("byebye")){
                    System.out.println("学生也下线。。。");
                    break;
                }//运行后发现，学生端下线了，但是老师端没有正常下线
                //原因：这段if判断的代码加错地方了，应该加在发送数据的代码后面

                //双向通信！！！

                //学生接收老师发送回来的信息：
                //同理，准备一个空的数据包，打算用来接收 对方(老师)传过来的数据包
                byte[] b = new byte[1024];
                DatagramPacket dp2 = new DatagramPacket(b,b.length); //传入空的数组
                //接收对方的数据包，然后放入我们的dp数据包中填充
                ds.receive(dp2); //接收完以后,dp里面就填充好内容了

                //4、取出数据
                byte[] data = dp2.getData(); // dp.getData()的返回值是字节数组
                //String s = new String(data);//将data字节数组转为字符串
                //取出数组包中的有效数据，dp.getLength() — 数组包中的有效长度
                String s = new String(data,0,dp2.getLength());
                System.out.println("老师对我说："+s);
            }
            
        } catch (SocketException e) {
            e.printStackTrace();
        } catch (UnknownHostException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //关闭资源
            ds.close();
        }
    }
}

接收方：

package test9_UDP_4_complete_communication;

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

/**
 * @Auther: zhoulz
 * @Description: test6_UDP_1 —— 分解2：双向通信
 * @version: 1.0
 */
public class TestReceive {//接收方

    public static void main(String[] args) {
        System.out.println("老师上线了。。。");
        //1、创建套接字：指定接收方的端口
        DatagramSocket ds = null;
        try {
            ds = new DatagramSocket(9999);

            while (true){ //同样，加一个死循环
                //同样，把下面的代码剪切到try中来
                //2、有一个空的数据包，打算用来接收 对方传过来的数据包
                byte[] b = new byte[1024];
                DatagramPacket dp = new DatagramPacket(b,b.length); //传入空的数组
                //3.接收对方的数据包，然后放入我们的dp数据包中填充
                ds.receive(dp); //接收完以后,dp里面就填充好内容了

                //4、取出数据
                byte[] data = dp.getData(); // dp.getData()的返回值是字节数组
                //String s = new String(data);//将data字节数组转为字符串
                //取出数组包中的有效数据，dp.getLength() — 数组包中的有效长度
                String s = new String(data,0,dp.getLength());
                System.out.println("学生对我说："+s);

                //如果学生说了byebye，老师端则就终止会话
                if (s.equals("byebye")){
                    System.out.println("学生已经下线了，老师也下线。。。");
                    break;
                }

                //双向通信！！！

                //老师进行回复：
                //准备数据包
                //同样从 键盘输入获取数据包
                Scanner sc= new Scanner(System.in);
                System.out.print("老师：");
                String str = sc.next();//提示,且不换行
                byte[] bytes = str.getBytes(); //将String转为字节数组
                //封装数据，并且指定学生的ip和端口号
                DatagramPacket dp2 = new DatagramPacket(bytes,bytes.length, InetAddress.getByName("localhost"),8888);
                //发送：
                ds.send(dp2);
            }

        } catch (SocketException e) {
            e.printStackTrace();
        } catch (UnknownHostException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //5、关闭资源
            ds.close();
        }
    }
}
哆啦A梦的_梦
关注
专栏目录
linux网络编程-宋敬彬-part1
03-03
目 录 第1篇 Linux网络开发基础 第1章 Linux操作系统概述 2 1.1 Linux发展历史 2 1.1.1 Linux的诞生和发展 2 ...第10章 基于UDP协议的接收和发送 267 10.1 UDP编程框架 267 10.1.1 UDP编程框图 267
Java 网络编程UDP协议之发送数据和接收数据的详解
路宇的博客
11-26 6940
UDP协议： 用户数据报协议(User Datagram Protocol) UDP是无连接通信协议，即在数据传输时，数据的发送端和接收端不建立逻辑连接。简单来说，当一个台计算机向另外一台计算机发送数据时，发送端不会确认接收端是否存在，就会发出数据，同样接收端在收到数据时，也不会向发送端反馈是否收到数据。由于使用UDP协议消耗资源少，通信效率高，所以通常都会用于音频，视频和普通数据的传输。 例如视频会议通常会采用UDP协议，因为这种情况偶尔丢一两个数据包，也不会对接收结果产生太大影响，但是在使用UDP协议
Java笔记（10）网络编程
m0_62567916的博客
02-16 450
1 理解网络编程 （1）计算机网络：是指将地理位置不同的具有独立功能的多台计算机及其外部设备，通过通信线路来连接起来，在网络操作系统，网络管理软件及网络通信协议的管理和协调下，实现资源共享和信息传递的计算机系统。 （2）网络编程：在网络通信协议下，不同计算机上运行的程序，可以进行数据传输。 2 网络编程三要素 ★ip地址：设备的唯一标识 IPv4：给每一个连接在网络上的主机分配一个32bit地址。按照TCP/IP规定，IP地址用二进制来表示，每个IP地址长32bit（4个字节)，但二进制写起来太麻
网络编程Socket
最新发布
qq_58631644的博客
10-17 364
网络三要素：ip，端口，协议TCP保证接收，UDP不管是否接收到，是不可靠协议。
DatagramSocket.receive()方法无响应的解决
Larry Sora
01-18 1万+
之前看网上说用发送命令行的方式获取客户端的mac地址，具体方法不复述了。 其中用到这个receive()方法，朋友在测试的时候发现会无响应，发现是window的系统防火墙开启以后出现的。 无法保证每个用户都是关闭系统防火墙的，所以看了一下api，发现一个解决方法。 直接贴代码看吧 DatagramSocket ds=new DatagramSocket(); DatagramP
JAVA网络编程
07-18
Java网络编程涉及多种技术，包括TCP和UDP协议的选择、基于URL的网络访问等。选择合适的协议和方法能够有效提高程序的性能和用户体验。理解这些基本概念和技术细节对于开发高效稳定的网络应用程序至关重要。
关于VC++基于H263视频传输的程序
06-22
在本文中，我们将深入探讨...总的来说，基于VC++的H263视频传输程序开发涵盖了多媒体处理、网络通信、编码解码等多个领域，需要综合运用多种技术和工具。通过不断学习和实践，你可以构建出高效、稳定的视频通信系统。
Udp Send(发送端)与Receive(接收端) 基本原理
Enjoy life,Enjoy coding!!
01-09 8116
package com.mth.udp; import java.net.DatagramPacket; import java.net.DatagramSocket; import java.net.InetAddress; import java.net.SocketException; /* * UdpSend * 需求：通过udp传输方式 将一段文字数据发送出去 * 步骤：
UDP的广播实例
清欢Viki的博客
03-20 628
运行环境 IDEA 目录结构 MessageCreator 数据构造器，用于信息发送的数据格式化 UDPProvider 用于提供数据，即广播的接收者 UDPSearcher 用于搜索支持方，即广播发送者 MessageCreator类 public class MessageCreator { //发送数据包的头部 private s...
网络编程中的两种传输方式
qq_42155078的博客
03-09 470
方式1：UDP网络传输 需求：通过ip与端口号进行数据传输，在传输过程中有一方输入“bye”则结束数据传输。 SendMessages； public static void main(String[] args) throws Exception{ DatagramSocket ds = new DatagramSocket(9999); Scanner sc = new Scanner(System.in); while(true){
Socket套接字之UDP网络编程 单向 双向 异常处理 基于UDP实现两人正常通信
SKPrimin的博客
08-12 579
Socket套接字之UDP网络编程 单向 双向 异常处理 套接字(Socket) 用来描述IP地址和端口，是通信链的句柄，应用程序通过Socket向网络发送请求或者应答网络请求 是支持TCP/IP协议的网络通信的基本操作单元， 是对网络中不同主机上的应用进程之间进行双向通信的端点的抽象，内含五种信息：连接使用的协议，本机IP即进程接口PORT，远程主机IP及进程接口PORT。 一个套接字就是网络上进程通信的一端，提供了应用层进程利用网络协议交换数据的机制。 从所处的地位来讲，套接字上联应用进程，下联网络协
在Java中实现UDP协议编程（DatagramSocket/DatagramPacket）
热门推荐
redarmychen的专栏
10-16 4万+
1.什么是UDP协议？ UDP( User Datagram Protocol )协议是用户数据报，在网络中它与TCP协议一样用于处理数据包。在OSI模型中，在第四层——传输层，处于IP协议的上一层。 UDP是一种无连接的协议，每个数据报都是一个独立的信息，包括完整的源或目的地址，它在网络上以任何可能的路径传往目的地，因此能否到达目的地，到达目的地的时间以及内容的正确性都是不能被保证的。
UDP协议中的用法
yinbucheng的博客
04-03 338
/**创建UDP传输的发送端 *思路: *1.建立udp的socket服务 *2.将要发送的数据封装到数据包中 *3.通过udp的socket服将数据包发送出去 *4.关闭socket服务 */ public class Send implements Runnable{   private DatagramSocket ds;       pubic Send(Da
UDP发送数据和接收数据
云飞扬°的博客
05-08 1万+
UDP发送数据和接收数据 1.发送数据 步骤： 创建发送端Socket对象 创建数据并打包 发送数据 释放资源 package com.itheima; import java.io.IOException; import java.net.DatagramPacket; import java.net.DatagramSo...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值