Überprüfen der IPv4-Zeichenfolge in Java

UPDATE: Commons-HttpClient und seine Nachfolger HttpComponents-HttpClient angenommen haben, diese Funktionalität. Nutzen Sie diese version von es etwa so: InetAddressUtils.isIPv4Address(Str).

Die Entwickler-version von Apache Commons Validator hat eine InetAddressValidator class, die eine isValidInet4Address(String) Methode, um eine überprüfung durchführen, um zu sehen, dass einer bestimmten String ist eine gültige IPv4-Adresse.

Den Quellcode angezeigt werden können aus dem repository, so dass vielleicht einige Ideen für Verbesserungen, wenn Sie spürt, dass es Sie gibt.

Einen schnellen Blick in den code zeigt, dass Ihre Methode zu kompilieren Pattern bei jedem Aufruf der Methode. Ich würde zu bewegen, dass Pattern Klasse zu einem static Feld zu vermeiden, die kostspieligen Muster Kompilierung bei jedem Aufruf.

InformationsquelleAutor der Antwort coobird

Hier ist eine Lösung, die mit Java 8 streams, um zu überprüfen, dass die Adresse besteht aus genau 4 zahlen zwischen 0 und 255 inklusive sein, die durch Punkte getrennt sind:

public class IpValidation {

    /**
     * Check that a string represents a decimal number
     * @param string The string to check
     * @return true if string consists of only numbers without leading zeroes, false otherwise
     */
    public static boolean isDecimal(String string) {
        if (string.startsWith("0")) {
            if (string.length() == 1) {
                 //"0"
                 return true;
            }
            //The string has a leading zero but is not "0"
            return false;
        }
        for(char c : string.toCharArray()) {
            if(c < '0' || c > '9') {
                return false;
            }
        }
        return true;
    }

    public static boolean isIp(String string) {
        String[] parts = string.split("\\.", -1);
        return parts.length == 4 //4 parts
                && Arrays.stream(parts)
                .filter(IpValidation::isDecimal) //Only decimal numbers
                .map(Integer::parseInt)
                .filter(i -> i <= 255 && i >= 0) //Must be inside [0, 255]
                .count() == 4; //4 numerical parts inside [0, 255]
    }
}

InformationsquelleAutor der Antwort Raniz

Finden, regex Beispiel aus diese

package com.mkyong.regex;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class IPAddressValidator{

    private Pattern pattern;
    private Matcher matcher;

    private static final String IPADDRESS_PATTERN = 
        "^([01]?\\d\\d?|2[0-4]\\d|25[0-5])\\." +
        "([01]?\\d\\d?|2[0-4]\\d|25[0-5])\\." +
        "([01]?\\d\\d?|2[0-4]\\d|25[0-5])\\." +
        "([01]?\\d\\d?|2[0-4]\\d|25[0-5])$";

    public IPAddressValidator(){
      pattern = Pattern.compile(IPADDRESS_PATTERN);
    }

   /**
    * Validate ip address with regular expression
    * @param ip ip address for validation
    * @return true valid ip address, false invalid ip address
    */
    public boolean validate(final String ip){         
      matcher = pattern.matcher(ip);
      return matcher.matches();             
    }
}

InformationsquelleAutor der Antwort bigspawn

Wenn Sie code verwenden, die in der Frage, Sie werden wollen, ändern Sie die Zeile:

if ((ip.length() < 6) & (ip.length() > 15)) return false;

zu

if ((ip.length() <= 6) || (ip.length() > 15)) return false;

InformationsquelleAutor der Antwort jtbr

Ich denke, der richtige Weg ist und bauen eine IPAddress Klasse und instantiieren, indem es eine string-Repräsentation der ip-Adresse.

Diese Weise können Sie split, die verschiedenen Validierungs-Schritte in Instanz-Methoden und Holen Sie sich einige Trennung der Anliegen gehen.

Zum Beispiel, dieser hier ist in der Regel seine eigene Methode, rufen Sie diese einfach isEmpty:

return (ip == null || ip.isEmpty());

Auch dies sollte eine separate Methode, man könnte nennen dies eine hasProbableLength.

ip = ip.trim();
return ((ip.length() < 6) & (ip.length() > 15));

Hier gibt es viele Dinge, auf. Ich würde versuchen, diese zu brechen und vielleicht versuchen, überspringen Sie die regex vollständig.

try {
    Pattern pattern = Pattern.compile("^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$");
    Matcher matcher = pattern.matcher(ip);
    return matcher.matches();
} catch (PatternSyntaxException ex) {
    return false;
}

Ich würde erstmal split die Zeichenfolge, die auf Punkten und sehen, dass ich genau vier Gruppen. Rufen Sie diese Methode auf divideIntoGroups

Ich würde dann überprüfen Sie jede der Gruppen, für die ein Wert zwischen 0 und 255. Rufen Sie diese Methode auf validateGroups

Nun, dass Sie diese, wenn Sie jemals wollen, um diese Klasse erweitern, um auch Aussehen, wenn die IP "localhost" oder, wenn es eine broadcast-Adresse, es ist ziemlich einfach, dies zu tun. Dies ist, was Trennung der Anliegen gibt Sie.

Können Sie auch genau sagen, welche Ihrer Validierungsregeln gebrochen wurde in der Validierung der IP-Adresse string. Etwas, dass regex nicht.

InformationsquelleAutor der Antwort firelynx

Meisten Antworten (außer die von Michael Konietzka) sind falsch: 10.8, zum Beispiel, ist eine gültige IP4-Adresse (Abkürzung für "10.0.0.8" konfiguriert).

SehenTextliche Darstellung von IP-Adressen in der Java-Spezifikationen.

Wie gesehen werden kann in der Referenz, um zu überprüfen, eine numerische Darstellung, es können 1 bis 4 Teile, und in jedem Fall unterschiedliche Einschränkungen auf die Teile gelten.

InformationsquelleAutor der Antwort Jonathan Rosenne

boolean isValid = inetAddressValidator.isValid(hostName) || hostName.equalsIgnoreCase("localhost");

gleiche Antwort wie coobird. Fügen Sie einfach localhost auf die Erklärung. Die meisten der Umgebungen nimmt Sie "localhost" als einen gültigen host-Namen. Es ist nicht eine ipv4-format, aber es sollte auch zu Bedenken Gültigkeit.

InformationsquelleAutor der Antwort rinjan

Die IP-Adresse Java-Bibliothek wird es tun. In der javadoc steht im link. Disclaimer: ich bin der Projekt manager.

Diese Bibliothek unterstützt IPv4 und IPv6 transparent, so dass die Validierung entweder funktioniert auf die gleiche unten), und es unterstützt auch die CIDR-Präfix-Länge IPC4-Adressen als auch. Es unterstützt die ungewöhnliche Formate wie inet_aton (zum Beispiel 10.8 bereits erwähnt wurde, in einer anderen Antwort hier)

Überprüfen, ob eine Adresse gültig ist:

    String str = "1.2.3.4";
    IPAddressString addrString = new IPAddressString(str);
    try {
         IPAddress addr = addrString.toAddress();
         ...
    } catch(AddressStringException e) {
        //e.getMessage provides validation issue
    }

InformationsquelleAutor der Antwort Sean F