UDP
User Datagram Protocol :一种用户数据报协议,又称用户数据报文协议
是一个简单的面向数据报的传输层协议,正式规范为RFC 768
用户数据协议、非连接协议
为什么是不可靠的?
它一旦把应用程序发给网络层的数据发送出去,就不保留数据备份
UDP在IP数据报的头部仅仅加入了复用和数据校验(字段)
发送端生产数据,接收端从网络中抓取数据
结构简单、无校验、速度快、容易丢包、可广播
UDP能做什么?
DNS、TFTP、SNMP
用于视频、音频、普通数据(无关紧要数据)
UDP核心API
- DatagramSocket
用于接收与发送UDP的类
负责发送某一个UDP包,或者接收UDP包
不同于TCP,UDP并没有合并到Socket API中
DatagramSocket() :创建简单实例,不指定端口与IP,将会使用本机的
DatagramSocket(int port) :创建监听固定端口的实例
DatagramSocket(int port , InetAddress localAddr) :创建固定端口指定IP的实例
receive(DatagramPacket d) :接收
send(DatagramPacket d) :发送
setSoTimeout(int timeout) :设置超时,毫秒
close() :关闭资源
- DatagramPacket
用于处理报文
将byte数组、目标地址、目标端口等数据包装成报文或者将报文拆卸成byte数组
是UDP的发送实体,也是接收实体
DatagramPacket( byte[] buf, int offset ,int length , InetAddress address, int port)
前面3个参数指定buf的使用区间
后面2个参数指定目标机器地址与端口
DatagramPacket( byte[] buf, int length , SocketAddress address)
前面3个参数指定buf的使用区间
SocketAddress相当于InetAddress + Port
setData(byte[] buf , int offset , int length )
setData(byte[] buf)
setLength(int length)
getData()、getOffset()、 getlength()
setAddress( InetAddress iaddr)、setPort(int iport) //发送时有效,接收时无效的,接收时是由系统自动set
getAddress()、getPort()
setSocketAddress( SocketAddress address)
getSocketAddress()
UDP单播、广播、多播
广播地址
255.255.255.255 为受限广播地址
C网广播地址一般为:XXX.XXX.XXX.255(192.128.1.255)
D类IP地址为多播预留
IP地址构成
广播地址运算
IP:192.168.124.7
子网掩码:255.255.255.192
网络地址:192.168.124.0
广播地址:192.168.124.63
广播通信问题:不在同一个广播地址网段,是无法通信的
案例实操——局域网搜索案例
- UDP接收消息并回送功能实现
- UDP局域网广播发送实现
- UDP局域网回送消息实现
UDPProvider:服务器端,不断监听端口20000,回送消息
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.util.UUID;
/**
* UDP提供者,用于提供服务,B计算机
*/
public class UDPProvider {
public static void main(String[] args) throws IOException {
//生成唯一标识
String sn = UUID.randomUUID().toString();
Provider provider = new Provider(sn);
provider.start();
System.in.read();
provider.exit();
}
private static class Provider extends Thread {
private final String sn;
private boolean done = false;
private DatagramSocket ds = null;
private Provider(String sn) {
super();
this.sn = sn;
}
@Override
public void run() {
super.run();
System.out.println("UDPProvider Started....");
try {
//监听20000端口
ds = new DatagramSocket(20000);
while (!done) {
//构建接收实体
final byte[] buf = new byte[512];
DatagramPacket receivePack = new DatagramPacket(buf, buf.length);
//接收
ds.receive(receivePack);
//打印接收到的信息与发送者的信息
//发送者的IP地址
String ip = receivePack.getAddress().getHostAddress();
int port = receivePack.getPort();
int datalen = receivePack.getLength();
String data = new String(receivePack.getData(), 0, datalen);
System.out.println("UDPProvider receive form ip :" + ip +
"\tport :" + port + "\tdata :" + data);
//解析端口号
int responsePort = MessageCreator.parsePort(data);
if (responsePort != -1) {
//构建一份回送数据
String responseData = MessageCreator.buildWithSn(sn);
byte[] responseDataBytes = responseData.getBytes();
//直接根据发送者构建一份回送消息
DatagramPacket responsePacket = new DatagramPacket(responseDataBytes,
responseDataBytes.length, receivePack.getAddress(), responsePort);
ds.send(responsePacket);
}
}
} catch (IOException e) {
} finally {
//完成,关闭资源
close();
}
System.out.println("UDPProvider Finished...");
}
private void close() {
if (ds != null) {
ds.close();
ds = null;
}
}
void exit() {
done = true;
close();
}
}
}
UDPSearcher:自身监听窗口为30000,向20000端口发送信息
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CountDownLatch;
public class UDPSearcher {
private static final int LISTEN_PORT = 30000;
public static void main(String[] args) throws IOException, InterruptedException {
System.out.println("UDPSearcher Started....");
Listener listener = listen();
sendBroadcast();
System.in.read();
List<Device> devices = listener.getDevicesAndClose();
for (Device device : devices) {
System.out.println("Device:"+device.toString());
}
System.out.println("UDPSearcher Finished....");
}
private static Listener listen() throws InterruptedException {
System.out.println("UDPSearcher start listen...");
CountDownLatch countDownLatch = new CountDownLatch(1);
Listener listener = new Listener(LISTEN_PORT,countDownLatch);
listener.start();
countDownLatch.await();
return listener;
}
private static void sendBroadcast() throws IOException {
System.out.println("UDPSearcher sendBroadcast started...");
//作为搜索者,让系统自动分配端口
DatagramSocket ds = new DatagramSocket();
//构建一份请求数据
String requestData = MessageCreator.buildWithPort(LISTEN_PORT);
byte[] requestDataBytes = requestData.getBytes();
//直接构建DatagramPacket
DatagramPacket requestPacket = new DatagramPacket(requestDataBytes,
requestDataBytes.length);
//本机20000端口
requestPacket.setAddress(InetAddress.getByName("255.255.255.255"));
requestPacket.setPort(20000);
//发送
ds.send(requestPacket);
ds.close();
//完成,关闭资源
System.out.println("UDPSearcher sendBroadcast Finished...");
}
private static class Device {
final int port;
final String ip;
final String sn;
public Device(int port, String ip, String sn) {
this.port = port;
this.ip = ip;
this.sn = sn;
}
@Override
public String toString() {
return "Device{" +
"port=" + port +
", ip=" + ip +
", sn='" + sn + '\'' +
'}';
}
}
private static class Listener extends Thread {
private final int listenPort;
private final CountDownLatch countDownLatch;
private final List<Device> devices = new ArrayList<>();
private boolean done = false;
private DatagramSocket ds = null;
public Listener(int listenPort, CountDownLatch countDownLatch) {
this.listenPort = listenPort;
this.countDownLatch = countDownLatch;
}
@Override
public void run() {
super.run();
//通知已启动
countDownLatch.countDown();
try {
//监听20000端口
ds = new DatagramSocket(LISTEN_PORT);
while (!done) {
//构建接收实体
final byte[] buf = new byte[512];
DatagramPacket receivePack = new DatagramPacket(buf, buf.length);
//接收
ds.receive(receivePack);
//打印接收到的信息与发送者的信息
//发送者的IP地址
String ip = receivePack.getAddress().getHostAddress();
int port = receivePack.getPort();
int datalen = receivePack.getLength();
String data = new String(receivePack.getData(), 0, datalen);
System.out.println("UDPSearcher receive form ip :" + ip +
"\tport :" + port + "\tdata :" + data);
String sn = MessageCreator.parseSn(data);
if (sn != null){
Device device = new Device(port,ip,sn);
devices.add(device);
}
}
} catch (Exception ignored) {
} finally {
close();
}
}
private void close() {
if (ds != null) {
ds.close();
ds = null;
}
}
List<Device> getDevicesAndClose() {
done = true;
close();
return devices;
}
}
}
MessageCreator:信息构建标准类
public class MessageCreator {
private static final String SN_HEADER = "收到暗号,我是(SN):";
private static final String PORT_HEADER = "这是暗号,请回电端口(Port):";
public static String buildWithPort(int port){
return PORT_HEADER + port;
}
public static int parsePort(String data){
if (data.startsWith(PORT_HEADER)){
return Integer.parseInt(data.substring(PORT_HEADER.length()));
}
return -1;
}
public static String buildWithSn(String sn){
return SN_HEADER + sn;
}
public static String parseSn(String data){
if (data.startsWith(SN_HEADER)){
return data.substring(SN_HEADER.length());
}
return null;
}
}