Java中的DatagramPacket与DatagramSocket的初步

简介:
 

1.基本概念:

  a.DatagramPacket与DatagramSocket位于java.net包中

  b.DatagramPacket表示存放数据的数据报,DatagramSocket表示接受或发送数据报的套接字

  c.由这两个类所有构成的网络链接是基于UDP协议,是一种不可靠的协议。

  之所以不可靠是因为发送方不负责数据是否发送成功,接收方收到数据时也不会   向发送方反馈成功消息,容易导致信息的丢失。

  但是这种协议却是快捷的,比如CS(半条命)游戏就是基于UDP协议,否则我们估计   要玩一次游戏后就会把机子砸了,所以我们可以看到游戏有时会失帧。

  2.使用方法:

  要建立基于UDP协议的链接,我们应该先建立套接字<DatagramSocket>(即发送站或接收站),之后通过套接字发送或接受数据<DatagramPacket>。

  我们先了解一下DatagramSocket和DatagramPacket类

  DatagramSocket类:

  构造方法:

  DatagramSocket():

  表示创建一个默认的套接字,并绑定到本地地址和一个随机的端口号

  DatagramSocket(int port):

  与上面不同的是,绑定到特定端口号,其它不变

  DatagramSocket(int port, InetAddress iad):

  表示创建一个套接字,绑定到特定的端口号及指定地址

  DatagramSocket(SocketAddress sad);

  表示创建一个套接字,绑定到特定的套接字地址

  小提示:所谓的本地地址我们可以这样来理解,我们通过“控制面板-本地连接-支持”中可以看到一个IP地址,这就是本地的IP地址,也暂且理解为本地地址。

  基本方法:

  close():

  关闭套接字

  recevie(DatagramPacket dp):

  接受数据报

  send(DatagramPacket dp):

 发送数据报

  这里触及了数据报,下面介绍数据报:

  DatagramPacket类:

  构造方法:(只列出主要的)

  接受类型:

  DatagramPacket(byte[] buf, int length):

  用来接受长度为length的buf数据(即数据存于字节数组buf中)

  发送类型:

  DatagramPacket(byte[] buf, int length, InetAddress address, int port);

  将length长的buf数据发送到指定的地址的端口号处

  DatagramPacket(byte[] buf, int length, SocketAddress address);

   将length长的buf数据发送到指定的套接字地址处

  有上面可知,我们发送数据时构造的数据报应该是发送类型的,而接受数据报时应该是接受类型的    

  开始书写代码

  代码意图:

  1.一个接收方,一个发送方

  2.当接收方收到发送方发送的消息后,打印发送的消息及发送方的地址和端口号,之后向发送反馈一条信息“接受方:我收到了!”

  3.发送方打印出接收方反馈的消息

  详细思路见代码:

  1. import java.net.DatagramPacket;  
  2. import java.net.DatagramSocket;  
  3. import java.net.InetAddress;  
  4.   
  5. public class Sender {  
  6.     public static void main(String[] args) {  
  7.         try {  
  8.             // 创建发送方的套接字,IP默认为本地,端口号随机   
  9.             DatagramSocket sendSocket = new DatagramSocket();  
  10.   
  11.             // 确定要发送的消息:   
  12.             String mes = "你好!接收方!";  
  13.   
  14.             // 由于数据报的数据是以字符数组传的形式存储的,所以传转数据   
  15.             byte[] buf = mes.getBytes();  
  16.   
  17.             // 确定发送方的IP地址及端口号,地址为本地机器地址   
  18.             int port = 8888;  
  19.             InetAddress ip = InetAddress.getLocalHost();  
  20.   
  21.             // 创建发送类型的数据报:   
  22.             DatagramPacket sendPacket = new DatagramPacket(buf, buf.length, ip,  
  23.                     port);  
  24.   
  25.             // 通过套接字发送数据:   
  26.             sendSocket.send(sendPacket);  
  27.   
  28.             // 确定接受反馈数据的缓冲存储器,即存储数据的字节数组   
  29.             byte[] getBuf = new byte[1024];  
  30.   
  31.             // 创建接受类型的数据报   
  32.             DatagramPacket getPacket = new DatagramPacket(getBuf, getBuf.length);  
  33.   
  34.             // 通过套接字接受数据   
  35.             sendSocket.receive(getPacket);  
  36.   
  37.             // 解析反馈的消息,并打印   
  38.             String backMes = new String(getBuf, 0, getPacket.getLength());  
  39.             System.out.println("接受方返回的消息:" + backMes);  
  40.   
  41.             // 关闭套接字   
  42.             sendSocket.close();  
  43.         } catch (Exception e) {  
  44.             e.printStackTrace();  
  45.         }  
  46.   
  47.     }  
  48. }  
  49.   
  50.   
  51.   
  52. import java.net.DatagramPacket;  
  53. import java.net.DatagramSocket;  
  54. import java.net.InetAddress;  
  55. import java.net.SocketAddress;  
  56.   
  57. public class Receive {  
  58.     public static void main(String[] args) {  
  59.         try {  
  60.             // 确定接受方的IP和端口号,IP地址为本地机器地址   
  61.             InetAddress ip = InetAddress.getLocalHost();  
  62.             int port = 8888;  
  63.   
  64.             // 创建接收方的套接字,并制定端口号和IP地址   
  65.             DatagramSocket getSocket = new DatagramSocket(port, ip);  
  66.   
  67.             // 确定数据报接受的数据的数组大小   
  68.             byte[] buf = new byte[1024];  
  69.   
  70.             // 创建接受类型的数据报,数据将存储在buf中   
  71.             DatagramPacket getPacket = new DatagramPacket(buf, buf.length);  
  72.   
  73.             // 通过套接字接收数据   
  74.             getSocket.receive(getPacket);  
  75.   
  76.             // 解析发送方传递的消息,并打印   
  77.             String getMes = new String(buf, 0, getPacket.getLength());  
  78.             System.out.println("对方发送的消息:" + getMes);  
  79.   
  80.             // 通过数据报得到发送方的IP和端口号,并打印   
  81.             InetAddress sendIP = getPacket.getAddress();  
  82.             int sendPort = getPacket.getPort();  
  83.             System.out.println("对方的IP地址是:" + sendIP.getHostAddress());  
  84.             System.out.println("对方的端口号是:" + sendPort);  
  85.   
  86.             // 通过数据报得到发送方的套接字地址   
  87.             SocketAddress sendAddress = getPacket.getSocketAddress();  
  88.   
  89.             // 确定要反馈发送方的消息内容,并转换为字节数组   
  90.             String feedback = "接收方说:我收到了!";  
  91.             byte[] backBuf = feedback.getBytes();  
  92.   
  93.             // 创建发送类型的数据报   
  94.             DatagramPacket sendPacket = new DatagramPacket(backBuf,  
  95.                     backBuf.length, sendAddress);  
  96.   
  97.             // 通过套接字发送数据   
  98.             getSocket.send(sendPacket);  
  99.   
  100.             // 关闭套接字   
  101.             getSocket.close();  
  102.         } catch (Exception e) {  
  103.             e.printStackTrace();  
  104.         }  
  105.     }  
  106. }  
