网络编程之UDP编程

最新推荐文章于 2024-05-03 21:43:52 发布

编程牧马人

最新推荐文章于 2024-05-03 21:43:52 发布

阅读量359

点赞数

分类专栏： java 文章标签： java udp socket 网络

本文链接：https://blog.csdn.net/m_shang/article/details/112364578

版权

java 专栏收录该内容

30 篇文章 0 订阅

订阅专栏

昨天学习了TCP编程，今天来康康UDP编程。

以下知识点均来源于廖雪峰官方网站https://www.liaoxuefeng.com/wiki/1252599548343744/1323711850348577

UDP编程

和TCP编程相比，UDP编程就简单得多，因为UDP没有创建连接，数据包也是一次收发一个，所以没有流的概念。

在Java中使用UDP编程，仍然需要使用Socket，因为应用程序在使用UDP时必须指定网络接口IP和端口号。注意：UDP端口和TCP端口虽然都使用0~65535，但他们是两套独立的端口，即一个应用程序用TCP占用了端口1234，不影响另一个应用程序用UDP占用端口1234。

服务器端

在服务器端，使用UDP也需要监听指定的端口。Java提供了DatagramSocket来实现这个功能，代码如下：

/**
 * @Auther Mario
 * @Date 2020-12-30 15:54
 * @Version 1.0
 * UDP 通信测试
 */
public class ServerOfUDP {

    public static void main(String[] args) throws Exception {

        DatagramSocket ds = new DatagramSocket(6666);
        for(;;){
            //数据缓冲区
            //要接收一个UDP数据包，需要准备一个byte[]缓冲区，并通过DatagramPacket实现接收：
            byte[] buffer = new byte[1024];
            DatagramPacket datagramPacket = new DatagramPacket(buffer, buffer.length);
            //接收UDP数据包
            ds.receive(datagramPacket);
            // 收取到的数据存储在buffer中，由packet.getOffset(), packet.getLength()指定起始位置和长度
            // 将其按UTF-8编码转换为String:
            String s = new String(datagramPacket.getData(), datagramPacket.getOffset(), datagramPacket.getLength(), StandardCharsets.UTF_8);

            //发送
            /**
             * 当服务器收到一个DatagramPacket后，通常必须立刻回复一个或多个UDP包，因为客户端地址在DatagramPacket中，
             * 每次收到的DatagramPacket可能是不同的客户端，如果不回复，客户端就收不到任何UDP包。
             */
            byte[] data = "ACK".getBytes();
            datagramPacket.setData(data);
            ds.send(datagramPacket);

        }
    }
}

服务器端首先使用如下语句在指定的端口监听UDP数据包：

DatagramSocket ds = new DatagramSocket(6666);

如果没有其他应用程序占据这个端口，那么监听成功，我们就使用一个无限循环来处理收到的UDP数据包：

for (;;) {
    ...
}

要接收一个UDP数据包，需要准备一个byte[]缓冲区，并通过DatagramPacket实现接收：

byte[] buffer = new byte[1024];
DatagramPacket packet = new DatagramPacket(buffer, buffer.length);
ds.receive(packet);

假设我们收取到的是一个String，那么，通过DatagramPacket返回的packet.getOffset()和packet.getLength()确定数据在缓冲区的起止位置：

String s = new String(packet.getData(), packet.getOffset(), packet.getLength(), StandardCharsets.UTF_8);

当服务器收到一个DatagramPacket后，通常必须立刻回复一个或多个UDP包，因为客户端地址在DatagramPacket中，每次收到的DatagramPacket可能是不同的客户端，如果不回复，客户端就收不到任何UDP包。

发送UDP包也是通过DatagramPacket实现的，发送代码非常简单：

byte[] data = ...
packet.setData(data);
ds.send(packet);

客户端

和服务器端相比，客户端使用UDP时，只需要直接向服务器端发送UDP包，然后接收返回的UDP包：

