Validation d'une chaîne IPv4 en Java

Question

La méthode ci-dessous valide si la chaîne de caractères est une adresse IPv4 correcte et renvoie vrai si elle est valide. Toute amélioration en matière de regex et d'élégance serait très appréciée :

public static boolean validIP(String ip) {
    if (ip == null || ip.isEmpty()) return false;
    ip = ip.trim();
    if ((ip.length() < 6) & (ip.length() > 15)) return false;

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

Answer 1

Voici une façon plus facile à lire, mais légèrement moins efficace, de procéder.

public static boolean validIP (String ip) {
    try {
        if ( ip == null || ip.isEmpty() ) {
            return false;
        }

        String[] parts = ip.split( "\\." );
        if ( parts.length != 4 ) {
            return false;
        }

        for ( String s : parts ) {
            int i = Integer.parseInt( s );
            if ( (i < 0) || (i > 255) ) {
                return false;
            }
        }
        if ( ip.endsWith(".") ) {
            return false;
        }

        return true;
    } catch (NumberFormatException nfe) {
        return false;
    }
}

Answer 2

UPDATE : Commons-HttpClient et son successeur HttpComponents-HttpClient ont adopté cette fonctionnalité. Vous pouvez utiliser cette version de la manière suivante : InetAddressUtils.isIPv4Address(Str) .

---

La version de développement de Valideur Apache Commons a un InetAddressValidator qui a une isValidInet4Address(String) afin de vérifier qu'un élément donné de la base de données de l'UE est bien présent. String est une adresse IPv4 valide.

El code source peut être consulté à partir du référentiel, ce qui pourrait donner des idées d'améliorations, si vous pensez qu'il en existe.

Un coup d'œil rapide sur le code fourni montre que votre méthode compile une Pattern à chaque invocation de la méthode. Je déplacerais cette Pattern à une classe static afin d'éviter le coûteux processus de compilation de motifs à chaque appel.

Answer 3

Si vous souhaitez utiliser une bibliothèque dont la version publiée prend en charge les protocoles IPv4 et IPv6, vous pouvez utiliser la méthode suivante Goyave

boolean isValid = InetAddresses.isInetAddress("1.2.3.4");

Answer 4

Voici une solution qui utilise les flux Java 8 pour vérifier que l'adresse est constituée d'exactement 4 chiffres compris entre 0 et 255 inclus, séparés par des points :

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) {
        // Check whether string has a leading zero but is not "0"
        if (string.startsWith("0")) {
            return string.length() == 1;
        }
        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]
    }
}

Answer 5

Si cela ne vous dérange pas d'utiliser la résolution DNS pour des adresses IP invalides comme www.example.com vous pouvez utiliser l'option InetAddress méthodes à vérifier :

public static final boolean checkIPv4(final String ip) {
    boolean isIPv4;
    try {
    final InetAddress inet = InetAddress.getByName(ip);
    isIPv4 = inet.getHostAddress().equals(ip)
            && inet instanceof Inet4Address;
    } catch (final UnknownHostException e) {
    isIPv4 = false;
    }
    return isIPv4;
}

La méthode vérifie s'il s'agit d'une instance de Inet4Address et si le paramètre était l'adresse IP et non le nom d'hôte. Si vous attendez beaucoup de noms d'hôtes comme paramètres, sachez que cette implémentation utilise le DNS pour essayer de les résoudre. Cela peut poser un problème de performance.

Sinon, vous pouvez avoir un aperçu de boolean sun.net.util.IPAddressUtil.isIPv4LiteralAddress(String src) comment la chaîne est analysée pour la vérification de l'IPv4.