Get Your Current IP Address in Java

1. Overview

IP address, or Internet Protocol address, uniquely identifies a device on the Internet. Therefore, knowing the identity of the device running our application is a key part of some applications.

In this tutorial, we’ll check out various methods to retrieve the IP address of our computer using Java.

2. Find the Local IP Address

First, let’s look at some methods for obtaining the local IPv4 address of the current machine.

2.1. Local Address With Java Net Library

This method uses the Java Net library to make a UDP connection:

try (final DatagramSocket datagramSocket = new DatagramSocket()) {
    datagramSocket.connect(InetAddress.getByName("8.8.8.8"), 12345);
    return datagramSocket.getLocalAddress().getHostAddress();
}

Here, for simplicity, we are using Google’s primary DNS as our destination host and supplying the IP address 8.8.8.8. The Java Net Library checks only the validity of the address format at this point, so the address itself can be unreachable. Moreover, we are using a random port 12345 to create a UDP connection with the socket.connect() method. Under the hood, it sets all the variables needed for sending and receiving data, including the machine’s local address, without actually sending any request to the destination host.

While this solution works very well on Linux and Windows machines, it is problematic on macOS and doesn’t return the expected IP address.

2.2. Local Address With Socket Connection

Alternatively, we can use a socket connection through a reliable internet connection to look up the IP address:

try (Socket socket = new Socket()) {
    socket.connect(new InetSocketAddress("google.com", 80));
    return socket.getLocalAddress().getHostAddress();
}

Here, again for simplicity, we used google.com with a connection on port 80 to get the host address. We might use any other URL for creating a socket connection as long as it is reachable.

2.3. Using InetAddress.getLocalHost() Method

Also, we can get our local address using the getLocalHost() method:

try {
    return Inet4Address.getLocalHost().getHostAddress();
} catch (UnknownHostException e) {
    throw new RuntimeException(e);
}

In the code above, we invoke the getLocalHost() method on Inet4Address to retrieve the IPv4 address of our local machine, and then use the getHostAddress() method to retrieve its textual IP address.

Notably, getLocalHost() could resolve to a loopback address and return 127.0.0.1 in a case where a system DNS is misconfigured.

2.4. Using NetworkInterface Class

In case a machine has multiple IP addresses, we can use the NetworkInterface class to enumerate all available network interfaces and their associated address:

List<String> ipAddress = new ArrayList<>();
Enumeration<NetworkInterface> networkInterfaceEnumeration = null;
try {
    networkInterfaceEnumeration = NetworkInterface.getNetworkInterfaces();
} catch (SocketException e) {
    throw new RuntimeException(e);
}
for (; networkInterfaceEnumeration.hasMoreElements(); ) {
    NetworkInterface networkInterface = networkInterfaceEnumeration.nextElement();
    try {
        if (!networkInterface.isUp() || networkInterface.isLoopback()) {
            continue;
        }
    } catch (SocketException e) {
        throw new RuntimeException(e);
    }

    Enumeration<InetAddress> address = networkInterface.getInetAddresses();
    for (; address.hasMoreElements(); ) {
        InetAddress addr = address.nextElement();
        ipAddress.add(addr.getHostAddress());
    }
}
return ipAddress;

Here, we retrieve all the network interfaces available on our machine and iterate over the IP addresses associated with each one. Then, we return the list of addresses. Also, we filter out inactive and loopback interfaces before examining their addresses.

2.5. Caveats on Complex Network Situations

The methods listed above work very well in the case of simple network situations. However, in cases where the machine has more network interfaces, the behavior might not be as predictable.

In other words, the IP address returned from the functions described above will be the address of the preferred network interface on the machine. Consequently, it can be different from what we were expecting. For specific needs, we can find the IP Address of a Client Connected to a Server.

3. Find the Public IP Address

Similar to the local IP address, we might want to know the public IP address of the current machine. A public IP address is an IPv4 address reachable from the Internet. Moreover, it might not uniquely identify the machine looking up the address. For example, multiple hosts under the same router have the same public IP address.

Simply, we can connect to the Amazon AWS checkip.amazonaws.com URL and read the response:

String urlString = "http://checkip.amazonaws.com/";
URL url = new URL(urlString);
try (BufferedReader br = new BufferedReader(new InputStreamReader(url.openStream()))) {
    return br.readLine();
}

This works well most of the time. However, we explicitly depend on an external source whose reliability cannot be guaranteed. Therefore, as a fallback, we can use any of these URLs to retrieve the public IP address:

• https://ipv4.icanhazip.com/
• http://myexternalip.com/raw
• http://ipecho.net/plain

4. Conclusion

In this article, we learned how to find IP addresses of the current machine and how to retrieve them using Java. We also looked at various methods for checking both local and public IP addresses.