Abrufen der IP-Adresse des aktuellen Computers mithilfe von Java

Ich versuche, ein System zu entwickeln, in dem verschiedene Knoten auf verschiedenen Systemen oder an verschiedenen Ports auf demselben System ausgeführt werden.

Jetzt erstellen alle Knoten einen Socket mit einer Ziel-IP als IP eines speziellen Knotens, der als Bootstrapping-Knoten bezeichnet wird. Die Knoten erstellen dann ihre eigenen ServerSocketund warten auf Verbindungen.

Der Bootstrapping-Knoten verwaltet eine Liste von Knoten und gibt diese bei Abfrage zurück.

Was ich jetzt brauche, ist, dass der Knoten seine IP beim Bootstrapping-Knoten registrieren muss. Ich habe versucht, zu verwenden, cli.getInetAddress()sobald der Client eine Verbindung zum ServerSocketBootstrapping-Knoten hergestellt hat, aber das hat nicht funktioniert.

1. Ich benötige den Client, um seine PPP-IP zu registrieren, falls verfügbar.
2. Andernfalls die LAN-IP, falls verfügbar;
3. Andernfalls muss 127.0.0.1 unter der Annahme registriert werden, dass es sich um denselben Computer handelt.

Verwenden des Codes:

System.out.println(Inet4Address.getLocalHost().getHostAddress());

oder

System.out.println(InetAddress.getLocalHost().getHostAddress());

Meine PPP-Verbindungs-IP-Adresse lautet: 117.204.44.192, aber die oben angegebene Adresse gibt mir 192.168.1.2 zurück

BEARBEITEN

Ich verwende den folgenden Code:

Enumeration e = NetworkInterface.getNetworkInterfaces();
while(e.hasMoreElements())
{
    NetworkInterface n = (NetworkInterface) e.nextElement();
    Enumeration ee = n.getInetAddresses();
    while (ee.hasMoreElements())
    {
        InetAddress i = (InetAddress) ee.nextElement();
        System.out.println(i.getHostAddress());
    }
}

Ich kann alle IP-Adressen abrufen, die allen NetworkInterfaces zugeordnet sind, aber wie unterscheide ich sie? Dies ist die Ausgabe, die ich bekomme:

127.0.0.1
192.168.1.2
192.168.56.1
117.204.44.19

import java.net.DatagramSocket;
import java.net.InetAddress;

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

Diese Methode funktioniert gut, wenn mehrere Netzwerkschnittstellen vorhanden sind. Es wird immer die bevorzugte ausgehende IP zurückgegeben. Das Ziel muss 8.8.8.8nicht erreichbar sein.

ConnectEin UDP-Socket hat folgenden Effekt: Er legt das Ziel für Senden / Empfangen fest, verwirft alle Pakete von anderen Adressen und versetzt den Socket - was wir verwenden - in den Status "Verbunden" und stellt die entsprechenden Felder ein. Dies umfasst das Überprüfen des Vorhandenseins der Route zum Ziel gemäß der Routing-Tabelle des Systems und das entsprechende Festlegen des lokalen Endpunkts. Der letzte Teil scheint offiziell nicht dokumentiert zu sein, sieht jedoch wie ein integraler Bestandteil der Berkeley-Sockets-API aus (ein Nebeneffekt des "verbundenen" UDP-Status), der sowohl unter Windows als auch unter Linux über Versionen und Distributionen hinweg zuverlässig funktioniert.

Diese Methode gibt also die lokale Adresse an, die für die Verbindung mit dem angegebenen Remote-Host verwendet wird. Es wurde keine echte Verbindung hergestellt, daher kann die angegebene Remote-IP nicht erreichbar sein.

Bearbeiten:

Wie @macomgil sagt, können Sie dies unter MacOS wie folgt tun:

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

Dies kann im allgemeinsten Fall etwas schwierig sein.