/**
 * @Auther Mario
 * @Date 2020-12-30 16:05
 * @Version 1.0
 * UDP 通信
 * 和TCP编程相比，UDP编程就简单得多，因为UDP没有创建连接，数据包也是一次收发一个，所以没有流的概念。
 */
public class ClientOfUDP {

    public static void main(String[] args) throws Exception {
        /**
         客户端创建DatagramSocket实例时并不需要指定端口，而是由操作系统自动指定一个当前未使用的端口。
         紧接着，调用setSoTimeout(1000)设定超时1秒，意思是后续接收UDP包时，等待时间最多不会超过1秒，
         否则在没有收到UDP包时，客户端会无限等待下去。这一点和服务器端不一样，服务器端可以无限等待，
         因为它本来就被设计成长时间运行。
         */
        DatagramSocket ds = new DatagramSocket();
        ds.setSoTimeout(1000);
        ds.connect(InetAddress.getByName("localhost"),6666);
        /**
         * 注意到客户端的DatagramSocket还调用了一个connect()方法“连接”到指定的服务器端。不是说UDP是无连接的协议吗？为啥这里需要connect()？
         * 这个connect()方法不是真连接，它是为了在客户端的DatagramSocket实例中保存服务器端的IP和端口号，确保这个DatagramSocket实例只能往指定的地址和端口发送UDP包，不能往其他地址和端口发送。这么做不是UDP的限制，而是Java内置了安全检查。
         * 如果客户端希望向两个不同的服务器发送UDP包，那么它必须创建两个DatagramSocket实例。
         */
        //发送
        byte[] data = "Hello".getBytes();
        DatagramPacket packet = new DatagramPacket(data,data.length);
        ds.send(packet);

        //接收
        byte[] buffer = new byte[1024];
        packet = new DatagramPacket(buffer,buffer.length);
        ds.receive(packet);
        String resp = new String(packet.getData(),packet.getOffset(),packet.getLength(), StandardCharsets.UTF_8);
        ds.disconnect();
    }
}

/**
 * 和TCP编程相比，UDP编程就简单得多，因为UDP没有创建连接，数据包也是一次收发一个，所以没有流的概念。
 * 在Java中使用UDP编程，仍然需要使用Socket，因为应用程序在使用UDP时必须指定网络接口（IP）和端口号。
 * 注意：UDP端口和TCP端口虽然都使用0~65535，但他们是两套独立的端口，即一个应用程序用TCP占用了端口1234，不影响另一个应用程序用UDP占用端口1234。
 */

客户端打开一个DatagramSocket使用以下代码：

DatagramSocket ds = new DatagramSocket();
ds.setSoTimeout(1000);
ds.connect(InetAddress.getByName("localhost"), 6666);

客户端创建DatagramSocket实例时并不需要指定端口，而是由操作系统自动指定一个当前未使用的端口。紧接着，调用setSoTimeout(1000)设定超时1秒，意思是后续接收UDP包时，等待时间最多不会超过1秒，否则在没有收到UDP包时，客户端会无限等待下去。这一点和服务器端不一样，服务器端可以无限等待，因为它本来就被设计成长时间运行。

注意到客户端的DatagramSocket还调用了一个connect()方法“连接”到指定的服务器端。不是说UDP是无连接的协议吗？为啥这里需要connect()？

这个connect()方法不是真连接，它是为了在客户端的DatagramSocket实例中保存服务器端的IP和端口号，确保这个DatagramSocket实例只能往指定的地址和端口发送UDP包，不能往其他地址和端口发送。这么做不是UDP的限制，而是Java内置了安全检查。

如果客户端希望向两个不同的服务器发送UDP包，那么它必须创建两个DatagramSocket实例。

后续的收发数据和服务器端是一致的。通常来说，客户端必须先发UDP包，因为客户端不发UDP包，服务器端就根本不知道客户端的地址和端口号。

如果客户端认为通信结束，就可以调用disconnect()断开连接：

ds.disconnect();

注意到disconnect()也不是真正地断开连接，它只是清除了客户端DatagramSocket实例记录的远程服务器地址和端口号，这样，DatagramSocket实例就可以连接另一个服务器端。

