Obtenir l'adresse IP de la machine actuelle à l'aide de Java


291

J'essaie de développer un système où il y a différents nœuds qui sont exécutés sur un système différent ou sur différents ports du même système.

Maintenant, tous les nœuds créent un socket avec une IP cible comme IP d'un nœud spécial appelé nœud d'amorçage. Les nœuds créent ensuite le leur ServerSocketet commencent à écouter les connexions.

Le nœud d'amorçage conserve une liste de nœuds et les renvoie lors de l'interrogation.

Maintenant, ce dont j'ai besoin, c'est que le nœud doive enregistrer son IP au nœud d'amorçage. J'ai essayé d'utiliser cli.getInetAddress()une fois que le client se connecte au ServerSocketnœud de démarrage mais cela n'a pas fonctionné.

  1. J'ai besoin que le client enregistre son IP PPP si disponible;
  2. Sinon, l'IP LAN si disponible;
  3. Sinon, il doit s'enregistrer 127.0.0.1 en supposant qu'il s'agit du même ordinateur.

En utilisant le code:

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

ou

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

Mon adresse IP de connexion PPP est: 117.204.44.192 mais ce qui précède me renvoie 192.168.1.2

ÉDITER

J'utilise le code suivant:

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

Je peux obtenir toutes les adresses IP associées à tous les NetworkInterfaces, mais comment les distinguer? Voici la sortie que j'obtiens:

127.0.0.1
192.168.1.2
192.168.56.1
117.204.44.19

Inet4Address.getLocalHost () devrait fonctionner correctement?
Sears India

3
À l'intérieur de la boucle si j'ajoute n.isPointToPoint () cela fonctionnera-t-il ?? Mon idée est de retourner "127.0.0.1" si aucun réseau point à point n'est trouvé. Ça marchera??
sasidhar

3
@sasidhar: Veuillez ne pas publier votre véritable adresse IP. écrivez 117.xxx.xxx.xxx, pour une adresse IP privée, ça va.
nIcE cOw

@GagandeepBali Merci pour les conseils mais mon IP est une IP dynamique et j'obtiens une nouvelle IP chaque fois que je me déconnecte et connecte mon internet. Cela ne devrait donc pas être un problème, je suppose.
sasidhar

Réponses:


115
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();
}

Cette méthode fonctionne bien lorsqu'il existe plusieurs interfaces réseau. Il renvoie toujours l'IP sortante préférée. Il 8.8.8.8n'est pas nécessaire que la destination soit accessible.