Auf den ersten Blick InetAddress.getLocalHost()sollte Ihnen die IP-Adresse dieses Hosts geben. Das Problem ist, dass ein Host viele Netzwerkschnittstellen haben kann und eine Schnittstelle an mehr als eine IP-Adresse gebunden sein kann. Darüber hinaus sind nicht alle IP-Adressen außerhalb Ihres Computers oder Ihres LAN erreichbar. Dies können beispielsweise IP-Adressen für virtuelle Netzwerkgeräte, private Netzwerk-IP-Adressen usw. sein.

Dies bedeutet, dass die von zurückgegebene IP-Adresse InetAddress.getLocalHost()möglicherweise nicht die richtige ist.

Wie können Sie damit umgehen?

• Ein Ansatz besteht darin NetworkInterface.getNetworkInterfaces(), alle bekannten Netzwerkschnittstellen auf dem Host abzurufen und dann die Adressen der einzelnen NI zu durchlaufen.
• Ein anderer Ansatz besteht darin, (irgendwie) den extern angekündigten vollqualifizierten Domänennamen für den Host abzurufen und InetAddress.getByName()die primäre IP-Adresse nachzuschlagen . (Aber wie bekommen Sie es und wie gehen Sie mit einem DNS-basierten Load Balancer um?)
• Eine Variation der vorherigen besteht darin, den bevorzugten vollqualifizierten Domänennamen aus einer Konfigurationsdatei oder einem Befehlszeilenparameter abzurufen.
• Eine andere Variante besteht darin, die bevorzugte IP-Adresse aus einer Konfigurationsdatei oder einem Befehlszeilenparameter abzurufen.

Zusammenfassend InetAddress.getLocalHost()funktioniert dies normalerweise, aber Sie müssen möglicherweise eine alternative Methode für die Fälle bereitstellen, in denen Ihr Code in einer Umgebung mit "kompliziertem" Netzwerk ausgeführt wird.

Ich kann alle IP-Adressen abrufen, die allen Netzwerkschnittstellen zugeordnet sind, aber wie unterscheide ich sie?

• Jede Adresse im Bereich 127.xxx.xxx.xxx ist eine "Loopback" -Adresse. Es ist nur für "diesen" Host sichtbar.
• Jede Adresse im Bereich 192.168.xxx.xxx ist eine private (auch als Site Local bezeichnete) IP-Adresse. Diese sind für die Verwendung innerhalb einer Organisation reserviert. Gleiches gilt für 10.xxx.xxx.xxx-Adressen und 172.16.xxx.xxx bis 172.31.xxx.xxx.
• Adressen im Bereich 169.254.xxx.xxx sind lokale Link-IP-Adressen. Diese sind für die Verwendung in einem einzelnen Netzwerksegment reserviert.
• Adressen im Bereich von 224.xxx.xxx.xxx bis 239.xxx.xxx.xxx sind Multicast-Adressen.
• Die Adresse 255.255.255.255 ist die Broadcast-Adresse.
• Alles andere sollte eine gültige öffentliche Punkt-zu-Punkt-IPv4-Adresse sein.

Tatsächlich bietet die InetAddress-API Methoden zum Testen von Loopback-, Link Local-, Site Local-, Multicast- und Broadcast-Adressen. Sie können diese verwenden, um herauszufinden, welche der IP-Adressen, die Sie zurückerhalten, am besten geeignet ist.

Wenn Sie hier getesteten IP-Ambiguitäts-Workaround-Code von https://issues.apache.org/jira/browse/JCS-40 (InetAddress.getLocalHost () auf Linux-Systemen nicht eindeutig) veröffentlichen:

