UDP连接之基本用法

最新推荐文章于 2024-07-25 22:57:00 发布

山鬼谣me

最新推荐文章于 2024-07-25 22:57:00 发布

阅读量1.1w

点赞数 5

分类专栏： Java 文章标签： java udp

本文链接：https://blog.csdn.net/u013066244/article/details/77621294

版权

Java 专栏收录该内容

176 篇文章 5 订阅

订阅专栏

环境

Java：1.7

场景

公司需要从交易所接收股票的数据，交易所那边使用的是UDP连接方式，叫我先预演下，网上找个了资料后，这里简单记录下。

分析

UDP或者TCP，无非就是发送和接收，这里不提它们的区别，只需要知道前者没有保障，后者有保障。正常情况下，一般是服务端发送，客户端来接收。
在我这场景中就是交易所是就是服务端，我公司就是客户端。

客户端

代码如下（其实是来自于极客学院，只不过我自己消化了）：

package udp;

import java.io.IOException;
import java.io.InterruptedIOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

public class ClientUDP {

    private static final int TIMEOUT = 5000;//设置接收数据超时时间
    private static final int MAXSUM = 5;//设置重发数据的次数

    public static void main(String[] args) {
        String str_send = "Hello yutao";

        byte[] buf = new byte[1024];
        try {
            //客户端在9000端口监听接收到的数据
            DatagramSocket ds = new DatagramSocket(9000);//建立了一个通信实例（socket）
            InetAddress loc = InetAddress.getLocalHost();

            //定义用来发送数据的DatagramPacket实例  
            //官方：创建一个数据包实例，将指定长度的数据发送给指定端口的指定主键上。
            DatagramPacket dp_send = new DatagramPacket(str_send.getBytes(), str_send.length(), loc, 3000);
            //定义用来接收数据的DatagramPacket实例
            //没有设置端口号，所以是接收数据，要是设置了端口号和主机就是发送数据
            DatagramPacket dp_receive = new DatagramPacket(buf, buf.length);

            //数据发向本地3000端口
            ds.setSoTimeout(TIMEOUT);
            int tries = 0;
            boolean receivedResponse = false;
            //直到接收到数据，或者重发次数达到预定值，则退出循环
            while(!receivedResponse && tries < MAXSUM){
                //发送数据
                ds.send(dp_send);

                try {
                    //接收从服务端发送来的数据
                    ds.receive(dp_receive);
                    //如果接收的数据不是来自目标地址就抛出异常
                    if(!dp_receive.getAddress().equals(loc)){
                        throw new IOException("Received packet from an umknown source");
                    }
                    //如果接收到数据。则将receivedResponse标志位改为true，从而退出循环
                    receivedResponse = true;
                } catch (InterruptedIOException e) {
                    //如果接收数据时阻塞超时，重发并减少一次重发次数
                    tries += 1;
                    System.out.println("Time out," + (MAXSUM - tries) + " more tries..." ); 
//                  e.printStackTrace();
                }
            }

            if(receivedResponse){
                //如果收到数据，则打印出来
                System.out.println("client received data from server：");

                String str_receive = new String(dp_receive.getData(),0,dp_receive.getLength()) +
                                                " from " + dp_receive.getAddress().getHostAddress() + ":" +
                                                dp_receive.getPort();

                System.out.println(str_receive);

                //由于dp_receive在接收了数据之后，其内部消息长度值会变为实际接收的消息的字节数，  
                //所以这里要将dp_receive的内部消息长度重新置为1024 
                dp_receive.setLength(1024);
            }else{
                //如果重发MAXNUM次数据后，仍未获得服务器发送回来的数据，则打印如下信息  
                System.out.println("No response -- give up.");
            }
            ds.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

讲解：客户方既可以接收数据也可以用来发送数据。

我们知道实现数据通信在开发层面来说，就是用socket；作为客户方，我们首先需要在本机建立一个socket类，并且要指定端口。通俗点就是通过哪个门来接收或者发送数据。建立通信的基础有了，接着我们需要对数据进行打包（即数据包），在java中可以使用DatagramPacket来定义数据包，之后就依靠socket把数据包，发送出去或者通过socket接收数据。通信完毕后，调用相关close方法关闭通信。

以下是我自己画的思维导图
思维导图1

从代码层面来看：

第一步：创建本地socket，并设置相关端口（用来监听接收数据的端口）。

//写法一
DatagramSocket s = new DatagramSocket(null); 
s.bind(new InetSocketAddress(8888)); 

//写法二、和上面是等效的
DatagramSocket s = new DatagramSocket(8888); 

上面两个方法是等效的，都是创建一个`DatagramSocket`并通过端口号为`8888`来接收广播。
Both cases will create a DatagramSocket able to receive broadcasts on UDP port 8888.

第二部：创建DatagramPacket，这个方法有点意思：

//定义用来发送数据的DatagramPacket实例  
//官方：创建一个数据包实例，将指定长度的数据发送给指定端口的指定主键上。
DatagramPacket dp_send = new DatagramPacket(str_send.getBytes(), str_send.length(), loc, 3000);
//定义用来接收数据的DatagramPacket实例
//没有设置端口号，所以是接收数据，要是设置了端口号和主机就是发送数据
DatagramPacket dp_receive = new DatagramPacket(buf, buf.length);

1)当你构造时，指定了目标主机和端口，那么创建出的对象就是用来发送的数据包。
2)当你构造时，没有指定目标主机和端口，那么创建出来的对象就是用来接收数据的。

第三步：
①假设你要发送数据的话：ds.send(dp_send);这样数据就发送出去啦！
②假设你要接收数据的话：ds.receive(dp_receive);这个方法要是没有接收到数据就会产生阻塞，所以你需要设置超时时间ds.setSoTimeout(TIMEOUT);

通信完毕后，ds.close();关闭通信。

至此一次通信结束。

服务端

package udp;

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

public class ServiceUDP {
    public static void main(String[] args) {
        String str_send = "Hello UDPClient";
        byte[] buf = new byte[1024];
        try {
            //服务端在3000端口监听接收数据
            //首先建立一个通信（socket）实例
            DatagramSocket ds = new DatagramSocket(3000);
            //接收从客户端发送过来的数据
            //创建数据包（没有包含端口和IP，所以是接收）
            //事实上，其包含远程客户端的IP地址和端口
            DatagramPacket dp_receive = new DatagramPacket(buf, buf.length);
            System.out.println("server is on，waiting for client to send data......");

            boolean f = true;
            while(f){
                //服务器端接收来自客户端的数据
                ds.receive(dp_receive);
                System.out.println("server received data from client：");
                String str_receive = 
                new String(dp_receive.getData(), 0, 
                dp_receive.getLength())+ 
                " from " + 
                dp_receive.getAddress().getHostAddress() +
                 ":" + dp_receive.getPort();
                System.out.println(str_receive);

                //数据发送到客户端3000端口
                //要发送数据，所以需要指定IP和端口
                DatagramPacket dp_send = 
                new DatagramPacket(str_send.getBytes(), str_send.length(), dp_receive.getAddress(), 9000);
                ds.send(dp_send);
    //由于dp_receive在接收了数据之后，其内部消息长度值会变为实际接收的消息的字节数，  
    //所以这里要将dp_receive的内部消息长度重新置为1024
                dp_receive.setLength(buf.length);
            }
            ds.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

我自己画的思维导图：

这里写图片描述

讲解：服务端既可以发送数据也可以接收数据

首先我们创建一个socket来建立通信实例，即监听本机的哪个端口来传输数据
接着创建数据包实例，用来封装发送或者接收的数据：DatagramPacket。
和客户端一样：
①构造时没有指定主机和端口，就是接收数据包的实例
②构造时指定了主机和端口，就是发送数据包的实例

之后就依靠socket把数据包，发送出去或者通过socket接收数据。通信完毕后，调用相关close方法关闭通信。

从代码层面来看：其实和上面客户端是类似的。

接收数据的时候，可以通过dp_receive.getAddress().getHostAddress()来获取发送方的地址。

重点

//由于dp_receive在接收了数据之后，其内部消息长度值会变为实际接收的消息的字节数，  
//所以这里要将dp_receive的内部消息长度重新置为1024
dp_receive.setLength(buf.length);

我们可以看下receive方法源码：

public void receive(DatagramPacket paramDatagramPacket)
     throws IOException
   {
     synchronized (dc.blockingLock()) {
      if (!dc.isBlocking())
         throw new IllegalBlockingModeException();
      try {
        synchronized (paramDatagramPacket) {
          ByteBuffer localByteBuffer = ByteBuffer.wrap(paramDatagramPacket.getData(), paramDatagramPacket.getOffset(), paramDatagramPacket.getLength());


          SocketAddress localSocketAddress = receive(localByteBuffer);
          paramDatagramPacket.setSocketAddress(localSocketAddress);
          //注意下面，这就是为什么要重新设置长度的原因
          paramDatagramPacket.setLength(localByteBuffer.position() - paramDatagramPacket.getOffset());
         }
       } catch (IOException localIOException) {
         Net.translateException(localIOException);
      }
     }
   }

需要注意的地方

UDP 套接字和 TCP 套接字的一个微小但重要的差别：UDP 协议保留了消息的边界信息。

DatagramSocket 的每一次 receive()调用最多只能接收调用一次 send()方法所发送的数据，而且，不同的 receive()方法调用绝对不会返回同一个 send()方法所发送的额数据。

当在 TCP 套接字的输出流上调用 write()方法返回后，所有调用者都知道数据已经被复制到一个传输缓存区中，实际上此时数据可能已经被发送，也有可能还没有被传送，而 UDP 协议没有提供从网络错误中恢复的机制，因此，并不对可能需要重传的数据进行缓存。这就意味着，当send（）方法调用返回时，消息已经被发送到了底层的传输信道中。

UDP 数据报文所能负载的最多数据，亦及一次传送的最大数据为 65507 个字节。

当消息从网络中到达后，其所包含的数据被 TCP 的 read()方法或 UDP 的 receive()方法返回前，数据存储在一个先进先出的接收数据队列中。对于已经建立连接的 TCP 套接字来说，所有已接受但还未传送的字节都看作是一个连续的字节序列。然而，对于 UDP 套接字来说，接收到的数据可能来自不同的发送者，一个 UDP 套接字所接受的数据存放在一个消息队列中，每个消息都关联了其源地址信息，每次 receive()调用只返回一条消息。如果 receive()方法在一个缓存区大小为 n 的 DatagramPacket 实例中调用，而接受队里中的第一条消息的长度大于 n，则 receive()方法只返回这条消息的前 n 个字节，超出部分会被自动放弃，而且对接收程序没有任何消息丢失的提示！

出于这个原因，接受者应该提供一个有足够大的缓存空间的 DatagramPacket 实例，以完整地存放调用 receive()方法时应用程序协议所允许的最大长度的消息。一个 DatagramPacket 实例中所允许传输的最大数据量为 65507 个字节，也即是 UDP 数据报文所能负载的最多数据。因此，可以用一个 65600 字节左右的缓存数组来接受数据。

DatagramPacket 的内部消息长度值在接收数据后会发生改变，变为实际接收到的数据的长度值。

每一个 DatagramPacket 实例都包含一个内部消息长度值，其初始值为 byte 缓存数组的长度值，而该实例一旦接受到消息，这个长度值便会变为接收到的消息的实际长度值，这一点可以用 DatagramPacket 类的 getLength()方法来测试。如果一个应用程序使用同一个 DatagramPacket 实例多次调用 receive()方法，每次调用前就必须显式地将其内部消息长度重置为缓存区的实际长度，以免接受的数据发生丢失。

以上面的程序为例，若在服务端的 receiver()后加入如下代码：

System.out.println(dp_receive.getLength());

DatagramPacket 的 getData()方法总是返回缓冲区的原始大小，忽略了实际数据的内部偏移量和长度信息。

由于 DatagramPacket 的 getData()方法总是返回缓冲数组的原始大小，即刚开始创建缓冲数组时指定的大小，在上面程序中，该长度为 1024，因此如果我们要获取接收到的数据，就必须截取 getData()方法返回的数组中只含接收到的数据的那一部分。在 Java1.6 之后，我们可以使用 Arrays.copyOfRange()方法来实现，只需一步便可实现以上功能：

byte[] destbuf = Arrays.copyOfRange(dp_receive.getData(),dp_receive.getOffset(),
dp_receive.getOffset() + dp_receive.getLength());

当然，如果要将接收到的字节数组转换为字符串的话，也可以采用本程序中直接 new 一个 String 对象的方法：

new String(dp_receive.getData(),dp_receive.getOffset(),
dp_receive.getOffset() + dp_receive.getLength());

参考地址：
http://wiki.jikexueyuan.com/project/java-socket/udp.html

山鬼谣me

关注

5
点赞
踩
9

收藏

觉得还不错? 一键收藏
打赏
0
评论
UDP连接之基本用法

环境Java：1.7场景公司需要从交易所接收股票的数据，交易所那边使用的是UDP连接方式，叫我先预演下，网上找个了资料后，这里简单记录下。分析UDP或者TCP，无非就是发送和接收，这里不提它们的区别，只需要指定前者没有保障，后者有保障。正常情况下，一般是服务方发送，客户方来接收。在我这场景中就是交易所是就是服务方，我公司就是客户方。客户端代码如下（其实是来自于极客学院，只不过我自己消化了）：pa
复制链接

扫一扫