Connectsur un socket UDP a l'effet suivant: il définit la destination pour Send / Recv, rejette tous les paquets provenant d'autres adresses et - ce que nous utilisons - transfère le socket dans l'état "connecté", définit ses champs appropriés. Cela comprend la vérification de l'existence de l'itinéraire vers la destination en fonction de la table de routage du système et la définition du point de terminaison local en conséquence. La dernière partie ne semble pas être officiellement documentée, mais elle ressemble à un trait intégral de l'API des sockets Berkeley (un effet secondaire de l'état "connecté" UDP) qui fonctionne de manière fiable dans Windows et Linux à travers les versions et les distributions.

Ainsi, cette méthode donnera l'adresse locale qui serait utilisée pour se connecter à l'hôte distant spécifié. Il n'y a pas de connexion réelle établie, l'IP distante spécifiée peut donc être inaccessible.

Éditer:

Comme le dit @macomgil , pour MacOS, vous pouvez le faire:

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

7
Cela a fonctionné pour moi sur Linux mais sur OsX j'obtiens: "0.0.0.0"
Radu Toader

@Jeef, la réponse est mise à jour. Si cela ne fonctionne pas sur OsX, vous devez choisir une autre façon.
Mr.Wang de Next Door

1
Brillant! Pour votre information, lorsque vous traitez avec un réseau interne fermé, remplacez simplement 8.8.8.8 par quelque chose que chaque hôte peut atteindre
Murphy Ng

Fonctionne sous Windows; pouvons-nous confirmer si OSX est toujours un problème?
trilogie

4
@trilogy Je reçois toujours 0.0.0.0 sur OSX
Peter Tutervai

273

Cela pourrait être un peu délicat dans le cas le plus général.

À première vue, InetAddress.getLocalHost()devrait vous donner l'adresse IP de cet hôte. Le problème est qu'un hôte peut avoir de nombreuses interfaces réseau et qu'une interface peut être liée à plusieurs adresses IP. Et pour couronner le tout, toutes les adresses IP ne seront pas accessibles en dehors de votre machine ou de votre réseau local. Par exemple, il peut s'agir d'adresses IP pour des périphériques réseau virtuels, d'adresses IP de réseau privé, etc.

Cela signifie que l'adresse IP renvoyée par InetAddress.getLocalHost()n'est peut-être pas la bonne à utiliser.

Comment pouvez-vous y faire face?

  • Une approche consiste à utiliser NetworkInterface.getNetworkInterfaces()pour obtenir toutes les interfaces réseau connues sur l'hôte, puis à parcourir les adresses de chaque NI.
  • Une autre approche consiste à (en quelque sorte) obtenir le nom de domaine complet publié en externe pour l'hôte et à utiliser InetAddress.getByName()pour rechercher l'adresse IP principale. (Mais comment l'obtenir et comment gérer un équilibreur de charge basé sur DNS?)
  • Une variante de la précédente consiste à obtenir le nom de domaine complet préféré à partir d'un fichier de configuration ou d'un paramètre de ligne de commande.
  • Une autre variante consiste à obtenir l'adresse IP préférée à partir d'un fichier de configuration ou d'un paramètre de ligne de commande.

En résumé, InetAddress.getLocalHost()cela fonctionne généralement, mais vous devrez peut-être fournir une méthode alternative pour les cas où votre code est exécuté dans un environnement avec un réseau "compliqué".


Je peux obtenir toutes les adresses IP associées à toutes les interfaces réseau, mais comment les distinguer?

  • Toute adresse dans la plage 127.xxx.xxx.xxx est une adresse de "bouclage". Il n'est visible que par "cet" hôte.
  • Toute adresse dans la plage 192.168.xxx.xxx est une adresse IP privée (aka site local). Ceux-ci sont réservés à une utilisation au sein d'une organisation. Il en va de même pour les adresses 10.xxx.xxx.xxx et 172.16.xxx.xxx à 172.31.xxx.xxx.
  • Les adresses de la plage 169.254.xxx.xxx sont des adresses IP locales de liaison. Ceux-ci sont réservés à une utilisation sur un seul segment de réseau.
  • Les adresses comprises entre 224.xxx.xxx.xxx et 239.xxx.xxx.xxx sont des adresses de multidiffusion.
  • L'adresse 255.255.255.255 est l'adresse de diffusion.
  • Tout le reste doit être une adresse IPv4 publique point à point valide.

En fait, l'API InetAddress fournit des méthodes pour tester les adresses de bouclage, de liaison locale, de site local, de multidiffusion et de diffusion. Vous pouvez les utiliser pour déterminer laquelle des adresses IP que vous récupérez est la plus appropriée.


3
Si quelqu'un est curieux, getLocalHost effectue essentiellement une recherche DNS sur le nom d'hôte du serveur. S'il obtient une adresse IP à partir de cette recherche, il recherche les interfaces disponibles pour voir quelle interface a cette adresse IP et il renvoie cette interface. Cela signifie que getLocalHost aura tendance à fonctionner dans un environnement "serveur" où l'adresse IP sortante est celle qui correspond au nom d'hôte du serveur.
Rendez-vous le

1
Sur Ubuntu 14.04, cette api renvoie 127.0.1.1 même si ifconfig ne signale que deux interfaces, celle que je veux (l'adresse IP accessible au public) et le bouclage (127.0.0.1). Bizarre qu'il retourne un alias de bouclage différent.
ctpenrose

J'ajouterai que si vous use getLocalHost().getHostAddress()publiez quelque chose, vous pouvez le voir 0.0.0.0en regardant depuis un autre ordinateur sur le réseau. Ceci est expliqué ici C'est ce qui m'est arrivé lorsque
j'utilisais

57

La publication ici a testé le code de contournement d'ambiguïté IP à partir de https://issues.apache.org/jira/browse/JCS-40 (InetAddress.getLocalHost () ambigu sur les systèmes Linux):

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

6
Il faut noter que cela ne résout toujours pas l'ambiguïté au cas où l'hôte aurait plusieurs interfaces nerwork similaires.
Vadzim

1
la réponse ci-dessous est meilleure - stackoverflow.com/questions/9481865/… obtient l'adresse IP locale utilisée comme src pour Default Gatway
Radu Toader

Pourquoi l'adresse IP est ajoutée avec la barre oblique ..? comme /10.39.0.17 ..?, Est-ce toujours comme ça qu'il faut couper ...?
Kanagavelu Sugumar

51

Vous pouvez utiliser la classe InetAddress de java à cet effet.

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

Sortie pour mon système = IP of my system is := 10.100.98.228

getHostAddress () renvoie

Renvoie la chaîne d'adresse IP dans la présentation textuelle.

OU vous pouvez aussi faire

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

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


9
Notez que 10.xxx est une adresse privée, indiquant que votre système est sur un réseau NAT. Il apparaîtra comme une adresse différente lorsque vous contactez le monde extérieur. Si vous avez vraiment besoin de l'adresse IP externe, vous devrez contacter l'un des nombreux sites qui vous renverront l'adresse IP dont vous venez. Cela peut vous être utile ou non. De toute façon, votre système ne sera presque pas accessible de l'extérieur.
Edward Falk

19

Lorsque vous recherchez votre adresse "locale", vous devez noter que chaque machine n'a pas seulement une seule interface réseau et que chaque interface peut avoir sa propre adresse locale. Ce qui signifie que votre machine possède toujours plusieurs adresses "locales".

Différentes adresses "locales" seront automatiquement choisies à utiliser lorsque vous vous connectez à différents points de terminaison. Par exemple, lorsque vous vous connectez à google.com, vous utilisez une adresse locale "extérieure"; mais lorsque vous vous connectez à votre localhost, votre adresse locale est toujours localhostelle-même, car localhost n'est qu'un bouclage.

Vous trouverez ci-dessous comment trouver votre adresse locale lorsque vous communiquez avec google.com:

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

Impressionnant !! - si facile :)
smilyface

4
ajoutez socket.close () à la fin :)
MC

11

Exemple en scala (utile dans le fichier sbt):

  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
  }