/**
 * 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;
    }
}

Zu diesem Zweck können Sie die InetAddress- Klasse von Java verwenden.

InetAddress IP=InetAddress.getLocalHost();
System.out.println("IP of my system is := "+IP.getHostAddress());

Ausgabe für mein System = IP of my system is := 10.100.98.228

getHostAddress () gibt zurück

Gibt die IP-Adresszeichenfolge in Textdarstellung zurück.

ODER Sie können auch tun

InetAddress IP=InetAddress.getLocalHost();
System.out.println(IP.toString());

Ausgabe = IP of my system is := RanRag-PC/10.100.98.228

Wenn Sie nach Ihrer "lokalen" Adresse suchen, sollten Sie beachten, dass jeder Computer nicht nur eine einzige Netzwerkschnittstelle hat und jede Schnittstelle möglicherweise eine eigene lokale Adresse hat. Dies bedeutet, dass Ihr Computer immer mehrere "lokale" Adressen besitzt.

Verschiedene "lokale" Adressen werden automatisch ausgewählt, wenn Sie eine Verbindung zu verschiedenen Endpunkten herstellen. Wenn Sie beispielsweise eine Verbindung herstellen google.com, verwenden Sie eine lokale Adresse "außerhalb". Wenn Sie jedoch eine Verbindung zu Ihrem herstellen localhost, ist Ihre lokale Adresse immer localhostselbst, da localhost nur ein Loopback ist.

Im Folgenden erfahren Sie, wie Sie Ihre lokale Adresse ermitteln, wenn Sie mit google.comfolgenden Personen kommunizieren :

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

Beispiel in Scala (nützlich in 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
  }

BEARBEITEN 1: Der aktualisierte Code ist seit dem vorherigen Link nicht mehr vorhanden

import java.io.*;
import java.net.*;

public class GetMyIP {
    public static void main(String[] args) {
        URL url = null;
        BufferedReader in = null;
        String ipAddress = "";
        try {
            url = new URL("http://bot.whatismyipaddress.com");
            in = new BufferedReader(new InputStreamReader(url.openStream()));
            ipAddress = in.readLine().trim();
            /* IF not connected to internet, then
             * the above code will return one empty
             * String, we can check it's length and
             * if length is not greater than zero, 
             * then we can go for LAN IP or Local IP
             * or PRIVATE IP
             */
            if (!(ipAddress.length() > 0)) {
                try {
                    InetAddress ip = InetAddress.getLocalHost();
                    System.out.println((ip.getHostAddress()).trim());
                    ipAddress = (ip.getHostAddress()).trim();
                } catch(Exception exp) {
                    ipAddress = "ERROR";
                }
            }
        } catch (Exception ex) {
            // This try will give the Private IP of the Host.
            try {
                InetAddress ip = InetAddress.getLocalHost();
                System.out.println((ip.getHostAddress()).trim());
                ipAddress = (ip.getHostAddress()).trim();
            } catch(Exception exp) {
                ipAddress = "ERROR";
            }
            //ex.printStackTrace();
        }
        System.out.println("IP Address: " + ipAddress);
    }
}

TATSÄCHLICHE VERSION: Dies funktioniert nicht mehr

Hoffentlich kann Ihnen dieses Snippet dabei helfen:

// Method to get the IP Address of the Host.
private String getIP()
{
    // This try will give the Public IP Address of the Host.
    try
    {
        URL url = new URL("http://automation.whatismyip.com/n09230945.asp");
        BufferedReader in = new BufferedReader(new InputStreamReader(url.openStream()));
        String ipAddress = new String();
        ipAddress = (in.readLine()).trim();
        /* IF not connected to internet, then
         * the above code will return one empty
         * String, we can check it's length and
         * if length is not greater than zero, 
         * then we can go for LAN IP or Local IP
         * or PRIVATE IP
         */
        if (!(ipAddress.length() > 0))
        {
            try
            {
                InetAddress ip = InetAddress.getLocalHost();
                System.out.println((ip.getHostAddress()).trim());
                return ((ip.getHostAddress()).trim());
            }
            catch(Exception ex)
            {
                return "ERROR";
            }
        }
        System.out.println("IP Address is : " + ipAddress);

        return (ipAddress);
    }
    catch(Exception e)
    {
        // This try will give the Private IP of the Host.
        try
        {
            InetAddress ip = InetAddress.getLocalHost();
            System.out.println((ip.getHostAddress()).trim());
            return ((ip.getHostAddress()).trim());
        }
        catch(Exception ex)
        {
            return "ERROR";
        }
    }
}

