devbox
木道寻08
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

JAVA网络编程（二）：UDP编程_java udp报文解析成对象

作者：木道寻08 | 2024-07-19 09:41:08

赞

踩

java udp报文解析成对象

目录

什么是UDP？

UDP特点

UDP编程核心类

UDP编程

1、基本通信

2、基本类型数据通信

3、对象类型数据通信

4、文件类型通信

5、多次通信

6、双向通信

什么是UDP？

UDP（User Datagram Protocol）用户数据报协议，为应用程序提供了一种无需建立连接就可以发送封装的 IP 数据报的方法。

UDP特点

  1. 非面向连接，即通讯前不需要建立连接
  2. 高效
  3. 不可靠，可能存在丢包
  4. 大小有限制，一般来是数据包大小不要超过60K
  5. 不存在客户端与服务器的概念，每个端都是平等的
  6. JAVA编程中，将数据封装到DatagramPacket，指定目标地址进行数据传输

UDP编程核心类

DatagramSocket：该类表示用于发送/接收数据包的套接字

DatagramPacket：该类表示被传输的数据包

UDP编程

UDP编程可以概括为以下几步

发送端

  1. 创建发送端：DatagramSocket(int port)对象
  2. 准备数据，转为字节数组
  3. 将字节数组封装为数据报包：DatagramPacket(byte[] buf, int offset, int length, SocketAddress address)对象
  4. 发送/接收数据
  5. 释放资源

接收端

  1. 创建接收端：DatagramSocket(int port)对象
  2. 准备容器，封装为DatagramPacket包：DatagramPacket(byte[] buf, int offset, int length)对象
  3. 阻塞式接收包
  4. 解析包
  5. 释放资源

1、基本通信

发送端

  1. public class UdpSender {
  2.     public static void main(String[] args) throws Exception  {
  3.         // 1、指定端口，创建发送端
  4.         DatagramSocket client = new DatagramSocket(8888);
  5.  
  6.         // 2、准备数据，转成字节数组
  7.         String str = "Hello World!你好";
  8.         byte[] datas = str.getBytes();
  9.  
  10.         // 3、将字节数组封装成包，
  11.         // 发送端构造方法传递 ——> 
  12.         // 数据字节数组，起始位置，长度，IP套接字地址（接收端的ip/主机 + 端口）
  13.         DatagramPacket packet = new DatagramPacket(datas, 0, datas.length,
  14.             new InetSocketAddress("localhost", 9999));
  15.  
  16.         // 4、发送数据
  17.         client.send(packet);
  18.  
  19.         // 5、释放资源
  20.         client.close();
  21.     }
  22. }

接收端

  1. public class UdpReceiver {
  2.     public static void main(String[] args) throws Exception {
  3.         // 1、指定端口，创建接收端，此处的端口应对应发送端数据包传递的端口
  4.         DatagramSocket server = new DatagramSocket(9999);
  5.  
  6.         // 2、准备容器，封装成DatagramPacket包
  7.         byte[] contanier = new byte[60*1024]; // 60K
  8.         // 接收端的数据包不用传递IP套接字地址
  9.         DatagramPacket packet = new DatagramPacket(contanier, 0, contanier.length);
  10.  
  11.         // 3、阻塞式接收包，会一直等待数据包
  12.         System.out.println("等待接收");
  13.         server.receive(packet);
  14.         System.out.println("接收到数据包，进行解析");
  15.  
  16.         // 4、解析包
  17.         byte[] datas = packet.getData(); // 字节数组
  18.         int len = packet.getLength(); // 长度
  19.         System.out.println(new String(datas));
  20.         System.out.println(len);
  21.  
  22.         // 5、释放资源
  23.         server.close();
  24.     }
  25. }

接收端控制台

2、基本类型数据通信

与基本通信相同，唯一需要改动的部分就是发送端的数据转字节数组，接收端的字节数组转数据

发送端

  1. // 1、指定端口，创建发送端
  2.  
  3. // 2、准备基本类型数据，转成字节数组
  4. // ByteArrayOutputStream 用于将数据转为字节数组
  5. // BufferedOutputStream 用于缓冲，提升效率
  6. // DataOutputStream 用于将基本类型数据写入输出流
  7. ByteArrayOutputStream baos = new ByteArrayOutputStream();
  8. DataOutputStream dos = new DataOutputStream(new BufferedOutputStream(baos));
  9.  
  10. dos.writeInt(1);
  11. dos.writeChar('a');
  12. dos.writeBoolean(true);
  13. dos.writeFloat(1.2f);
  14. dos.flush(); // 调用flush()将缓冲区数据输出
  15.  
  16. byte[] datas = baos.toByteArray();
  17.  
  18. // 3、将字节数组封装成包
  19. // 4、发送数据
  20. // 5、释放资源