10

EDIT 1: Le code mis à jour, depuis le lien précédent, n'existe plus

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

VERSION RÉELLE: Cela a cessé de fonctionner

J'espère que cet extrait de code pourrait vous aider à y parvenir:

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

2
La solution fonctionnerait, espérons-le, si je suis toujours connecté à Internet, mais je ne le suis pas garanti. En outre, lorsque le système n'est pas connecté à Internet, je dois renvoyer l'adresse IP LAN du système, le cas échéant, sinon l'hôte local. Ce n'est donc pas une option réalisable pour moi. De toute autre manière ??
sasidhar

@sasidhar: Lorsque vous êtes connecté à Internet, ce n'est qu'alors que vous avez votre IP publique, je suppose, si vous n'êtes pas connecté, cette méthode vous donnera votre IP locale ou IP LAN, et pour la dernière condition spécifiée par vous vous pouvez retourner "127.0.0.1", au lieu de renvoyer Error.
nIcE cOw

1
J'aime votre approche mais ce lien ne semble plus fonctionner !! Puis-je mettre un contrôleur sur mon propre système pour fonctionner au lieu de ce lien externe et donc être plus fiable ???
azerafati

1
@Bludream: Merci beaucoup, pour avoir porté cela à ma connaissance, que le lien ne fonctionne plus. J'ai mis à jour le message, avec de nouvelles entrées. Espérons que cela fonctionne pour votre cas d'utilisation. En ce qui concerne votre question, je ne sais vraiment pas comment configurer un contrôleur sur votre propre système pour le faire fonctionner. Je ne pourrai donc pas donner un aperçu de ce sujet, MY BAD. Merci encore et
continuez à sourire

