User Datagram Protocol (UDP) provides a connectionless method for transmitting data across a network. Unlike TCP, UDP does not establish a persistent connection, making it suitable for scenarios where speed is prioritized over guaranteed delivery.

Core UDP Communication Components

UDP communication typically involves two primary classes: DatagramSocket and DatagramPacket.

1. DatagramPacket: Represents the actual data container. It holds the byte array to be sent or received, as well as the destination IP address and port number.
2. DatagramSocket: Serves as the mechanism for sending and receiving packets. A socket must be bound to a specific port to listen for incoming data.

Sending and Receiving Data

To transmit a packet, follow these steps:

• Create a DatagramSocket instance.
• Wrap the data into a DatagramPacket, specifying the recipient's InetAddress and port.
• Invoke the send() method on the socket.

To receive a packet:

• Create a DatagramSocket bound to a specific local port.
• Prepare a DatagramPacket with a pre-allocated byte buffer.
• Invoke the receive() method, which blocks the thread until data arrives.

Multicast Programming

Multicasting allows a single sender to transmit data too a group of interested hosts. This is achieved using a specific range of IP addresses (224.0.0.0 to 239.255.255.255). Hosts join a multicast group to receive messages sent to that group's adress.

Broadcaster Implementation

The following example demonstrates a server that broadcasts a message at regular intervals to a multicast group.

import java.net.*;

public class MessageBroadcaster extends Thread {
    private final String payload = "Scheduled Broadcast: System updates starting at midnight.";
    private final int groupPort = 7788;
    private InetAddress multicastGroup;
    private MulticastSocket mSocket;

    public MessageBroadcaster() {
        try {
            // Initialize multicast address and socket
            multicastGroup = InetAddress.getByName("228.5.6.7");
            mSocket = new MulticastSocket(groupPort);
            mSocket.setTimeToLive(1); // Restrict scope to local network
            mSocket.joinGroup(multicastGroup);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @Override
    public void run() {
        while (true) {
            byte[] dataBuffer = payload.getBytes();
            DatagramPacket outPacket = new DatagramPacket(dataBuffer, dataBuffer.length, multicastGroup, groupPort);
            try {
                System.out.println("Broadcasting message...");
                mSocket.send(outPacket);
                Thread.sleep(4000); // Wait 4 seconds between broadcasts
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        new MessageBroadcaster().start();
    }
}

Receiver Implementation

The client application below uses a Graphical User Interface to allow users to start and stop listening for multicast messages.

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.net.*;

public class MulticastClientGUI extends JFrame implements Runnable, ActionListener {
    private final int connectionPort = 7788;
    private InetAddress groupIP;
    private MulticastSocket receiverSocket;
    private JButton btnStart = new JButton("Start Listening");
    private JButton btnStop = new JButton("Stop Listening");
    private JTextArea currentField = new JTextArea(5, 20);
    private JTextArea historyField = new JTextArea(10, 20);
    private Thread workerThread;
    private volatile boolean active = false;

    public MulticastClientGUI() {
        super("UDP Multicast Monitor");
        initializeUI();
        setupNetworking();
    }

    private void initializeUI() {
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setLayout(new BorderLayout());

        JPanel topPanel = new JPanel();
        topPanel.add(btnStart);
        topPanel.add(btnStop);
        btnStart.addActionListener(this);
        btnStop.addActionListener(this);

        JPanel mainPanel = new JPanel(new GridLayout(2, 1));
        currentField.setBorder(BorderFactory.createTitledBorder("Latest Message"));
        mainPanel.add(new JScrollPane(currentField));
        historyField.setBorder(BorderFactory.createTitledBorder("Message History"));
        mainPanel.add(new JScrollPane(historyField));

        add(topPanel, BorderLayout.NORTH);
        add(mainPanel, BorderLayout.CENTER);
        setSize(450, 400);
        setVisible(true);
    }

    private void setupNetworking() {
        try {
            groupIP = InetAddress.getByName("228.5.6.7");
            receiverSocket = new MulticastSocket(connectionPort);
            receiverSocket.joinGroup(groupIP);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public void run() {
        byte[] buffer = new byte[1024];
        while (active) {
            try {
                DatagramPacket inPacket = new DatagramPacket(buffer, buffer.length);
                receiverSocket.receive(inPacket);
                String content = new String(inPacket.getData(), 0, inPacket.getLength());
                currentField.setText(content);
                historyField.append(content + "\\n");
            } catch (Exception e) {
                if (active) e.printStackTrace();
            }
        }
    }

    public void actionPerformed(ActionEvent e) {
        if (e.getSource() == btnStart) {
            if (!active) {
                active = true;
                workerThread = new Thread(this);
                workerThread.start();
                btnStart.setEnabled(false);
                btnStop.setEnabled(true);
            }
        } else if (e.getSource() == btnStop) {
            active = false;
            btnStart.setEnabled(true);
            btnStop.setEnabled(false);
        }
    }

    public static void main(String[] args) {
        new MulticastClientGUI();
    }
}