java uuid generator

Générateur d'UID Java (JUG)

JUG est un ensemble de classes Java permettant de travailler avec des UUID : génération d'UUID à l'aide de l'une des méthodes standard, sortie efficace, tri, etc. Il génère des UUID selon la spécification UUID (RFC-4122) (voir la page Wikipédia UUID pour plus d'explications)

JUG a été écrit par Tatu Saloranta ([email protected]) à l'origine en 2002 et a été mis à jour au fil des ans. De plus, de nombreuses autres personnes ont aidé à corriger des bugs et à implémenter de nouvelles fonctionnalités : veuillez consulter release-notes/CREDITS pour la liste complète.

JUG est sous licence Apache License 2.0.

Versions UUID prises en charge (1, 3, 4, 5, 6, 7)

JUG prend en charge les deux versions "classiques" définies dans la RFC 4122] :

• 1 : heure/lieu - basé sur
• 3 et 5 : nom basé sur le hachage
• 4 : basé sur un nombre aléatoire

et variantes nouvellement (en 2022-2024) proposées (voir uuid6 et RFC-4122 bis) :

• 6 : variante réordonnée de la version 1 (avec classement lexicographique)
• 7 : horodatage Unix + variante aléatoire (également avec ordre lexicographique)

Statut

Taper	Statut
Construire (CI)
Artefact
Parrainage de l'OSS
Javadocs
Couverture du code (5.x)
Score OpenSSF

Usage

JUG peut être utilisé comme outil de ligne de commande (via la classe com.fasterxml.uuid.Jug ) ou comme composant enfichable.

Dépendance Maven

Les coordonnées Maven sont :

< dependency >
  < groupId >com.fasterxml.uuid</ groupId >
  < artifactId >java-uuid-generator</ artifactId >
  < version >5.1.0</ version >
</ dependency >

Graduation :

implementation ' com.fasterxml.uuid:java-uuid-generator:5.1.0 ' 

Dépendances tierces par JUG

La seule dépendance de JUG est la bibliothèque de journalisation :

• Pour les versions jusqu'à 3.x, log4j est utilisé, en option (dépendance d'exécution)
• Pour les versions 4.x et supérieures, l'API slf4j est utilisée : implémentation de la journalisation à fournir par l'application appelante

Informations sur le module JDK9+

Depuis la version 3.2.0 , JUG définit module-info.class compatible JDK9+, avec le nom de module com.fasterxml.uuid .

Téléchargements

Pour des téléchargements directs, consultez Project Wiki.

Utiliser JUG comme bibliothèque

Générer des UUID

Le cas d'utilisation initial de JUG était la génération de valeurs UUID. Cela se fait en sélectionnant d’abord un type de générateur à utiliser, puis en appelant sa méthode generate() . Par exemple:

 UUID uuid = Generators . timeBasedGenerator (). generate (); // Version 1
UUID uuid = Generators . randomBasedGenerator (). generate (); // Version 4
UUID uuid = Generators . nameBasedgenerator (). generate ( "string to hash" ); // Version 5
// With JUG 4.1+: support for https://github.com/uuid6/uuid6-ietf-draft versions 6 and 7:
UUID uuid = Generators . timeBasedReorderedGenerator (). generate (); // Version 6
UUID uuid = Generators . timeBasedEpochGenerator (). generate (); // Version 7
// With JUG 5.0 added variation:
UUID uuid = Generators . timeBasedEpochRandomGenerator (). generate (); // Version 7 with per-call random values

Si vous souhaitez personnaliser les générateurs, vous pouvez également simplement conserver l'instance du générateur :

 TimeBasedGenerator gen = Generators . timeBasedGenerator ( EthernetAddress . fromInterface ());
UUID uuid = gen . generate ();
UUID anotherUuid = gen . generate ();

Si votre machine dispose d'une configuration réseau IP standard, la méthode d'usine Generators.defaultTimeBasedGenerator (ajoutée dans JUG 4.2) tentera de déterminer quelle interface réseau correspond à la route par défaut pour tout le trafic réseau sortant et l'utilisera pour créer un générateur basé sur le temps. C'est probablement un bon choix pour les scénarios d'utilisation courants si vous souhaitez un générateur d'UUID version 1.

 TimeBasedGenerator gen = Generators . defaultTimeBasedGenerator ();
UUID uuid = gen . generate ();
UUID anotherUuid = gen . generate ();

Les générateurs sont entièrement thread-safe, de sorte qu'une seule instance peut être partagée entre plusieurs threads.

Des Javadocs pour plus d’informations peuvent être trouvés sur Project Wiki.

Conversion des valeurs java.util.UUID en octet[]

Parfois, vous souhaiterez peut-être convertir java.util.UUID en sérialisation externe : par exemple, sous forme String ou de tableaux d'octets ( byte[] ). La conversion en String est facile avec UUID.toString() (fourni par JDK), mais il n'existe pas de fonctionnalité similaire pour la conversion en byte[] .

Mais la classe UUIDUtil fournit des méthodes pour des conversions efficaces :

 byte[] asBytes = UUIDUtil.asByteArray(uuid);
// or if you have longer buffer already
byte[] outputBuffer = new byte[1000];
// append at position #100
UUIDUtil.toByteArray(uuid, outputBuffer, 100);

Construction de valeurs java.util.UUID à partir de String, byte[]

