Abrufen der IP-Adresse des aktuellen Computers mit Java

import java.net.DatagramSocket;

try(final DatagramSocket socket = new DatagramSocket()){
  socket.connect(InetAddress.getByName("8.8.8.8"), 10002);
  ip = socket.getLocalAddress().getHostAddress();
}

Diese Weise funktioniert auch wenn es mehreren Netzwerk-Schnittstellen. Es gibt immer die bevorzugte ausgehende IP. Das Ziel 8.8.8.8 ist nicht nötig, um zu erreichen.

Connect auf einen UDP-socket hat folgende Wirkung: es legt das Ziel für Send/Recv, verwirft alle Pakete von anderen Adressen, und - das ist, was wir verwenden - überträgt die Buchse in die "verbunden" - Zustand, Einstellungen die entsprechenden Felder ein. Dies beinhaltet die Prüfung der Existenz der route zu dem Ziel entsprechend der system-routing-Tabelle und der Einstellung des lokalen Endpunkts entsprechend. Der Letzte Teil scheint zu sein, ohne Papiere offiziell, aber es sieht aus wie ein integraler Charakterzug der Berkeley sockets-API (eine Nebenwirkung von UDP - "connected" - Zustand), funktioniert zuverlässig unter Windows und Linux in verschiedenen Versionen und Distributionen.

So, diese Methode geben Sie die lokale Adresse, die verwendet werden, um eine Verbindung zu dem angegebenen remote host. Es gibt keine wirkliche Verbindung aufgebaut, damit die festgelegten remote-ip nicht erreichbar sein.

InformationsquelleAutor der Antwort Mr.Wang from Next Door

Posting hier getesteten IP-Mehrdeutigkeit Problemumgehung code von https://issues.apache.org/jira/browse/JCS-40 (InetAddress.getLocalHost() mehrdeutig auf Linux-Systemen):

/**
 * Returns an <code>InetAddress</code> object encapsulating what is most likely the machine's LAN IP address.
 * <p/>
 * This method is intended for use as a replacement of JDK method <code>InetAddress.getLocalHost</code>, because
 * that method is ambiguous on Linux systems. Linux systems enumerate the loopback network interface the same
 * way as regular LAN network interfaces, but the JDK <code>InetAddress.getLocalHost</code> method does not
 * specify the algorithm used to select the address returned under such circumstances, and will often return the
 * loopback address, which is not valid for network communication. Details
 * <a href="http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4665037">here</a>.
 * <p/>
 * This method will scan all IP addresses on all network interfaces on the host machine to determine the IP address
 * most likely to be the machine's LAN address. If the machine has multiple IP addresses, this method will prefer
 * a site-local IP address (e.g. 192.168.x.x or 10.10.x.x, usually IPv4) if the machine has one (and will return the
 * first site-local address if the machine has more than one), but if the machine does not hold a site-local
 * address, this method will return simply the first non-loopback address found (IPv4 or IPv6).
 * <p/>
 * If this method cannot find a non-loopback address using this selection algorithm, it will fall back to
 * calling and returning the result of JDK method <code>InetAddress.getLocalHost</code>.
 * <p/>
 *
 * @throws UnknownHostException If the LAN address of the machine cannot be found.
 */
private static InetAddress getLocalHostLANAddress() throws UnknownHostException {
    try {
        InetAddress candidateAddress = null;
        //Iterate all NICs (network interface cards)...
        for (Enumeration ifaces = NetworkInterface.getNetworkInterfaces(); ifaces.hasMoreElements();) {
            NetworkInterface iface = (NetworkInterface) ifaces.nextElement();
            //Iterate all IP addresses assigned to each card...
            for (Enumeration inetAddrs = iface.getInetAddresses(); inetAddrs.hasMoreElements();) {
                InetAddress inetAddr = (InetAddress) inetAddrs.nextElement();
                if (!inetAddr.isLoopbackAddress()) {

                    if (inetAddr.isSiteLocalAddress()) {
                        //Found non-loopback site-local address. Return it immediately...
                        return inetAddr;
                    }
                    else if (candidateAddress == null) {
                        //Found non-loopback address, but not necessarily site-local.
                        //Store it as a candidate to be returned if site-local address is not subsequently found...
                        candidateAddress = inetAddr;
                        //Note that we don't repeatedly assign non-loopback non-site-local addresses as candidates,
                        //only the first. For subsequent iterations, candidate will be non-null.
                    }
                }
            }
        }
        if (candidateAddress != null) {
            //We did not find a site-local address, but we found some other non-loopback address.
            //Server might have a non-site-local address assigned to its NIC (or it might be running
            //IPv6 which deprecates the "site-local" concept).
            //Return this non-loopback candidate address...
            return candidateAddress;
        }
        //At this point, we did not find a non-loopback address.
        //Fall back to returning whatever InetAddress.getLocalHost() returns...
        InetAddress jdkSuppliedAddress = InetAddress.getLocalHost();
        if (jdkSuppliedAddress == null) {
            throw new UnknownHostException("The JDK InetAddress.getLocalHost() method unexpectedly returned null.");
        }
        return jdkSuppliedAddress;
    }
    catch (Exception e) {
        UnknownHostException unknownHostException = new UnknownHostException("Failed to determine LAN address: " + e);
        unknownHostException.initCause(e);
        throw unknownHostException;
    }
}

