java uuid generator
1.0.0
JUG é um conjunto de classes Java para trabalhar com UUIDs: gerar UUIDs usando qualquer um dos métodos padrão, gerar saída de forma eficiente, classificar e assim por diante. Ele gera UUIDs de acordo com a especificação UUID (RFC-4122) (consulte a página UUID da Wikipedia para obter mais explicações)
JUG foi escrito por Tatu Saloranta ([email protected]) originalmente em 2002 e foi atualizado ao longo dos anos. Além disso, muitas outras pessoas ajudaram a corrigir bugs e implementar novos recursos: consulte release-notes/CREDITS para obter a lista completa.
JUG é licenciado sob Licença Apache 2.0.
JUG suporta ambas as versões "clássicas" definidas na RFC 4122]:
1 : baseado em hora/local3 e 5 : baseado em hash de nome4 : baseado em números aleatóriose variantes propostas recentemente (em 2022-2024) (ver uuid6 e RFC-4122 bis):
6 : variante reordenada da versão 1 (com ordenação lexicográfica)7 : carimbo de data/hora Unix + variante aleatória (também com ordenação lexicográfica) | Tipo | Status |
|---|---|
| Construir (CI) | |
| Artefato | |
| Patrocínio OSS | |
| Javadocs | |
| Cobertura de código (5.x) | |
| Pontuação OpenSSF |
JUG pode ser usado como uma ferramenta de linha de comando (via classe com.fasterxml.uuid.Jug ) ou como um componente conectável.
As coordenadas Maven são:
< dependency >
< groupId >com.fasterxml.uuid</ groupId >
< artifactId >java-uuid-generator</ artifactId >
< version >5.1.0</ version >
</ dependency >Gradil:
implementation ' com.fasterxml.uuid:java-uuid-generator:5.1.0 ' A única dependência do JUG é a biblioteca de log:
log4j é usado, opcionalmente (dependência de tempo de execução)slf4j é usada: implementação de registro a ser fornecida pela chamada do aplicativo Desde a versão 3.2.0 , o JUG define module-info.class compatível com JDK9+, com o nome do módulo com.fasterxml.uuid .
Para downloads diretos, confira o Project Wiki.
O caso de uso original do JUG era a geração de valores UUID. Isso é feito primeiro selecionando um tipo de gerador a ser usado e, em seguida, chamando seu método generate() . Por exemplo:
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 valuesSe você quiser personalizar geradores, você também pode querer apenas manter a instância do gerador:
TimeBasedGenerator gen = Generators . timeBasedGenerator ( EthernetAddress . fromInterface ());
UUID uuid = gen . generate ();
UUID anotherUuid = gen . generate (); Se sua máquina tiver uma configuração de rede IP padrão, o método de fábrica Generators.defaultTimeBasedGenerator (adicionado no JUG 4.2) tentará determinar qual interface de rede corresponde à rota padrão para todo o tráfego de rede de saída e usará isso para criar um gerador baseado em tempo. Esta é provavelmente uma boa escolha para cenários de uso comuns se você quiser um gerador UUID versão 1.
TimeBasedGenerator gen = Generators . defaultTimeBasedGenerator ();
UUID uuid = gen . generate ();
UUID anotherUuid = gen . generate ();Os geradores são totalmente thread-safe, portanto, uma única instância pode ser compartilhada entre vários threads.
Javadocs para mais informações podem ser encontrados no Project Wiki.
java.util.UUID em byte[] Às vezes você pode querer converter de java.util.UUID em serialização externa: por exemplo, como String s ou matrizes de bytes ( byte[] ). A conversão para String é fácil com UUID.toString() (fornecido pelo JDK), mas não há funcionalidade semelhante para conversão em byte[] .
Mas a classe UUIDUtil fornece métodos para conversões eficientes:
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);
java.util.UUID de String, byte[] Os valores UUID são frequentemente passados como java String s ou byte[] s (matrizes de bytes), e a conversão é necessária para chegar às instâncias java.util.UUID reais. JUG otimizou a funcionalidade de conversão disponível por meio da classe UUIDUtil (pacote com.fasterxml.uuid.impl ), usada da seguinte forma:
UUID uuidFromStr = UUIDUtil.uuid("ebb8e8fe-b1b1-11d7-8adb-00b0d078fa18");
byte[] rawUuidBytes = ...; // byte array with 16 bytes
UUID uuidFromBytes = UUIDUtil.uuid(rawUuidBytes)
Observe que, embora o JDK tenha funcionalidade para construir UUID a partir de String , assim:
UUID uuidFromStr = UUID.fromString("ebb8e8fe-b1b1-11d7-8adb-00b0d078fa18");
é um pouco mais lento que a versão JUG: para obter mais informações, leia Medindo o desempenho do Java UUID.fromString().
Jar JUG construído em target/ :
target/java-uuid-generator-5.1.0-SNAPSHOT.jar
também pode ser usado como uma ferramenta simples de geração de UUID de linha de comando.
Para ver o uso, você pode fazer algo como:
java -jar target/java-uuid-generator-5.1.0-SNAPSHOT.jar
e obtenha instruções completas, mas para gerar 5 UUIDs aleatórios, você usaria:
java -jar target/java-uuid-generator-5.1.0-SNAPSHOT.jar -c 5 r
(onde -c (ou --count ) significa o número de UUIDs a serem gerados e r significa versão baseada em Random)
NOTA: esta funcionalidade está incluída a partir do JUG 4.1 - com versões anteriores você precisaria de uma invocação um pouco mais longa, pois os metadados do Jar não especificavam "Classe Principal". Se sim, você precisaria usar
java -cp target/java-uuid-generator-5.1.0-SNAPSHOT.jar com.fasterxml.uuid.Jug -c 5 r
As versões 3.1 e posteriores do JUG requerem que o JDK 1.6 funcione, principalmente para poder acessar o endereço MAC Ethernet local. Versões anteriores (3.0 e anteriores) funcionavam na 1.4 (que introduziu java.util.UUID ).
As versões 5.0 e posteriores do JUG requerem o JDK 8 para funcionar.
O java.util.UUID do JDK possui uma implementação falha de compareTo() , que usa comparação ingênua de valores de 64 bits. Isso NÃO funciona conforme o esperado, visto que o conteúdo subjacente não é assinado para todos os efeitos. Por exemplo, dois UUIDs:
7f905a0b-bb6e-11e3-9e8f-000000000000
8028f08c-bb6e-11e3-9e8f-000000000000
seria ordenado com o segundo primeiro, devido à extensão do sinal (o segundo valor é considerado negativo e, portanto, "menor").
Por causa disso, você deve sempre usar um comparador externo, como com.fasterxml.uuid.UUIDComparator , que implementa a ordem de classificação esperada que é uma classificação simples sem sinal, que também é igual à classificação lexicográfica (alfabética) de UUIDs (ao assumir capitalização uniforme) .
Disponível como parte da assinatura Tidelift.
Os mantenedores do java-uuid-generator e milhares de outros pacotes estão trabalhando com o Tidelift para fornecer suporte comercial e manutenção para as dependências de código aberto que você usa para construir seus aplicativos. Economize tempo, reduza riscos e melhore a integridade do código, enquanto paga os mantenedores das dependências exatas que você usa. Saber mais.
Para relatórios e correções simples de bugs e solicitações de recursos, basta usar o Issue Tracker de projetos, com exceção de problemas relacionados à segurança para os quais recomendamos preencher o contato de segurança do Tidelift (NOTA: você NÃO precisa ser um assinante para fazer isso).
Existem muitos outros geradores de UUID disponíveis publicamente. Por exemplo:
java.util.UUID desde 1.4, mas omite métodos de geração (especialmente aqueles baseados em tempo/local), tem desempenho abaixo do padrão para muitas operações e implementa comparação de maneira inútilObserve que embora alguns pacotes afirmem ser mais rápidos que outros, isso não está claro:
portanto, geralmente é melhor escolher com base na estabilidade dos pacotes e da API.
