2.4. UDP Programming in Java

Unlike TCP, UDP does not establish a connection before sending data.

UDP, or User Datagram Protocol, is fundamentally different from TCP in that it doesn't require a connection setup before transmitting data. With TCP, a connection must be established between the sender and receiver which ensures reliable data transfer, but adds some delay for the connection phase. UDP skips this step, allowing data to be sent immediately, which usually results in a faster transmission of information.

Think of UDP like sending a postcard instead of a registered letter. When you send a postcard (UDP), your message goes directly to the recipient without any formalities or delivery confirmation. If the postcard gets lost, there's no way to retrieve it, but it reaches the recipient quickly. In contrast, a registered letter (TCP) ensures that the recipient must sign for it upon delivery, providing proof that the message was received, albeit taking more time.

import java.net.*;
public class UDPSender {
public static void main(String[] args) {
try {
DatagramSocket socket = new DatagramSocket();
String msg = "Hello UDP Server";
byte[] buffer = msg.getBytes();
InetAddress receiver = InetAddress.getByName("localhost");
DatagramPacket packet = new DatagramPacket(buffer, buffer.length,
receiver, 6000);
socket.send(packet);
socket.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}

This code represents the UDP sender or client. It begins by importing the necessary networking classes. A DatagramSocket object is created which is responsible for sending the data. A message is defined, and then converted into a byte array using getBytes(). The receiver's address is obtained by looking up 'localhost', which refers to the same machine, and a DatagramPacket is formed using the byte array, its length, the receiver's address, and the port number (6000). Finally, the packet is sent using the send() method before closing the socket to free up resources.

Imagine you're sending a simple text message to a friend. You compose your message (like 'Hello UDP Server'), convert it into a format that can be sent over (like converting it to a digital format), and then you send it off without waiting for any acknowledgment if your friend received it. This spontaneous and quick action mirrors how the UDP client operates, swiftly sending messages without the need for confirmation.

import java.net.*;
public class UDPReceiver {
public static void main(String[] args) {
try {
DatagramSocket socket = new DatagramSocket(6000);
byte[] buffer = new byte[1024];
DatagramPacket packet = new DatagramPacket(buffer, buffer.length);
System.out.println("Waiting for message...");
socket.receive(packet);
String msg = new String(packet.getData(), 0, packet.getLength());
System.out.println("Received: " + msg);
socket.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}

This code illustrates the UDP receiver or server. It listens for incoming data on port 6000 through a DatagramSocket. A buffer of 1024 bytes is created to hold incoming data. The server waits for a DatagramPacket to come in. Once a packet is received, the message is extracted from the packet using getData() and its length is specified to ensure only the actual message text is read. The received message is then printed out before closing the socket to release resources.

Consider yourself as the person at the post office box who waits for any mail. You're ready with an empty box to receive letters. When a postcard arrives (the UDP packet), you take it out and read the message. The beauty of your job is that you don’t require the sender to confirm whether you got it or not. This reflects the operation of a UDP server, which simply waits and reads messages when they arrive.

--