Validateur regex Java de GUID

Qu'est-ce qu'un GUID en Java ?

Un GUID (ou UUID) est un nombre de 128 bits utilisé pour identifier des données de manière unique dans les systèmes. Il est généralement formaté ainsi :

xxxxxxxx-xxxx-Mxxx-Nxxx-xxxxxxxxxxxx

Où :

• x est un chiffre hexadécimal

• M indique la version

• N indique la variante

Un GUID garantit l'unicité globale dans les systèmes distribués, les bases de données ou les transactions API.

Pattern regex Java pour GUID

Le pattern regex couramment utilisé pour valider les GUID :

^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-5][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}$

Ce qu'il correspond :

• 8 chiffres hexadécimaux

• Un tiret

• 4 chiffres hexadécimaux

• Un tiret

• 4 chiffres hexadécimaux commençant par la version 1-5

• Un tiret

• 4 chiffres hexadécimaux commençant par 8, 9, A ou B (variante)

• Un tiret

• 12 chiffres hexadécimaux

Qu'est-ce qu'un validateur regex et à quoi sert-il ?

Un validateur regex est un outil pratique pour vérifier si une valeur donnée correspond à un ou plusieurs patterns d'expressions régulières. En lui fournissant un pattern, vous pouvez vérifier si des chaînes de texte sont valides selon vos règles. Ce validateur est flexible : vous pouvez le régler pour être strict sur la casse (sensible à la casse) ou traiter 'Java' et 'java' comme équivalents (insensible à la casse).

Cas d'utilisation courants :

• Vérifier si une adresse e-mail est correctement formatée

• Valider des GUID ou UUID

• S'assurer que les entrées utilisateur correspondent à certaines exigences

Exemple de code Java

import java.util.regex.Pattern;
import java.util.regex.Matcher;
public class GUIDValidator {
public static void main(String[] args) {
String input = "3f2504e0-4f89-11d3-9a0c-0305e82c3301";
    String regex = "^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-5][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}$";

    Pattern pattern = Pattern.compile(regex);
    Matcher matcher = pattern.matcher(input);

    if (matcher.matches()) {
        System.out.println("Valid GUID");
    } else {
        System.out.println("Invalid GUID");
    }
}

}

Note : Les patterns sont mis en correspondance avec l'intégralité de l'entrée. Les ancres ^ et $ vérifient du début jusqu'à la fin de la chaîne.

Paramètres des constructeurs du validateur regex

• Pattern unique (sensible à la casse) : Accepte une seule chaîne d'expression régulière.

• Patterns multiples (sensible à la casse) : Accepte un tableau de chaînes d'expressions régulières, permettant une correspondance avec l'une ou l'autre.

• Pattern unique avec sensibilité à la casse personnalisée : Prend une chaîne regex et un indicateur booléen pour la sensibilité à la casse.

• Patterns multiples avec sensibilité à la casse personnalisée : Accepte un tableau de chaînes regex et un booléen pour la sensibilité à la casse.

Comment valider une valeur et récupérer les groupes correspondants

• Passez la valeur à travers le regex à l'aide d'un matcher.

• Si la valeur correspond, utilisez matcher.group() ou matcher.group(n) pour extraire les parties correspondantes.

• Collectez tous les groupes correspondants dans un tableau pour un accès facile.

Méthodes de validation

• Validation booléenne :
  Vérifiez rapidement si une valeur correspond à un pattern.
  boolean valid = pattern.matcher(value).matches();

• Récupérer les groupes correspondants sous forme de chaîne :
  String result = matcher.group();

• Récupérer tous les groupes correspondants sous forme de tableau :
  Parcourez matcher.group(i) pour les patterns complexes.

Que retournent isValid, match et validate en cas d'échec ?

• isValid : Retourne false si la valeur ne correspond pas au pattern.

• match : En cas d'échec de validation, retourne null au lieu d'un tableau de groupes.

• validate : En cas d'échec, retourne null au lieu d'une chaîne agrégée.

Exemples d'entrées

GUID valides :

• 3f2504e0-4f89-11d3-9a0c-0305e82c3301

• 123e4567-e89b-12d3-a456-426614174000

• 550e8400-e29b-41d4-a716-446655440000

GUID invalides :

• 3f2504e0-4f89-11d3-9a0c0305e82c3301 (tiret manquant)

• zzzzzzzz-zzzz-zzzz-zzzz-zzzzzzzzzzzz (caractères non hexadécimaux)

• 12345 (trop court)

Conseils avancés

• Validez toujours les GUID avant de les stocker ou de les utiliser dans des API ou des sessions.

• Les GUID sont insensibles à la casse. Votre regex doit permettre les majuscules et minuscules (utilisez a-fA-F).

• Supprimez les espaces ou caractères invisibles avant d'exécuter les vérifications regex.

• Pour une validation plus stricte, créez des patterns spécifiques à chaque version (par exemple, uniquement les UUID v4).

• N'exposez jamais directement des GUID internes ou sensibles : hachez-les ou encodez-les avec un générateur de hash ou un Encodeur base64.

Cas d'utilisation

• Validation de clés API : S'assurer que les tokens transmis suivent la structure GUID.

• Clés de base de données : Confirmer le format des clés primaires ou étrangères.

• Systèmes de journalisation : Nettoyer et valider les identifiants de journaux basés sur des UUID.

• Soumissions de formulaires : N'accepter que des GUID correctement formatés dans les champs de formulaire.

Outils à associer

• Validateur regex Java d'UUID : Vérifiez les UUID généraux avec une correspondance spécifique à la version.

• Testeur de regex Java : Ajustez et testez des variations regex pour différents formats.

• Générateur de tokens : Générez des tokens uniques qui imitent les formats GUID.

• Encodeur base64 : Encodez les GUID validés pour une transmission ou un stockage sécurisé.