Les valeurs UUID sont souvent transmises sous forme de java String ou byte[] (tableaux d'octets), et une conversion est nécessaire pour accéder aux instances java.util.UUID réelles. JUG a une fonctionnalité de conversion optimisée disponible via la classe UUIDUtil (package com.fasterxml.uuid.impl ), utilisée comme suit :

 UUID uuidFromStr = UUIDUtil.uuid("ebb8e8fe-b1b1-11d7-8adb-00b0d078fa18");
byte[] rawUuidBytes = ...; // byte array with 16 bytes
UUID uuidFromBytes = UUIDUtil.uuid(rawUuidBytes)

Notez que même si JDK dispose de fonctionnalités permettant de construire UUID à partir de String , comme ceci :

 UUID uuidFromStr = UUID.fromString("ebb8e8fe-b1b1-11d7-8adb-00b0d078fa18");

elle est plutôt plus lente que la version JUG : pour plus d'informations, lisez Mesure des performances de Java UUID.fromString().

Utiliser JUG comme CLI

Pot JUG construit sous target/ :

 target/java-uuid-generator-5.1.0-SNAPSHOT.jar

peut également être utilisé comme un simple outil de génération d'UUID en ligne de commande.

Pour voir l'utilisation, vous pouvez faire quelque chose comme :

 java -jar target/java-uuid-generator-5.1.0-SNAPSHOT.jar

et obtenez des instructions complètes, mais pour générer 5 UUID aléatoires, vous utiliserez :

 java -jar target/java-uuid-generator-5.1.0-SNAPSHOT.jar -c 5 r

(où -c (ou --count ) signifie le nombre d'UUID à générer et r signifie la version aléatoire)

REMARQUE : cette fonctionnalité est incluse à partir de JUG 4.1. Avec les versions antérieures, vous auriez besoin d'un appel un peu plus long car les métadonnées Jar ne spécifiaient pas "Main-Class". Si c'est le cas, vous devrez utiliser

 java -cp target/java-uuid-generator-5.1.0-SNAPSHOT.jar com.fasterxml.uuid.Jug -c 5 r

Compatibilité

Les versions 3.1 et ultérieures de JUG nécessitent JDK 1.6 pour fonctionner, principalement pour pouvoir accéder à l'adresse MAC Ethernet locale. Les versions antérieures (3.0 et antérieures) fonctionnaient sur la version 1.4 (qui introduisait java.util.UUID ).

Les versions 5.0 et ultérieures de JUG nécessitent JDK 8 pour fonctionner.

Problèmes connus

java.util.UUID du JDK a une implémentation défectueuse de compareTo() , qui utilise une comparaison naïve de valeurs 64 bits. Cela ne fonctionne PAS comme prévu, étant donné que le contenu sous-jacent n’est à aucune fin non signé. Par exemple deux UUID :

 7f905a0b-bb6e-11e3-9e8f-000000000000
8028f08c-bb6e-11e3-9e8f-000000000000

serait ordonné avec le deuxième en premier, en raison de l'extension du signe (la deuxième valeur est considérée comme négative, et donc "plus petite").

Pour cette raison, vous devez toujours utiliser un comparateur externe, tel que com.fasterxml.uuid.UUIDComparator , qui implémente l'ordre de tri attendu qui est un simple tri non signé, qui est également le même que le tri lexicographique (alphabétique) des UUID (en supposant une majuscule uniforme) .

Assistance aux entreprises

Disponible dans le cadre de l’abonnement Tidelift.

Les responsables de java-uuid-generator et de milliers d'autres packages travaillent avec Tidelift pour fournir un support commercial et une maintenance pour les dépendances open source que vous utilisez pour créer vos applications. Gagnez du temps, réduisez les risques et améliorez la santé du code, tout en rémunérant les responsables des dépendances exactes que vous utilisez. Apprendre encore plus.

Contribuer

Pour de simples rapports de bugs, des correctifs et des demandes de fonctionnalités, veuillez simplement utiliser le projet Issue Tracker, à l'exception des problèmes liés à la sécurité pour lesquels nous vous recommandons de contacter le contact de sécurité de Tidelift (REMARQUE : vous n'avez PAS besoin d'être abonné pour ce faire).

Générateurs alternatifs d'UUID JVM

Il existe de nombreux autres générateurs d'UUID accessibles au public. Par exemple:

• Apache Commons IO a un générateur d'UUID
• eaio-uuid
• JDK inclut java.util.UUID depuis la version 1.4, mais omet les méthodes de génération (en particulier celles basées sur l'heure et le lieu), a des performances inférieures aux normes pour de nombreuses opérations et implémente la comparaison de manière inutile.
• Générateur d'UUID ohannburkard.de

Notez que même si certains packages prétendent être plus rapides que d’autres, ce n’est pas clair :

1. si les allégations ont été correctement vérifiées (ou, si elles l'ont été, peuvent être vérifiées de manière indépendante), OU
2. si les différences de performances sont vraiment importantes : JUG, par exemple, peut générer des millions d'UUID par seconde et par cœur (atteignant parfois la limite théorique de 10 millions par seconde) - et il semble peu probable que la génération soit un goulot d'étranglement pour un cas d'utilisation réel.

il est donc souvent préférable de choisir en fonction de la stabilité des packages et de l'API.