Importieren Sie zuerst die Klasse

import java.net.InetAddress;

im Unterricht

  InetAddress iAddress = InetAddress.getLocalHost();
  String currentIp = iAddress.getHostAddress();
  System.out.println("Current IP address : " +currentIp); //gives only host address

Sie können java.net.InetAddressAPI verwenden. Versuche dies :

InetAddress.getLocalHost().getHostAddress();

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;
    }

Dies ist ein funktionierendes Beispiel für die oben akzeptierte Antwort! Diese NetIdentity-Klasse speichert sowohl die interne Host-IP als auch den lokalen Loopback. Wenn Sie sich wie oben erwähnt auf einem DNS-basierten Server befinden, müssen Sie möglicherweise weitere Überprüfungen hinzufügen oder möglicherweise die Route der Konfigurationsdatei wählen.

import java.net.InetAddress;
import java.net.NetworkInterface;
import java.net.SocketException;
import java.net.UnknownHostException;
import java.util.Enumeration;

/**
 * Class that allows a device to identify itself on the INTRANET.
 * 
 * @author Decoded4620 2016
 */
public class NetIdentity {

    private String loopbackHost = "";
    private String host = "";

    private String loopbackIp = "";
    private String ip = "";
    public NetIdentity(){

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

            while(interfaces.hasMoreElements()){
                NetworkInterface i = interfaces.nextElement();
                if(i != null){
                    Enumeration<InetAddress> addresses = i.getInetAddresses();
                    System.out.println(i.getDisplayName());
                    while(addresses.hasMoreElements()){
                        InetAddress address = addresses.nextElement();
                        String hostAddr = address.getHostAddress();

                        // local loopback
                        if(hostAddr.indexOf("127.") == 0 ){
                            this.loopbackIp = address.getHostAddress();
                            this.loopbackHost = address.getHostName();
                        }

                        // internal ip addresses (behind this router)
                        if( hostAddr.indexOf("192.168") == 0 || 
                                hostAddr.indexOf("10.") == 0 || 
                                hostAddr.indexOf("172.16") == 0 ){
                            this.host = address.getHostName();
                            this.ip = address.getHostAddress();
                        }


                        System.out.println("\t\t-" + address.getHostName() + ":" + address.getHostAddress() + " - "+ address.getAddress());
                    }
                }
            }
        }
        catch(SocketException e){

        }
        try{
            InetAddress loopbackIpAddress = InetAddress.getLocalHost();
            this.loopbackIp = loopbackIpAddress.getHostName();
            System.out.println("LOCALHOST: " + loopbackIp);
        }
        catch(UnknownHostException e){
            System.err.println("ERR: " + e.toString());
        }
    }

    public String getLoopbackHost(){
        return loopbackHost;
    }

    public String getHost(){
        return host;
    }
    public String getIp(){
        return ip;
    }
    public String getLoopbackIp(){
        return loopbackIp;
    }
}