官方代码

服务端

/**
 * Learn Java from https://www.liaoxuefeng.com/
 * 
 * @author liaoxuefeng
 */
public class Server {
	public static void main(String[] args) throws IOException {
		DatagramSocket ds = new DatagramSocket(6666); // 监听指定端口
		System.out.println("server is running...");
		for (;;) {
			// 接收:
			byte[] buffer = new byte[1024];
			DatagramPacket packet = new DatagramPacket(buffer, buffer.length);
			ds.receive(packet);
			String cmd = new String(packet.getData(), packet.getOffset(), packet.getLength(), StandardCharsets.UTF_8);
			// 发送:
			String resp = "bad command";
			switch (cmd) {
			case "date":
				resp = LocalDate.now().toString();
				break;
			case "time":
				resp = LocalTime.now().withNano(0).toString();
				break;
			case "datetime":
				resp = LocalDateTime.now().withNano(0).toString();
				break;
			case "weather":
				resp = "sunny, 10~15 C.";
				break;
			}
			System.out.println(cmd + " >>> " + resp);
			packet.setData(resp.getBytes(StandardCharsets.UTF_8));
			ds.send(packet);
		}
	}
}

客户端

public class Client {
	public static void main(String[] args) throws IOException, InterruptedException {
		DatagramSocket ds = new DatagramSocket();
		ds.setSoTimeout(1000);
		ds.connect(InetAddress.getByName("localhost"), 6666); // 连接指定服务器和端口
		DatagramPacket packet = null;
		for (int i = 0; i < 5; i++) {
			// 发送:
			String cmd = new String[] { "date", "time", "datetime", "weather", "hello" }[i];
			byte[] data = cmd.getBytes();
			packet = new DatagramPacket(data, data.length);
			ds.send(packet);
			// 接收:
			byte[] buffer = new byte[1024];
			packet = new DatagramPacket(buffer, buffer.length);
			ds.receive(packet);
			String resp = new String(packet.getData(), packet.getOffset(), packet.getLength());
			System.out.println(cmd + " >>> " + resp);
			Thread.sleep(1500);
		}
		ds.disconnect();
		System.out.println("disconnected.");
	}
}

自我总结：UDP相比TCP最主要的区别就是没有建立连接，没有基于Socket流进行通信，而是采用数据包报文的方式，不需要校验机制，提高了传输效率，对于非安全传输有很强的可用性。UDP服务端通过DatagramSocket监听指定端口，自定义byte[]缓存并封装到DatagramPacket，对每个请求发送的报文通过DatagramSocket.receive()接收，存入Packet数据包中，回复客户端的数据依然采用byte[]格式，调用DatagramPacket中setData()打包数据，通过DatagramSocket.send()返回报文。客户端直接通过DatagramSocket建立通信，不需要指定端口号，有系统自动指定，可设置超时时间避免无限等待，发送数据后DatagramSocket.disconnect()关闭连接。

小结

使用UDP协议通信时，服务器和客户端双方无需建立连接：

服务器端用DatagramSocket(port)监听端口；
客户端使用DatagramSocket.connect()指定远程地址和端口；
双方通过receive()和send()读写数据；
DatagramSocket没有IO流接口，数据被直接写入byte[]缓冲区。

原文链接
网络编程基础(下)

编程牧马人

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
网络编程之UDP编程

昨天学习了TCP编程，今天来康康UDP编程。以下知识点均来源于廖雪峰官方网站https://www.liaoxuefeng.com/wiki/1252599548343744/1323711850348577UDP编程和TCP编程相比，UDP编程就简单得多，因为UDP没有创建连接，数据包也是一次收发一个，所以没有流的概念。在Java中使用UDP编程，仍然需要使用Socket，因为应用程序在使用UDP时必须指定网络接口IP和端口号。注意：UDP端口和TCP端口虽然都使用0~65535，但他们是两套
复制链接

扫一扫

专栏目录