用Java创建一个GUID

在Java中创建GUID的一些最佳方法是什么?

426021 次浏览
小开
最佳答案

看看与Java 5及更高版本绑定的UUID类。

例如:

  • 如果你想要一个随机的UUID，你可以使用randomUUID方法。
  • 如果你想要一个UUID初始化为一个特定的值，你可以使用UUID构造函数或fromString方法。
小开

java.util.UUID.randomUUID();

小开

这取决于你想要什么样的UUID。

  • 标准Java UUID类生成版本4(随机)uuid。(更新 - 版本3 (name) uuid也可以生成。)它还可以处理其他变体，尽管它不能生成它们。(在这种情况下，&;handle"意味着从long、UUID0或UUID1表示构造UUID实例，并提供一些适当的访问器。)

  • Java UUID生成器(JUG)实现声称支持“由__abc1定义的所有3种正式的UUID”;．.． 尽管RFC实际上定义了4种类型，并提到了第五种类型。

关于UUID类型和变量的更多信息，在维基百科中有一个很好的总结，而血腥的细节在RFC 4122和其他规范中。

小开

其他答案是正确的，特别是这一个 by 斯蒂芬·C。

走出Java

出于安全考虑，Java中的生成UUID值被限制为版本4(随机)。

如果你想要其他版本的uuid，一种方法是让你的Java应用程序超出JVM来生成uuid，方法是调用:

  • 命令行实用程序
    几乎所有操作系统都绑定。
    例如，在Mac OS X、BSD和Linux中可以找到uuidgen。
  • 数据库服务器
    使用JDBC获取数据库服务器上生成的UUID。例如，uuid-ossp扩展名经常与Postgres绑定在一起。该扩展可以生成版本1、3和4的值，另外还有几个变体:
  • uuid_generate_v1mc() -生成版本1的UUID，但使用随机组播MAC地址而不是计算机的真实MAC地址。
  • uuid_generate_v5(namespace uuid, name text) -生成一个版本5的UUID，它像版本3的UUID一样工作，除了SHA-1被用作哈希方法。
  • Web服务
    例如，UUID发电机创建版本1 &3以及零值和GUID。
小开

用一个例子来扩展Mark Byers的回答:

import java.util.UUID;


public class RandomStringUUID {
public static void main(String[] args) {
UUID uuid = UUID.randomUUID();
System.out.println("UUID=" + uuid.toString() );
}
}
小开

这个答案包含2个生成器，用于基于随机和基于名称的uuid，符合RFC-4122。请随意使用和分享。

RANDOM-BASED (v4)

这个工具类生成基于随机的uuid:

package your.package.name;


import java.security.SecureRandom;
import java.util.Random;
import java.util.UUID;


/**
* Utility class that creates random-based UUIDs.
*
*/
public abstract class RandomUuidCreator {


private static final int RANDOM_VERSION = 4;


/**
* Returns a random-based UUID.
*
* It uses a thread local {@link SecureRandom}.
*
* @return a random-based UUID
*/
public static UUID getRandomUuid() {
return getRandomUuid(SecureRandomLazyHolder.THREAD_LOCAL_RANDOM.get());
}


/**
* Returns a random-based UUID.
*
* It uses any instance of {@link Random}.
*
* @return a random-based UUID
*/
public static UUID getRandomUuid(Random random) {


long msb = 0;
long lsb = 0;


// (3) set all bit randomly
if (random instanceof SecureRandom) {
// Faster for instances of SecureRandom
final byte[] bytes = new byte[16];
random.nextBytes(bytes);
msb = toNumber(bytes, 0, 8); // first 8 bytes for MSB
lsb = toNumber(bytes, 8, 16); // last 8 bytes for LSB
} else {
msb = random.nextLong(); // first 8 bytes for MSB
lsb = random.nextLong(); // last 8 bytes for LSB
}


// Apply version and variant bits (required for RFC-4122 compliance)
msb = (msb & 0xffffffffffff0fffL) | (RANDOM_VERSION & 0x0f) << 12; // apply version bits
lsb = (lsb & 0x3fffffffffffffffL) | 0x8000000000000000L; // apply variant bits


// Return the UUID
return new UUID(msb, lsb);
}


private static long toNumber(final byte[] bytes, final int start, final int length) {
long result = 0;
for (int i = start; i < length; i++) {
result = (result << 8) | (bytes[i] & 0xff);
}
return result;
}


// Holds thread local secure random
private static class SecureRandomLazyHolder {
static final ThreadLocal<Random> THREAD_LOCAL_RANDOM = ThreadLocal.withInitial(SecureRandom::new);
}


/**
* For tests!
*/
public static void main(String[] args) {


System.out.println("// Using thread local `java.security.SecureRandom` (DEFAULT)");
System.out.println("RandomUuidCreator.getRandomUuid()");
System.out.println();
for (int i = 0; i < 5; i++) {
System.out.println(RandomUuidCreator.getRandomUuid());
}


System.out.println();
System.out.println("// Using `java.util.Random` (FASTER)");
System.out.println("RandomUuidCreator.getRandomUuid(new Random())");
System.out.println();
Random random = new Random();
for (int i = 0; i < 5; i++) {
System.out.println(RandomUuidCreator.getRandomUuid(random));
}
}
}

输出如下:

// Using thread local `java.security.SecureRandom` (DEFAULT)
RandomUuidCreator.getRandomUuid()


'ef4f5ad2-8147-46cb-8389-c2b8c3ef6b10'
'adc0305a-df29-4f08-9d73-800fde2048f0'
'4b794b59-bff8-4013-b656-5d34c33f4ce3'
'22517093-ee24-4120-96a5-ecee943992d1'
'899fb1fb-3e3d-4026-85a8-8a2d274a10cb'


// Using `java.util.Random` (FASTER)
RandomUuidCreator.getRandomUuid(new Random())


'4dabbbc2-fcb2-4074-a91c-5e2977a5bbf8'
'078ec231-88bc-4d74-9774-96c0b820ceda'
'726638fa-69a6-4a18-b09f-5fd2a708059b'
'15616ebe-1dfd-4f5c-b2ed-cea0ac1ad823'
'affa31ad-5e55-4cde-8232-cddd4931923a'

基于name的(v3和v5)

生成基于名称的uuid (MD5和SHA1)的实用程序类:

package your.package.name;


import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.UUID;


/**
* Utility class that creates UUIDv3 (MD5) and UUIDv5 (SHA1).
*
*/
public class HashUuidCreator {


// Domain Name System
public static final UUID NAMESPACE_DNS = new UUID(0x6ba7b8109dad11d1L, 0x80b400c04fd430c8L);
// Uniform Resource Locator
public static final UUID NAMESPACE_URL = new UUID(0x6ba7b8119dad11d1L, 0x80b400c04fd430c8L);
// ISO Object ID
public static final UUID NAMESPACE_ISO_OID = new UUID(0x6ba7b8129dad11d1L, 0x80b400c04fd430c8L);
// X.500 Distinguished Name
public static final UUID NAMESPACE_X500_DN = new UUID(0x6ba7b8149dad11d1L, 0x80b400c04fd430c8L);


private static final int VERSION_3 = 3; // UUIDv3 MD5
private static final int VERSION_5 = 5; // UUIDv5 SHA1


private static final String MESSAGE_DIGEST_MD5 = "MD5"; // UUIDv3
private static final String MESSAGE_DIGEST_SHA1 = "SHA-1"; // UUIDv5


private static UUID getHashUuid(UUID namespace, String name, String algorithm, int version) {


final byte[] hash;
final MessageDigest hasher;


try {
// Instantiate a message digest for the chosen algorithm
hasher = MessageDigest.getInstance(algorithm);


// Insert name space if NOT NULL
if (namespace != null) {
hasher.update(toBytes(namespace.getMostSignificantBits()));
hasher.update(toBytes(namespace.getLeastSignificantBits()));
}


// Generate the hash
hash = hasher.digest(name.getBytes(StandardCharsets.UTF_8));


// Split the hash into two parts: MSB and LSB
long msb = toNumber(hash, 0, 8); // first 8 bytes for MSB
long lsb = toNumber(hash, 8, 16); // last 8 bytes for LSB


// Apply version and variant bits (required for RFC-4122 compliance)
msb = (msb & 0xffffffffffff0fffL) | (version & 0x0f) << 12; // apply version bits
lsb = (lsb & 0x3fffffffffffffffL) | 0x8000000000000000L; // apply variant bits


// Return the UUID
return new UUID(msb, lsb);


} catch (NoSuchAlgorithmException e) {
throw new RuntimeException("Message digest algorithm not supported.");
}
}


public static UUID getMd5Uuid(String string) {
return getHashUuid(null, string, MESSAGE_DIGEST_MD5, VERSION_3);
}


public static UUID getSha1Uuid(String string) {
return getHashUuid(null, string, MESSAGE_DIGEST_SHA1, VERSION_5);
}


public static UUID getMd5Uuid(UUID namespace, String string) {
return getHashUuid(namespace, string, MESSAGE_DIGEST_MD5, VERSION_3);
}


public static UUID getSha1Uuid(UUID namespace, String string) {
return getHashUuid(namespace, string, MESSAGE_DIGEST_SHA1, VERSION_5);
}


private static byte[] toBytes(final long number) {
return new byte[] { (byte) (number >>> 56), (byte) (number >>> 48), (byte) (number >>> 40),
(byte) (number >>> 32), (byte) (number >>> 24), (byte) (number >>> 16), (byte) (number >>> 8),
(byte) (number) };
}


private static long toNumber(final byte[] bytes, final int start, final int length) {
long result = 0;
for (int i = start; i < length; i++) {
result = (result << 8) | (bytes[i] & 0xff);
}
return result;
}


/**
* For tests!
*/
public static void main(String[] args) {


String string = "JUST_A_TEST_STRING";
UUID namespace = UUID.randomUUID(); // A custom name space


System.out.println("Java's generator");
System.out.println("UUID.nameUUIDFromBytes():      '" + UUID.nameUUIDFromBytes(string.getBytes()) + "'");
System.out.println();
System.out.println("This generator");
System.out.println("HashUuidCreator.getMd5Uuid():  '" + HashUuidCreator.getMd5Uuid(string) + "'");
System.out.println("HashUuidCreator.getSha1Uuid(): '" + HashUuidCreator.getSha1Uuid(string) + "'");
System.out.println();
System.out.println("This generator WITH name space");
System.out.println("HashUuidCreator.getMd5Uuid():  '" + HashUuidCreator.getMd5Uuid(namespace, string) + "'");
System.out.println("HashUuidCreator.getSha1Uuid(): '" + HashUuidCreator.getSha1Uuid(namespace, string) + "'");
}
}

输出如下:

// Java's generator
UUID.nameUUIDFromBytes():      '9e120341-627f-32be-8393-58b5d655b751'


// This generator
HashUuidCreator.getMd5Uuid():  '9e120341-627f-32be-8393-58b5d655b751'
HashUuidCreator.getSha1Uuid(): 'e4586bed-032a-5ae6-9883-331cd94c4ffa'


// This generator WITH name space
HashUuidCreator.getMd5Uuid():  '2b098683-03c9-3ed8-9426-cf5c81ab1f9f'
HashUuidCreator.getSha1Uuid(): '1ef568c7-726b-58cc-a72a-7df173463bbb'

备用发电机

你也可以使用uuid-creator库。请看这些例子:

// Create a random-based UUID
UUID uuid = UuidCreator.getRandomBased();

// Create a name based UUID (SHA1)
String name = "JUST_A_TEST_STRING";
UUID uuid = UuidCreator.getNameBasedSha1(name);

项目页面:https://github.com/f4b6a3/uuid-creator

小开

在许多情况下，我们需要对象的全局UUID，特别是在事件驱动架构或事件源中，我们必须根据日期对事件进行排序，但我们不需要关于时间戳的完整信息。

在那里，我们可以使用ULID的一个实现，即按字母排序的。

格式与标准UUID不同，但仍然很简单:

example value: 01AN4Z07BY79KA1307SR9X4MV3


01AN4Z07BY      79KA1307SR9X4MV3


|----------|    |----------------|
Timestamp          Randomness
48bits             80bits

在许多语言中有一些实现。

例如，在Java中，有简单的自由。

代码示例:

import de.huxhorn.sulky.ulid.ULID;


ULID ulid = new ULID();


// with current timestamp
String newId = ulid.nextULID();


// with selected timestamp
String newId2 = ulid.nextULID(Instant
.parse("2021-12-01T00:00:00.00Z")
.toEpochMilli()
);

使用Spring，您还可以为ULID生成器创建Bean。

@Configuration
public class UUIDGeneratorConfig {


@Bean
public ULID ulidGenerator() {
return new ULID();
}
}

@Component
public class ULIDGenerator {


private final ULID ulid;


public ULIDGenerator(ULID ulid) {
this.ulid = ulid;
}


public String generateUUID() {
return ulid.nextULID();
}


public String generateUUID(Instant timestamp) {
return ulid.nextULID(timestamp.toEpochMilli());
}
}

提交答案