Java Datagrams

📡 What are Java Datagrams?

Datagrams use UDP protocol for fast, connectionless communication in Java. They're ideal for real-time applications like gaming or streaming where speed matters more than guaranteed delivery.


// Basic datagram example
DatagramSocket socket = new DatagramSocket();
byte[] data = "Hello UDP!".getBytes();
DatagramPacket packet = new DatagramPacket(data, data.length, 
    InetAddress.getByName("localhost"), 8080);
socket.send(packet);

Datagram Components

📦

DatagramPacket

Container for UDP data

DatagramPacket packet = new DatagramPacket(data, length);

🔌

DatagramSocket

UDP communication endpoint

DatagramSocket socket = new DatagramSocket(port);

🏠

InetAddress

Network address representation

InetAddress address = InetAddress.getByName("localhost");

⚡

UDP Protocol

Fast, connectionless communication

// No connection needed, just send!

🔹 UDP Client (Sender)

Send data using UDP datagrams:

import java.net.*;
import java.io.*;

public class UDPClient {
    public static void main(String[] args) {
        try {
            // Create datagram socket
            DatagramSocket socket = new DatagramSocket();
            
            // Prepare data to send
            String message = "Hello UDP Server!";
            byte[] data = message.getBytes();
            
            // Get server address
            InetAddress serverAddress = InetAddress.getByName("localhost");
            
            // Create datagram packet
            DatagramPacket packet = new DatagramPacket(
                data, data.length, serverAddress, 8080);
            
            // Send packet
            socket.send(packet);
            System.out.println("Message sent: " + message);
            
            // Prepare to receive response
            byte[] responseData = new byte[1024];
            DatagramPacket responsePacket = new DatagramPacket(
                responseData, responseData.length);
            
            // Receive response
            socket.receive(responsePacket);
            String response = new String(responsePacket.getData(), 
                0, responsePacket.getLength());
            System.out.println("Server response: " + response);
            
            // Close socket
            socket.close();
            
        } catch (Exception e) {
            System.out.println("Client error: " + e.getMessage());
        }
    }
}

🔹 UDP Server (Receiver)

Receive and respond to UDP datagrams:

import java.net.*;
import java.io.*;

public class UDPServer {
    public static void main(String[] args) {
        try {
            // Create datagram socket on port 8080
            DatagramSocket socket = new DatagramSocket(8080);
            System.out.println("UDP Server started on port 8080");
            
            while (true) {
                // Prepare to receive data
                byte[] receiveData = new byte[1024];
                DatagramPacket receivePacket = new DatagramPacket(
                    receiveData, receiveData.length);
                
                // Receive packet
                socket.receive(receivePacket);
                
                // Extract message
                String message = new String(receivePacket.getData(), 
                    0, receivePacket.getLength());
                System.out.println("Received: " + message);
                
                // Get client address and port
                InetAddress clientAddress = receivePacket.getAddress();
                int clientPort = receivePacket.getPort();
                
                // Prepare response
                String response = "Echo: " + message;
                byte[] responseData = response.getBytes();
                
                // Create response packet
                DatagramPacket responsePacket = new DatagramPacket(
                    responseData, responseData.length, 
                    clientAddress, clientPort);
                
                // Send response
                socket.send(responsePacket);
                System.out.println("Response sent");
            }
            
        } catch (Exception e) {
            System.out.println("Server error: " + e.getMessage());
        }
    }
}

Server Output:

UDP Server started on port 8080

Received: Hello UDP Server!

Response sent

🔹 UDP vs TCP Comparison

Understanding the differences between UDP and TCP:

UDP (User Datagram Protocol):

Speed: Faster, no connection overhead
Reliability: No guarantee of delivery
Connection: Connectionless protocol
Order: No guarantee of packet order
Use cases: Gaming, live streaming, DNS queries

TCP (Transmission Control Protocol):

Speed: Slower due to connection management
Reliability: Guaranteed delivery and error correction
Connection: Connection-oriented protocol
Order: Maintains packet order
Use cases: Web browsing, file transfer, email

🔹 Broadcast Example

Send data to multiple recipients using broadcast:

import java.net.*;

public class UDPBroadcast {
    public static void main(String[] args) {
        try {
            // Create socket
            DatagramSocket socket = new DatagramSocket();
            
            // Enable broadcast
            socket.setBroadcast(true);
            
            // Prepare broadcast message
            String message = "Broadcast message to all!";
            byte[] data = message.getBytes();
            
            // Broadcast address (255.255.255.255)
            InetAddress broadcastAddress = 
                InetAddress.getByName("255.255.255.255");
            
            // Create broadcast packet
            DatagramPacket packet = new DatagramPacket(
                data, data.length, broadcastAddress, 8080);
            
            // Send broadcast
            socket.send(packet);
            System.out.println("Broadcast sent: " + message);
            
            socket.close();
            
        } catch (Exception e) {
            System.out.println("Broadcast error: " + e.getMessage());
        }
    }
}

🔹 Common Datagram Methods

Important methods for working with datagrams:

DatagramSocket Methods:

send(DatagramPacket): Send a datagram packet
receive(DatagramPacket): Receive a datagram packet
setBroadcast(boolean): Enable/disable broadcast
setSoTimeout(int): Set receive timeout
close(): Close the socket

DatagramPacket Methods:

getData(): Get packet data as byte array
getLength(): Get data length
getAddress(): Get sender/receiver address
getPort(): Get sender/receiver port