Getting the IP address of the current machine using Java

Handling multiple network interfaces

Many sophisticated applications run on machines with multiple network interfaces. You might need to iterate through all of them and identify the non-loopback and site-local addresses. These IPs often represent the machine on the LAN in multi-interface environments.

import java.net.*;
import java.util.*;

public class GetMultiIPs {
    public static void main(String[] args) throws SocketException {
        Enumeration<NetworkInterface> interfaces = NetworkInterface.getNetworkInterfaces();
        while (interfaces.hasMoreElements()) {
            NetworkInterface iface = interfaces.nextElement();
            // We're the network Sherlock Holmes, not interested in loopbacks or down interfaces!
            if (iface.isLoopback() || !iface.isUp()) continue;
            
            Enumeration<InetAddress> addresses = iface.getInetAddresses();
            while(addresses.hasMoreElements()) {
                InetAddress addr = addresses.nextElement();
                // Elementary, my dear Watson! We prefer ipv4 addresses
                if (addr instanceof Inet4Address) {
                    System.out.println(iface.getDisplayName() + " - " + addr.getHostAddress());
                }
            }
        }
    }
}


This listing manoeuvre will exhibit all IPv4 addresses of active, non-loopback network interfaces.

Going off the beaten track with DatagramSocket

Sometimes, InetAddress.getLocalHost() might not give you the desired results, especially on Linux. To handle such cases, DatagramSocket can be employed to query the network:

import java.net.*;

public class GetPreferredIP {
    public static void main(String[] args) throws SocketException {
        try (final DatagramSocket socket = new DatagramSocket()) {
            socket.connect(InetAddress.getByName("8.8.8.8"), 10002);
            // Just like a wizard, socket pulls out the preferred outbound IP, out of nowhere!
            System.out.println(socket.getLocalAddress().getHostAddress());
        } catch (UnknownHostException e) {
            e.printStackTrace();
        }
    }
}


No data is sent to the server (Google DNS, in this case), but this magical socket can fetch the preferred outbound IP address.

Addressing peculiar situations

Different environments have unique characteristics, so here's a few noteworthy situations:

• Loopback Addresses: Avoid reliance solely on them, particularly when you need the external-facing IP.
• Public IP Discovery: Need your public-facing IP? Fire a simple HTTP request to httpbin.org/ip.
• MacOS Quirks: MacOS users might need to sway towards the socket technique for landing the correct local address.

Crafting robust solutions

Ensure you put on your safety belts and swim floats, by implementing error handling for those unpredictable situations when none of your IP retrieval strategies work. Remember, try-catch blocks are your lifeguards.

Testing is the key

Just like the cook who tastes their dish, don't forget to test your methods across diverse network configurations.

Managing advanced situations

For those advanced applications like PPP connections, give DatagramSocket a try. Connect it to a known external IP address and marvel as it returns the correct local IP.