Wenn ich diesen Code ausführe, erhalte ich tatsächlich einen Ausdruck wie folgt:

    Software Loopback Interface 1
        -127.0.0.1:127.0.0.1 - [B@19e1023e
        -0:0:0:0:0:0:0:1:0:0:0:0:0:0:0:1 - [B@7cef4e59
Broadcom 802.11ac Network Adapter
        -VIKING.yourisp.com:192.168.1.142 - [B@64b8f8f4
        -fe80:0:0:0:81fa:31d:21c9:85cd%wlan0:fe80:0:0:0:81fa:31d:21c9:85cd%wlan0 - [B@2db0f6b2
Microsoft Kernel Debug Network Adapter
Intel Edison USB RNDIS Device
Driver for user-mode network applications
Cisco Systems VPN Adapter for 64-bit Windows
VirtualBox Host-Only Ethernet Adapter
        -VIKING:192.168.56.1 - [B@3cd1f1c8
        -VIKING:fe80:0:0:0:d599:3cf0:5462:cb7%eth4 - [B@3a4afd8d
LogMeIn Hamachi Virtual Ethernet Adapter
        -VIKING:25.113.118.39 - [B@1996cd68
        -VIKING:2620:9b:0:0:0:0:1971:7627 - [B@3339ad8e
        -VIKING:fe80:0:0:0:51bf:994d:4656:8486%eth5 - [B@555590
Bluetooth Device (Personal Area Network)
        -fe80:0:0:0:4c56:8009:2bca:e16b%eth6:fe80:0:0:0:4c56:8009:2bca:e16b%eth6 - [B@3c679bde
Bluetooth Device (RFCOMM Protocol TDI)
Intel(R) Ethernet Connection (2) I218-V
        -fe80:0:0:0:4093:d169:536c:7c7c%eth7:fe80:0:0:0:4093:d169:536c:7c7c%eth7 - [B@16b4a017
Microsoft Wi-Fi Direct Virtual Adapter
        -fe80:0:0:0:103e:cdf0:c0ac:1751%wlan1:fe80:0:0:0:103e:cdf0:c0ac:1751%wlan1 - [B@8807e25
VirtualBox Host-Only Ethernet Adapter-HHD Software NDIS 6.0 Filter Driver-0000
VirtualBox Host-Only Ethernet Adapter-WFP Native MAC Layer LightWeight Filter-0000
VirtualBox Host-Only Ethernet Adapter-HHD Software NDIS 6.0 Filter Driver-0001
VirtualBox Host-Only Ethernet Adapter-HHD Software NDIS 6.0 Filter Driver-0002
VirtualBox Host-Only Ethernet Adapter-VirtualBox NDIS Light-Weight Filter-0000
VirtualBox Host-Only Ethernet Adapter-HHD Software NDIS 6.0 Filter Driver-0003
VirtualBox Host-Only Ethernet Adapter-QoS Packet Scheduler-0000
VirtualBox Host-Only Ethernet Adapter-HHD Software NDIS 6.0 Filter Driver-0004
VirtualBox Host-Only Ethernet Adapter-WFP 802.3 MAC Layer LightWeight Filter-0000
VirtualBox Host-Only Ethernet Adapter-HHD Software NDIS 6.0 Filter Driver-0005
Intel(R) Ethernet Connection (2) I218-V-HHD Software NDIS 6.0 Filter Driver-0000
Intel(R) Ethernet Connection (2) I218-V-WFP Native MAC Layer LightWeight Filter-0000
Intel(R) Ethernet Connection (2) I218-V-HHD Software NDIS 6.0 Filter Driver-0001
Intel(R) Ethernet Connection (2) I218-V-Shrew Soft Lightweight Filter-0000
Intel(R) Ethernet Connection (2) I218-V-HHD Software NDIS 6.0 Filter Driver-0002
Intel(R) Ethernet Connection (2) I218-V-VirtualBox NDIS Light-Weight Filter-0000
Intel(R) Ethernet Connection (2) I218-V-HHD Software NDIS 6.0 Filter Driver-0003
Intel(R) Ethernet Connection (2) I218-V-QoS Packet Scheduler-0000
Intel(R) Ethernet Connection (2) I218-V-HHD Software NDIS 6.0 Filter Driver-0004
Intel(R) Ethernet Connection (2) I218-V-WFP 802.3 MAC Layer LightWeight Filter-0000
Intel(R) Ethernet Connection (2) I218-V-HHD Software NDIS 6.0 Filter Driver-0005
Broadcom 802.11ac Network Adapter-WFP Native MAC Layer LightWeight Filter-0000
Broadcom 802.11ac Network Adapter-Virtual WiFi Filter Driver-0000
Broadcom 802.11ac Network Adapter-Native WiFi Filter Driver-0000
Broadcom 802.11ac Network Adapter-HHD Software NDIS 6.0 Filter Driver-0003
Broadcom 802.11ac Network Adapter-Shrew Soft Lightweight Filter-0000
Broadcom 802.11ac Network Adapter-HHD Software NDIS 6.0 Filter Driver-0004
Broadcom 802.11ac Network Adapter-VirtualBox NDIS Light-Weight Filter-0000
Broadcom 802.11ac Network Adapter-HHD Software NDIS 6.0 Filter Driver-0005
Broadcom 802.11ac Network Adapter-QoS Packet Scheduler-0000
Broadcom 802.11ac Network Adapter-HHD Software NDIS 6.0 Filter Driver-0006
Broadcom 802.11ac Network Adapter-WFP 802.3 MAC Layer LightWeight Filter-0000
Broadcom 802.11ac Network Adapter-HHD Software NDIS 6.0 Filter Driver-0007
Microsoft Wi-Fi Direct Virtual Adapter-WFP Native MAC Layer LightWeight Filter-0000
Microsoft Wi-Fi Direct Virtual Adapter-Native WiFi Filter Driver-0000
Microsoft Wi-Fi Direct Virtual Adapter-HHD Software NDIS 6.0 Filter Driver-0002
Microsoft Wi-Fi Direct Virtual Adapter-Shrew Soft Lightweight Filter-0000
Microsoft Wi-Fi Direct Virtual Adapter-HHD Software NDIS 6.0 Filter Driver-0003
Microsoft Wi-Fi Direct Virtual Adapter-VirtualBox NDIS Light-Weight Filter-0000
Microsoft Wi-Fi Direct Virtual Adapter-HHD Software NDIS 6.0 Filter Driver-0004
Microsoft Wi-Fi Direct Virtual Adapter-QoS Packet Scheduler-0000
Microsoft Wi-Fi Direct Virtual Adapter-HHD Software NDIS 6.0 Filter Driver-0005
Microsoft Wi-Fi Direct Virtual Adapter-WFP 802.3 MAC Layer LightWeight Filter-0000
Microsoft Wi-Fi Direct Virtual Adapter-HHD Software NDIS 6.0 Filter Driver-0006

Für meine Verwendung richte ich einen Upnp-Server ein. Es half mir, das gesuchte 'Muster' zu verstehen. Einige der zurückgegebenen Objekte sind Ethernet-Adapter, Netzwerkadapter, virtuelle Netzwerkadapter, Treiber und VPN-Clientadapter. Auch hat nicht alles eine Adresse. Sie sollten also auf Schnittstellenobjekte verzichten, die dies nicht tun.

Sie können dies auch zur Schleife für den Strom hinzufügen NetworkInterface i

while(interfaces.hasMoreElements()){
    Enumeration<InetAddress> addresses = i.getInetAddresses();
    System.out.println(i.getDisplayName());
    System.out.println("\t- name:" + i.getName());
    System.out.println("\t- idx:" + i.getIndex());
    System.out.println("\t- max trans unit (MTU):" + i.getMTU());
    System.out.println("\t- is loopback:" + i.isLoopback());
    System.out.println("\t- is PPP:" + i.isPointToPoint());
    System.out.println("\t- isUp:" + i.isUp());
    System.out.println("\t- isVirtual:" + i.isVirtual());
    System.out.println("\t- supportsMulticast:" + i.supportsMulticast());
}

Und Sie werden Informationen in Ihrer Ausgabe ähnlich sehen:

Software Loopback Interface 1
    - name:lo
    - idx:1
    - max trans unit (MTU):-1
    - is loopback:true
    - is PPP:false
    - isUp:true
    - isVirtual:false
    - supportsMulticast:true
        -ADRESS: [127.0.0.1(VIKING-192.168.56.1)]127.0.0.1:127.0.0.1 - [B@19e1023e
        -ADRESS: [0:0:0:0:0:0:0:1(VIKING-192.168.56.1)]0:0:0:0:0:0:0:1:0:0:0:0:0:0:0:1 - [B@7cef4e59
Broadcom 802.11ac Network Adapter
    - name:wlan0
    - idx:2
    - max trans unit (MTU):1500
    - is loopback:false
    - is PPP:false
    - isUp:true
    - isVirtual:false
    - supportsMulticast:true
        -ADRESS: [VIKING.monkeybrains.net(VIKING-192.168.56.1)]VIKING.monkeybrains.net:192.168.1.142 - [B@64b8f8f4
        -ADRESS: [fe80:0:0:0:81fa:31d:21c9:85cd%wlan0(VIKING-192.168.56.1)]fe80:0:0:0:81fa:31d:21c9:85cd%wlan0:fe80:0:0:0:81fa:31d:21c9:85cd%wlan0 - [B@2db0f6b2
Microsoft Kernel Debug Network Adapter
    - name:eth0
    - idx:3
    - max trans unit (MTU):-1
    - is loopback:false
    - is PPP:false
    - isUp:false
    - isVirtual:false
    - supportsMulticast:true

Verwenden Sie InetAddress.getLocalHost () , um die lokale Adresse abzurufen

import java.net.InetAddress;

try {
  InetAddress addr = InetAddress.getLocalHost();            
  System.out.println(addr.getHostAddress());
} catch (UnknownHostException e) {
}

import java.net.InetAddress;
import java.net.NetworkInterface;
import java.util.Enumeration;

public class IpAddress {

NetworkInterface ifcfg;
Enumeration<InetAddress> addresses;
String address;

public String getIpAddress(String host) {
    try {
        ifcfg = NetworkInterface.getByName(host);
        addresses = ifcfg.getInetAddresses();
        while (addresses.hasMoreElements()) {
            address = addresses.nextElement().toString();
            address = address.replace("/", "");
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
    return ifcfg.toString();
}
}

Ein eher simpler 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();
}

Dadurch wird die IP-Adresse Ihres Netzwerks abgerufen, wenn Ihr Computer Teil eines Netzwerks ist

try {
    System.out.println(InetAddress.getLocalHost().getHostAddress());
} catch (UnknownHostException e) {
    e.printStackTrace();
}

Wenn ich versuche, meine öffentliche IP-Adresse wie cmyip.com oder www.iplocation.net zu finden , gehe ich normalerweise folgendermaßen vor :

public static String myPublicIp() {

    /*nslookup myip.opendns.com resolver1.opendns.com*/
    String ipAdressDns  = "";
    try {
        String command = "nslookup myip.opendns.com resolver1.opendns.com";
        Process proc = Runtime.getRuntime().exec(command);

        BufferedReader stdInput = new BufferedReader(new InputStreamReader(proc.getInputStream()));

        String s;
        while ((s = stdInput.readLine()) != null) {
            ipAdressDns  += s + "\n";
        }
    } catch (IOException e) {
        e.printStackTrace();
    }

    return ipAdressDns ;
}

Da mein System (wie so viele andere Systeme) verschiedene Netzwerkschnittstellen hatte. InetAddress.getLocalHost()oder Inet4Address.getLocalHost()einfach eine zurückgegeben, die ich nicht wollte. Deshalb musste ich diesen naiven Ansatz verwenden.

InetAddress[] allAddresses = Inet4Address.getAllByName("YourComputerHostName");
        InetAddress desiredAddress;
        //In order to find the desired Ip to be routed by other modules (WiFi adapter)
        for (InetAddress address :
                allAddresses) {
            if (address.getHostAddress().startsWith("192.168.2")) {
                desiredAddress = address;
            }
        }
// Use the desired address for whatever purpose.

Seien Sie nur vorsichtig, dass ich bei diesem Ansatz bereits wusste, dass sich meine gewünschte IP-Adresse im 192.168.2Subnetz befindet.

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;
}