1
Autant que c'est une solution intéressante, elle est extrêmement peu fiable. Si vous deviez bloquer le thread principal (disons) et que pour quelque raison que ce soit whatismyip.cométait en panne pendant un certain temps, votre application serait également en panne :(. Ou elle renverra des données inutiles et provoquera un comportement inattendu. En outre, cela renvoie l'outter la plupart des adresses IP détectables par whatismyip.com, pas nécessairement l'adresse IP de la machine que vous utilisez
Decoded

6

importer d'abord la classe

import java.net.InetAddress;

en classe

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

2
il ne donne que la première adresse ip même si ce n'est pas celle utilisée!
Yahya

6

Vous pouvez utiliser l' java.net.InetAddressAPI. Essaye ça :

InetAddress.getLocalHost().getHostAddress();

5
il reviendra juste 127.0.0.1
HCarrasko

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

1
s'il vous plaît, pensez à ajouter quelques explications sur ce que fait votre code.
HCarrasko

4

Ceci est un exemple de travail de la réponse ACCEPTÉE ci-dessus! Cette classe NetIdentity stockera à la fois l'adresse IP de l'hôte interne et le bouclage local. Si vous êtes sur un serveur basé sur DNS, comme mentionné ci-dessus, vous devrez peut-être ajouter quelques vérifications supplémentaires, ou éventuellement aller sur la route du fichier de configuration.

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

Lorsque j'exécute ce code, j'obtiens une impression comme celle-ci:

    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

Pour mon utilisation, je configure un serveur Upnp, cela a aidé à comprendre le «modèle» que je cherchais. Certains des objets renvoyés sont des cartes Ethernet, des cartes réseau, des cartes réseau virtuelles, des pilotes et des cartes client VPN. Tout n'a pas non plus d'adresse. Vous voudrez donc sauter les objets d'interface qui ne le font pas.

Vous pouvez également l'ajouter à la boucle du courant 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());
}

Et vous verrez des informations dans votre sortie un peu comme ceci:

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

3

Utilisez InetAddress.getLocalHost () pour obtenir l'adresse locale

import java.net.InetAddress;

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

Mon adresse IP de connexion PPP est: 117.204.44.192 Mais ce qui précède me renvoie 192.168.1.2
sasidhar

Vous devez analyser toutes les instances InetAddress disponibles et déterminer laquelle est la bonne.
Décodé

1
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();
}
}

1

Une approche assez simpliste qui semble fonctionner ...

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

1

Ceci obtient l'adresse IP de votre réseau si votre machine fait partie d'un réseau

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

0

Habituellement, lorsque j'essaie de trouver mon adresse IP publique comme cmyip.com ou www.iplocation.net , j'utilise cette méthode:

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

0

Depuis mon système (comme tant d'autres systèmes) avait différentes interfaces réseau. InetAddress.getLocalHost()ou Inet4Address.getLocalHost()simplement retourné celui que je ne désirais pas. J'ai donc dû utiliser cette approche naïve.

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.

Faites juste attention que dans cette approche, je savais déjà que mon adresse IP souhaitée est dans le 192.168.2sous-réseau.


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

veuillez ajouter quelques explications sur ce que fait votre code.
HCarrasko
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.