If you’re working with Spring, check out "REST With Spring":

>> CHECK OUT THE COURSE

1. Introduction

In this article, we describe how one-to-all (Broadcast) and one-to-many (Multicast) communications can be handled in Java. The broadcast and multicast concepts outlined in this article are based on the UDP protocol.

We start with a quick recap of datagrams and broadcasting and how it is implemented in Java. We also look into disadvantages of broadcasting and propose multicasting as an alternative to broadcasting.

Finally, we conclude by discussing support for these two addressing methods in both IPv4 and IPv6.

2. Datagram Recap

As per the official definition of a datagram, “A datagram is an independent, self-contained message sent over the network whose arrival, arrival time, and content are not guaranteed”.

In Java, the java.net package exposes the DatagramPacket and DatagramSocket classes that can be used for communication via the UDP protocol. UDP is typically used in scenarios where lower latency is more important than guaranteed delivery, such as audio/video streaming, network discovery, etc.

To learn more about UDP and datagrams in Java, refer to A Guide to UDP in Java.

3. Broadcasting

Broadcasting is a one-to-all type of communication, i.e. the intention is to send the datagram to all the nodes in the network. Unlike in the case of point-to-point communication, we don’t have to know the target host’s IP Address. Instead, a broadcast address is used.

As per IPv4 Protocol, a broadcast address is a logical address, on which devices connected to the network are enabled to receive packets. In our example, we use a particular IP address, 255.255.255.255, which is the broadcast address of the local network.

By definition, routers connecting a local network to other networks don’t forward packets sent to this default broadcast address. Later we also show how we can iterate through all NetworkInterfaces, and send packets to their respective broadcast addresses.

First, we demonstrate how to broadcast a message. To this extent, we need to call the setBroadcast() method on the socket to let it know that the packet is to be broadcasted:

public class BroadcastingClient {
    private static DatagramSocket socket = null;

    public static void main((String[] args)) throws IOException {
        broadcast("Hello", InetAddress.getByName("255.255.255.255"));
    }

    public static void broadcast(
      String broadcastMessage, InetAddress address) throws IOException {
        socket = new DatagramSocket();
        socket.setBroadcast(true);

        byte[] buffer = broadcastMessage.getBytes();

        DatagramPacket packet 
          = new DatagramPacket(buffer, buffer.length, address, 4445);
        socket.send(packet);
        socket.close();
    }
}

The next snippet shows how to iterate through all NetworkInterfaces to find their broadcast address:

List<InetAddress> listAllBroadcastAddresses() throws SocketException {
    List<InetAddress> broadcastList = new ArrayList<>();
    Enumeration<NetworkInterface> interfaces 
      = NetworkInterface.getNetworkInterfaces();
    while (interfaces.hasMoreElements()) {
        NetworkInterface networkInterface = interfaces.nextElement();

        if (networkInterface.isLoopback() || !networkInterface.isUp()) {
            continue;
        }

        networkInterface.getInterfaceAddresses().stream() 
          .map(a -> a.getBroadcast())
          .filter(Objects::nonNull)
          .forEach(broadcastList::add);
    }
    return broadcastList;
}

Once we have the list of broadcast addresses, we can execute the code in the broadcast() method shown above for each of these addresses.

There is no special code required on the receiving side to receive a broadcasted message. We can reuse the same code that receives a normal UDP datagram. A Guide to UDP in Java contains more details on this topic.

4. Multicasting

Broadcasting is inefficient as packets are sent to all nodes in the network, irrespective of whether they are interested in receiving the communication or not. This may be a waste of resources.

Multicasting solves this problem and sends packets to only those consumers who are interested. Multicasting is based on a group membership concept, where a multicast address represents each group.

In IPv4, any address between 224.0.0.0 to 239.255.255.255 can be used as a multicast address. Only those nodes that subscribe to a group receive packets communicated to the group.

In Java, MulticastSocket is used to receive packets sent to a multicast IP. The following example demonstrates the usage of MulticastSocket:

public class MulticastReceiver extends Thread {
    protected MulticastSocket socket = null;
    protected byte[] buf = new byte[256];

    public void run() {
        socket = new MulticastSocket(4446);
        InetAddress group = InetAddress.getByName("230.0.0.0");
        socket.joinGroup(group);
        while (true) {
            DatagramPacket packet = new DatagramPacket(buf, buf.length);
            socket.receive(packet);
            String received = new String(
              packet.getData(), 0, packet.getLength());
            if ("end".equals(received)) {
                break;
            }
        }
        socket.leaveGroup(group);
        socket.close();
    }
}

After binding the MulticastSocket to a port, we call the joinGroup() method, with the multicast IP as an argument. This is necessary to be able to receive the packets published to this group. The leaveGroup() method can be used to leave the group.

The following example shows how to publish to a multicast IP:

public class MulticastPublisher {
    private DatagramSocket socket;
    private InetAddress group;
    private byte[] buf;

    public void multicast(
      String multicastMessage) throws IOException {
        socket = new DatagramSocket();
        group = InetAddress.getByName("230.0.0.0");
        buf = multicastMessage.getBytes();

        DatagramPacket packet 
          = new DatagramPacket(buf, buf.length, group, 4446);
        socket.send(packet);
        socket.close();
    }
}

5. Broadcast and IPv6

IPv4 supports three types of addressing: unicast, broadcast, and multicast. Broadcast, in theory, is a one-to-all communication, i.e. a packet sent from a device has the potential of reaching the entire internet.

As this is undesired for obvious reasons, the scope of the IPv4 broadcast was significantly reduced. Multicast, which also serves as a better alternative to broadcast, came in much later and hence lagged in adoption.

In IPv6, multicast support has been made mandatory, and there is no explicit concept of broadcasting. Multicast has been extended and improved so that all broadcasting features can now be implemented with some form of multicasting.

In IPv6, the left-most bits of an address are used to determine its type. For a multicast address, the first 8 bits are all ones, i.e. FF00::/8.  Further, bit 113-116 represent the scope of the address, which can be either one of the following 4: Global, Site-local, Link-local, Node-local.

In addition to unicast and multicast, IPv6 also supports anycast, in which a packet can be sent to any member of the group, but need not be sent to all members.

6. Summary

In this article, we explored the concepts of one-to-all and one-to-many type of communication using the UDP protocol. We saw examples of how to implement these concepts in Java.

Finally, we also explored IPv4 and IPv6 support.

Full example code is available over on Github.

The new Certification Class of "REST With Spring" is finally out:

>> CHECK OUT THE COURSE

Leave a Reply

1 Comment on "Broadcasting and Multicasting in Java"

Notify of
avatar
Sort by:   newest | oldest | most voted
Priya
Guest

This blog gives clear difference between broadcasting & Multicasting. Thanks for sharing.

wpDiscuz