InformationsquelleAutor der Antwort Vadzim

Beispiel in scala (nützlich bei der sbt-Datei):

  import collection.JavaConverters._
  import java.net._

  def getIpAddress: String = {

    val enumeration = NetworkInterface.getNetworkInterfaces.asScala.toSeq

    val ipAddresses = enumeration.flatMap(p =>
      p.getInetAddresses.asScala.toSeq
    )

    val address = ipAddresses.find { address =>
      val host = address.getHostAddress
      host.contains(".") && !address.isLoopbackAddress
    }.getOrElse(InetAddress.getLocalHost)

    address.getHostAddress
  }

InformationsquelleAutor der Antwort Andrzej Jozwik

Wenn Sie sind auf der Suche nach Ihrem "local" - Adresse, sollten Sie beachten, dass jede Maschine, nicht nur eine einzelne Netzwerk-Schnittstelle, und jedes interface hat seine eigenen lokalen Adresse. Was bedeutet, dass Ihre Maschine immer besitzen Sie mehrere "local" - Adressen.

Verschiedenen "local" - Adressen werden automatisch ausgewählt, wenn Sie eine Verbindung zu verschiedenen Endpunkten. Zum Beispiel, wenn Sie eine Verbindung zu google.com Sie ein "außerhalb" lokale Adresse; aber wenn Sie die Verbindung zu Ihrem localhost Ihre lokale Adresse ist immer localhost selbst, denn localhost ist einfach nur ein loopback.

Unten zeigt, wie finden Sie Ihre lokale Adresse, wenn Sie die Kommunikation mit google.com:

Socket socket = new Socket();
socket.connect(new InetSocketAddress("google.com", 80));
System.out.println(socket.getLocalAddress());

InformationsquelleAutor der Antwort macomgil

private static InetAddress getLocalAddress(){
        try {
            Enumeration<NetworkInterface> b = NetworkInterface.getNetworkInterfaces();
            while( b.hasMoreElements()){
                for ( InterfaceAddress f : b.nextElement().getInterfaceAddresses())
                    if ( f.getAddress().isSiteLocalAddress())
                        return f.getAddress();
            }
        } catch (SocketException e) {
            e.printStackTrace();
        }
        return null;
    }

InformationsquelleAutor der Antwort J.R

Können Sie java.net.InetAddress API.
Versuchen Sie dies :

InetAddress.getLocalHost().getHostAddress();

InformationsquelleAutor der Antwort Ved

Einen eher einfachen Ansatz, der zu funktionieren scheint...

String getPublicIPv4() throws UnknownHostException, SocketException{
    Enumeration<NetworkInterface> e = NetworkInterface.getNetworkInterfaces();
    String ipToReturn = null;
    while(e.hasMoreElements())
    {
        NetworkInterface n = (NetworkInterface) e.nextElement();
        Enumeration<InetAddress> ee = n.getInetAddresses();
        while (ee.hasMoreElements())
        {
            InetAddress i = (InetAddress) ee.nextElement();
            String currentAddress = i.getHostAddress();
            logger.trace("IP address "+currentAddress+ " found");
            if(!i.isSiteLocalAddress()&&!i.isLoopbackAddress() && validate(currentAddress)){
                ipToReturn = currentAddress;    
            }else{
                System.out.println("Address not validated as public IPv4");
            }

        }
    }

    return ipToReturn;
}

private static final Pattern IPv4RegexPattern = Pattern.compile(
        "^(([01]?\\d\\d?|2[0-4]\\d|25[0-5])\\.){3}([01]?\\d\\d?|2[0-4]\\d|25[0-5])$");

public static boolean validate(final String ip) {
    return IPv4RegexPattern.matcher(ip).matches();
}

InformationsquelleAutor der Antwort Pantelis Natsiavas

public static String getIpAddress() {

    String ipAddress = null;

    try {
        Enumeration<NetworkInterface> networkInterfaces = NetworkInterface.getNetworkInterfaces();

        while (networkInterfaces.hasMoreElements()) {

            NetworkInterface networkInterface = networkInterfaces.nextElement();

            byte[] hardwareAddress = networkInterface.getHardwareAddress();
            if (null == hardwareAddress || 0 == hardwareAddress.length || (0 == hardwareAddress[0] && 0 == hardwareAddress[1] && 0 == hardwareAddress[2])) continue;

            Enumeration<InetAddress> inetAddresses = networkInterface.getInetAddresses();

            if (inetAddresses.hasMoreElements()) ipAddress = inetAddresses.nextElement().toString();

            break;
        }
    } catch (SocketException e) {
        e.printStackTrace();
    }

    return ipAddress;
}

InformationsquelleAutor der Antwort Maxple