接收端

  1. // 1、指定端口，创建接收端
  2. // 2、准备容器，封装成DatagramPacket包
  3. // 3、阻塞式接收包
  4.  
  5. // 4、解析基本类型
  6. // ByteArrayInputStream 获取传递过来的输入流
  7. // BufferedInputStream 用于缓冲提升效率
  8. // DataInputStream 用于读取输入流中的基本数据类型
  9. ByteArrayInputStream bais = new ByteArrayInputStream(packet.getData());
  10. DataInputStream dis = new DataInputStream(new BufferedInputStream(bais));
  11.  
  12. // 取值顺序应和写入顺序一致
  13. System.out.println(dis.readInt());
  14. System.out.println(dis.readChar());
  15. System.out.println(dis.readBoolean());
  16. System.out.println(dis.readFloat());
  17.  
  18. // 5、释放资源

接收端控制台

3、对象类型数据通信

对象要能够被传输，必须实现Serializable接口，最好提供一个serialVersionUID

Person.java

  1. public class Person implements Serializable {
  2.     private static final long serialVersionUID = -3201672726868875942L;
  3.  
  4.     private String name;
  5.     private transient int age; // 使用transient修饰的属性不会被序列化传输
  6.  
  7.     public String getName() {
  8.         return name;
  9.     }
  10.  
  11.     // get/set/constructor方法省略
  12. }

发送端

  1. // 1、指定端口，创建发送端
  2.  
  3. // 2、准备对象类型数据，转成字节数组
  4. ByteArrayOutputStream baos = new ByteArrayOutputStream();
  5. ObjectOutputStream oos = new ObjectOutputStream(new BufferedOutputStream(baos));
  6.  
  7. oos.writeObject(new Person("IcyDate", 18));
  8. oos.flush();
  9.  
  10. byte[] datas = baos.toByteArray();
  11.  
  12. // 3、将字节数组封装成包
  13. // 4、发送数据
  14. // 5、释放资源

接收端

  1. // 1、指定端口，创建接收端，此处的端口应对应发送端发送数据指定的端口
  2. // 2、准备容器，封装成DatagramPacket包
  3. // 3、阻塞式接收包
  4.  
  5. // 4、解析对象类型，取值顺序应和写入顺序一致
  6. ByteArrayInputStream bais = new ByteArrayInputStream(packet.getData());
  7. ObjectInputStream ois = new ObjectInputStream(new BufferedInputStream(bais));
  8.  
  9. Object obj = ois.readObject();
  10. Person person = null;
  11. if (obj instanceof Person) {
  12.     person = (Person) obj;
  13. }
  14.  
  15. System.out.println("name----->" + person.getName());
  16. System.out.println("age----->" + person.getAge());
  17.  
  18. // 5、释放资源

接收端控制台

4、文件类型通信

文件在发送端首先使用FileInputStream读取，再写入ByteArrayOutputStrem并转为字节数组

发送端

  1. // 1、指定端口，创建发送端
  2.  
  3. // 2、准备基本类型数据，转成字节数组
  4. File file = new File("src/test/1.png"); // 文件大小不超过接收端容器大小
  5. FileInputStream fis = new FileInputStream(file); // 也可直接传递文件地址
  6. ByteArrayOutputStream baos = new ByteArrayOutputStream();
  7.  
  8. // flush代表每次读取和写入的大小，10K
  9. byte[] flush = new byte[1024*10];
  10. int len = -1;
  11. // 文件输入流读取最多flush.length字节的数据到字节数组，读取完毕返回-1
  12. while ((len = fis.read(flush)) != -1) {
  13.     // 往字节输出流中写入读取出的数据
  14.     baos.write(flush, 0, len);
  15. }
  16.  
  17. byte[] datas = baos.toByteArray();
  18.  
  19. // 3、将字节数组封装成包
  20. // 4、发送数据
  21. // 5、释放资源

接收端

  1. // 1、指定端口，创建接收端，此处的端口应对应发送端发送数据指定的端口
  2. // 2、准备容器，封装成DatagramPacket包
  3. // 3、阻塞式接收包
  4.  
  5. // 4、解析基本类型，取值顺序应和写入顺序一致
  6. ByteArrayInputStream bais = new ByteArrayInputStream(packet.getData());
  7.  
  8. File file = new File("src/test/copy.png"); // 需要写入的文件路径
  9. FileOutputStream fos = new FileOutputStream(file);
  10.  
  11. byte[] flush = new byte[5];
  12. int len = -1;
  13. // 从数据包中的输入流里读取并写入文件输出流
  14. while ((len = bais.read(flush)) != -1) {
  15.     fos.write(flush, 0, len);
  16. }
  17. fos.flush();
  18.  
  19.  
  20. // 5、释放资源