import java.net.DatagramPacket; import java.net.DatagramSocket; import java.net.InetAddress; public class Sender { public static void main(String[] args) { try { // 创建发送方的套接字,IP默认为本地,端口号随机 DatagramSocket sendSocket = new DatagramSocket(); // 确定要发送的消息: String mes = "你好!接收方!"; // 由于数据报的数据是以字符数组传的形式存储的,所以传转数据 byte[] buf = mes.getBytes(); // 确定发送方的IP地址及端口号,地址为本地机器地址 int port = 8888; InetAddress ip = InetAddress.getLocalHost(); // 创建发送类型的数据报: DatagramPacket sendPacket = new DatagramPacket(buf, buf.length, ip, port); // 通过套接字发送数据: sendSocket.send(sendPacket); // 确定接受反馈数据的缓冲存储器,即存储数据的字节数组 byte[] getBuf = new byte[1024]; // 创建接受类型的数据报 DatagramPacket getPacket = new DatagramPacket(getBuf, getBuf.length); // 通过套接字接受数据 sendSocket.receive(getPacket); // 解析反馈的消息,并打印 String backMes = new String(getBuf, 0, getPacket.getLength()); System.out.println("接受方返回的消息:" + backMes); // 关闭套接字 sendSocket.close(); } catch (Exception e) { e.printStackTrace(); } } } import java.net.DatagramPacket; import java.net.DatagramSocket; import java.net.InetAddress; import java.net.SocketAddress; public class Receive { public static void main(String[] args) { try { // 确定接受方的IP和端口号,IP地址为本地机器地址 InetAddress ip = InetAddress.getLocalHost(); int port = 8888; // 创建接收方的套接字,并制定端口号和IP地址 DatagramSocket getSocket = new DatagramSocket(port, ip); // 确定数据报接受的数据的数组大小 byte[] buf = new byte[1024]; // 创建接受类型的数据报,数据将存储在buf中 DatagramPacket getPacket = new DatagramPacket(buf, buf.length); // 通过套接字接收数据 getSocket.receive(getPacket); // 解析发送方传递的消息,并打印 String getMes = new String(buf, 0, getPacket.getLength()); System.out.println("对方发送的消息:" + getMes); // 通过数据报得到发送方的IP和端口号,并打印 InetAddress sendIP = getPacket.getAddress(); int sendPort = getPacket.getPort(); System.out.println("对方的IP地址是:" + sendIP.getHostAddress()); System.out.println("对方的端口号是:" + sendPort); // 通过数据报得到发送方的套接字地址 SocketAddress sendAddress = getPacket.getSocketAddress(); // 确定要反馈发送方的消息内容,并转换为字节数组 String feedback = "接收方说:我收到了!"; byte[] backBuf = feedback.getBytes(); // 创建发送类型的数据报 DatagramPacket sendPacket = new DatagramPacket(backBuf, backBuf.length, sendAddress); // 通过套接字发送数据 getSocket.send(sendPacket); // 关闭套接字 getSocket.close(); } catch (Exception e) { e.printStackTrace(); } } }

 

测试已通过

  先启动接收方,然后启动发送方即可

相关文章
|
Java
java中DatagramSocket连续发送多个数据报包时产生丢包现象解决方案
1 try { 2 //向指定的ip和端口发送数据~! 3 //先说明一下数据是谁发送过来的! 4 byte[] ip = InetAddress.
837 0
|
存储 Java
Java中的DatagramPacket与DatagramSocket的初步
转自:http://blog.csdn.net/pengchua/article/details/4398972 1.基本概念:   a.DatagramPacket与DatagramSocket位于java.net包中   b.DatagramPacket表示存放数据的数据报,DatagramSocket表示接受或发送数据报的套接字   c.由这两个类所有构成的网络链接是基于UDP协议,是一种不可靠的协议。
844 0
|
13天前
|
安全 算法 Java
深入理解Java并发编程:线程安全与性能优化
【4月更文挑战第11天】 在Java中,高效的并发编程是提升应用性能和响应能力的关键。本文将探讨Java并发的核心概念,包括线程安全、锁机制、线程池以及并发集合等,同时提供实用的编程技巧和最佳实践,帮助开发者在保证线程安全的前提下,优化程序性能。我们将通过分析常见的并发问题,如竞态条件、死锁,以及如何利用现代Java并发工具来避免这些问题,从而构建更加健壮和高效的多线程应用程序。
|
1天前
|
安全 Java 调度
Java线程:深入理解与实战应用
Java线程:深入理解与实战应用
11 0
|
1天前
|
Java
Java中的并发编程:理解和应用线程池
【4月更文挑战第23天】在现代的Java应用程序中,性能和资源的有效利用已经成为了一个重要的考量因素。并发编程是提高应用程序性能的关键手段之一,而线程池则是实现高效并发的重要工具。本文将深入探讨Java中的线程池,包括其基本原理、优势、以及如何在实际开发中有效地使用线程池。我们将通过实例和代码片段,帮助读者理解线程池的概念,并学习如何在Java应用中合理地使用线程池。
|
5天前
|
安全 Java
深入理解 Java 多线程和并发工具类
【4月更文挑战第19天】本文探讨了Java多线程和并发工具类在实现高性能应用程序中的关键作用。通过继承`Thread`或实现`Runnable`创建线程,利用`Executors`管理线程池,以及使用`Semaphore`、`CountDownLatch`和`CyclicBarrier`进行线程同步。保证线程安全、实现线程协作和性能调优(如设置线程池大小、避免不必要同步)是重要环节。理解并恰当运用这些工具能提升程序效率和可靠性。
|
6天前
|
安全 Java
java多线程(一)(火车售票)
java多线程(一)(火车售票)
|
6天前
|
安全 Java 调度
Java并发编程:深入理解线程与锁
【4月更文挑战第18天】本文探讨了Java中的线程和锁机制,包括线程的创建(通过Thread类、Runnable接口或Callable/Future)及其生命周期。Java提供多种锁机制,如`synchronized`关键字、ReentrantLock和ReadWriteLock,以确保并发访问共享资源的安全。此外,文章还介绍了高级并发工具,如Semaphore(控制并发线程数)、CountDownLatch(线程间等待)和CyclicBarrier(同步多个线程)。掌握这些知识对于编写高效、正确的并发程序至关重要。