5、多次通信

之前的例子都是单次的通信，多次通信只需要发送端循环接收控制台输入并发送，接收端循环接收数据包并解析即可

发送端

  1. // 1、指定端口，创建发送端
  2.  
  3. // 2、准备数据，转成字节数组
  4. BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
  5. while (true) {
  6.     String str = br.readLine(); // 接收控制台输入
  7.     byte[] datas = str.getBytes();
  8.  
  9.     // 3、将字节数组封装成包
  10.     DatagramPacket packet = new DatagramPacket(datas, 0, datas.length,
  11.             new InetSocketAddress("localhost", 9999));
  12.  
  13.     // 4、发送数据
  14.     client.send(packet);
  15.     if ("bye".equals(str)) {
  16.         break;
  17.     }
  18. }
  19.  
  20. // 5、释放资源

接收端

  1. // 1、指定端口，创建接收端，此处的端口应对应发送端发送数据指定的端口
  2.  
  3. // 2、准备容器，封装成DatagramPacket包
  4. while (true) {
  5.     byte[] contanier = new byte[60*1024];
  6.     DatagramPacket packet = new DatagramPacket(contanier, 0, contanier.length);
  7.  
  8.     // 3、阻塞式接收包
  9.     server.receive(packet);
  10.  
  11.     // 4、解析包
  12.     byte[] datas = packet.getData();
  13.     int len = packet.getLength();
  14.     String msg = new String(datas, 0, len);
  15.     System.out.println(msg);
  16.  
  17.     if ("bye".equals(msg)) {
  18.         break;
  19.     }
  20. }
  21.  
  22. // 5、释放资源

6、双向通信

双向通信要求每一端，既能发送数据，也能接收数据。那就需要一个线程来执行发送端，一个线程执行接收端。也就需要我们把发送端和接受端封装成两个类并实现Runnable接口

发送端

  1. public class UdpSender implements Runnable{
  2.     private DatagramSocket client;
  3.     private BufferedReader br;
  4.  
  5.     private String toIP;
  6.     private int toPort;
  7.  
  8.     private String sender;
  9.  
  10.     // 用构造方法来指定发送端端口，接收端ip+端口，和发送人
  11.     UdpSender(int port, String toIP, int toPort, String sender) {
  12.         this.toIP = toIP;
  13.         this.toPort = toPort;
  14.         this.sender = sender;
  15.  
  16.         try {
  17.             client = new DatagramSocket(port);
  18.             br = new BufferedReader(new InputStreamReader(System.in));
  19.         } catch (SocketException e) {
  20.             e.printStackTrace();
  21.         }
  22.     }
  23.  
  24.     @Override
  25.     public void run() {
  26.         while (true) {
  27.             String str = null;
  28.             try {
  29.                 str = sender + "：" + br.readLine();
  30.                 byte[] datas = str.getBytes();
  31.  
  32.                 // 3、将字节数组封装成包
  33.                 DatagramPacket packet = new DatagramPacket(datas, 0, datas.length,
  34.                         new InetSocketAddress(toIP, toPort));
  35.  
  36.                 // 4、发送数据
  37.                 client.send(packet);
  38.             } catch (IOException e) {
  39.                 e.printStackTrace();
  40.             }
  41.         }
  42.  
  43.         // 5、释放资源
  44.         client.close();
  45.     }
  46. }

接收端

  1. public class UdpReceiver implements Runnable{
  2.     private DatagramSocket server;
  3.  
  4.     // 指定接收端端口
  5.     UdpReceiver(int port) {
  6.         try {
  7.             server = new DatagramSocket(port);
  8.         } catch (SocketException e) {
  9.             e.printStackTrace();
  10.         }
  11.     }
  12.  
  13.     @Override
  14.     public void run() {
  15.         // 2、准备容器，封装成DatagramPacket包
  16.         while (true) {
  17.             byte[] contanier = new byte[60*1024];
  18.             DatagramPacket packet = new DatagramPacket(contanier, 0, contanier.length);
  19.  
  20.             // 3、阻塞式接收包
  21.             try {
  22.                 server.receive(packet);
  23.                 // 4、解析包
  24.                 byte[] datas = packet.getData();
  25.                 int len = packet.getLength();
  26.                 String msg = new String(datas, 0, len);
  27.                 System.out.println(msg);
  28.             } catch (IOException e) {
  29.                 e.printStackTrace();
  30.             }
  31.         }
  32.  
  33.         // 5、释放资源
  34.         server.close();
  35.     }
  36. }

创建一个学生类和教师类，分别启动发送和接收端口

 

声明：本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：【wpsshop博客】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号