天景科技苑

这个屌丝很懒，什么也没留下！

热门标签

从UUID到替代方案：探索Java中唯一ID生成的多种方法_java 128位有序id

作者：天景科技苑 | 2024-06-28 23:44:20

踩

java 128位有序id

hi，我是程序员王也，一个资深Java开发工程师，平时十分热衷于技术副业变现和各种搞钱项目的程序员~，如果你也是，可以一起交流交流。

今天我们来聊聊UUID。

在这里插入图片描述

UUID的基本知识

UUID（Universally Unique Identifier）是一个128位长的数字，用于在分布式系统中唯一标识信息。它由两部分组成：一个32位的段和一个96位的段，通过特定的算法生成，以确保在全球范围内的唯一性。

UUID的结构和版本类型

UUID的标准格式由32个十六进制数字组成，以连字符分为五组，形式为8-4-4-4-12，例如：123e4567-e89b-12d3-a456-426614174000。每个部分都有特定的含义，其中前8位（第一段）是多播或单播地址，接下来的两个4位（第二和第三段）表示时间戳，最后的12位（第四段和第五段）是节点标识符。

Java中的UUID类提供了几种不同的方法来生成UUID，每种方法对应不同的版本。版本1基于时间和节点标识符，版本2（DCE Security UUID）基于域名和时间，版本3和5基于名称空间和名称的散列值，版本4完全随机生成。
```
// 示例：生成版本1的UUID（基于时间）
UUID uuid1 = new UUID(0, System.currentTimeMillis());
System.out.println("Version 1 UUID: " + uuid1);

// 示例：生成版本4的UUID（随机）
UUID uuid4 = UUID.randomUUID();
System.out.println("Version 4 UUID: " + uuid4);
1
2
3
4
5
6
7
```
在这个例子中，我们使用UUID类的构造函数生成了一个版本1的UUID和一个版本4的UUID。
不同版本UUID的特点和生成方式

不同版本的UUID有不同的生成算法和用途。例如，版本1的UUID依赖于系统时间，因此可能存在重复的风险，尤其是在高并发的环境下。而版本4的UUID则完全随机生成，提供了更高的唯一性保证。
```
// 示例：生成版本3的UUID（基于名称的散列值）
String name = "example.com";
UUID uuid3 = UUID.nameUUIDFromBytes(name.getBytes(StandardCharsets.UTF_8));
System.out.println("Version 3 UUID: " + uuid3);
1
2
3
4
```
在这个例子中，我们使用nameUUIDFromBytes方法根据一个字符串名称生成了一个版本3的UUID。
UUID的标准化组织和规范

UUID遵循RFC 4122标准，由IETF（Internet Engineering Task Force）定义。这个标准详细描述了UUID的结构、版本、以及生成算法。
```
// 示例：根据RFC 4122生成UUID
// 通常不需要手动实现，java.util.UUID类已提供了标准的实现
1
2
```
在实际应用中，我们通常不需要手动实现UUID的生成，因为java.util.UUID类已经提供了符合标准的实现。

Java中生成UUID的方法

在Java中，java.util.UUID类是生成UUID的主要工具。这个类提供了多种静态方法来创建不同类型的UUID，以及一些实用的方法来操作和转换UUID。

使用UUID.randomUUID()生成随机UUID

UUID.randomUUID()是生成随机UUID最简单和最常用的方法。它创建一个版本4的UUID，这意味着UUID的大多数位都是随机生成的，确保了高度的唯一性。
```
public class RandomUUIDExample {
    public static void main(String[] args) {
        UUID randomUUID = UUID.randomUUID();
        System.out.println("Random UUID: " + randomUUID);
    }
}
1
2
3
4
5
6
```
在这个例子中，我们生成了一个随机UUID并打印到控制台。

使用UUID.fromString()解析UUID

UUID.fromString()方法可以将一个符合标准格式的字符串解析为UUID对象。

public class UUIDFromStringExample {
    public static void main(String[] args) {
        String uuidString = "123e4567-e89b-12d3-a456-426614174000";
        UUID uuid = UUID.fromString(uuidString);
        System.out.println("Parsed UUID: " + uuid);
    }
}
1
2
3
4
5
6
7

在这个例子中，我们将一个字符串解析为UUID对象，并打印出来。

使用UUID.nameUUIDFromBytes()生成名称基UUID

UUID.nameUUIDFromBytes()方法可以根据任意字节序列生成一个版本3的UUID，这个UUID是基于名称的散列值。

public class NameBasedUUIDExample {
    public static void main(String[] args) {
        String name = "example.com";
        UUID nameBasedUUID = UUID.nameUUIDFromBytes(name.getBytes(StandardCharsets.UTF_8));
        System.out.println("Name-based UUID: " + nameBasedUUID);
    }
}
1
2
3
4
5
6
7

在这个例子中，我们根据一个域名生成了一个名称基UUID。

UUID的其他实用方法

UUID类还提供了一些其他实用方法，例如toString()用于将UUID转换为其字符串表示形式，compareTo()用于比较两个UUID的先后顺序。

public class UUIDUtilsExample {
    public static void main(String[] args) {
        UUID uuid1 = UUID.randomUUID();
        UUID uuid2 = UUID.randomUUID();
        System.out.println("UUID1: " + uuid1);
        System.out.println("UUID2: " + uuid2);
        
        // 比较两个UUID
        if (uuid1.compareTo(uuid2) < 0) {
            System.out.println("UUID1 is lexicographically before UUID2");
        } else if (uuid1.compareTo(uuid2) > 0) {
            System.out.println("UUID1 is lexicographically after UUID2");
        } else {
            System.out.println("UUID1 and UUID2 are equal");
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

在这个例子中，我们生成了两个UUID并比较了它们的字典顺序。

案例：生成随机UUID

在实际应用中，随机UUID的生成是最常见和直接的需求。Java的UUID.randomUUID()方法为我们提供了一个简单而有效的方式来生成这样的UUID。下面是一个具体的案例，展示了如何在Java程序中生成并使用随机UUID。

生成并打印随机UUID

最简单的使用UUID.randomUUID()方法的方式是在程序中生成一个随机UUID并打印出来。

public class GenerateRandomUUID {
    public static void main(String[] args) {
        // 生成一个随机UUID
        UUID randomUUID = UUID.randomUUID();
        // 打印UUID的字符串表示形式
        System.out.println("Generated Random UUID: " + randomUUID.toString());
    }
}
1
2
3
4
5
6
7
8

在这个例子中，我们生成了一个随机UUID并将其转换为字符串形式打印出来。

生成多个随机UUID并存储

有时候，我们需要生成多个UUID并将它们存储起来，例如在创建多个实体或会话时。

public class GenerateMultipleUUIDs {
    public static void main(String[] args) {
        List<UUID> uuids = new ArrayList<>();
        for (int i = 0; i < 5; i++) {
            UUID uuid = UUID.randomUUID();
            uuids.add(uuid);
        }
        // 打印所有生成的UUID
        for (UUID uuid : uuids) {
            System.out.println("Generated UUID: " + uuid.toString());
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

在这个例子中，我们生成了5个随机UUID并将它们存储在一个列表中，然后遍历列表打印每个UUID。

使用随机UUID作为数据库记录的唯一标识

在数据库中，UUID常被用作唯一键，以确保每条记录都有一个唯一的标识符。

// 假设我们有一个名为Entity的实体类，其中包含一个UUID字段
public class Entity {
    private final UUID id;
    private String data;

    public Entity(UUID id, String data) {
        this.id = id;
        this.data = data;
    }

    // Getter和Setter方法省略...

    // 重写toString方法以打印实体信息
    @Override
    public String toString() {
        return "Entity{" +
                "id=" + id +
                ", data='" + data + '\'' +
                '}';
    }
}

public class DatabaseExample {
    public static void main(String[] args) {
        // 创建几个实体实例
        Entity entity1 = new Entity(UUID.randomUUID(), "Data for entity 1");
        Entity entity2 = new Entity(UUID.randomUUID(), "Data for entity 2");
        // 打印实体信息
        System.out.println(entity1);
        System.out.println(entity2);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

在这个例子中，我们创建了一个Entity类，它使用UUID作为唯一标识符。我们在数据库中创建了几个实体实例，并打印了它们的信息。

案例：根据名称生成UUID

在某些情况下，我们需要根据特定的名称或标识生成UUID，而不是完全随机生成。这种类型的UUID被称为名称基UUID（Version 3或Version 5），它们通过散列名称与一个命名空间的组合来生成。以下是一个具体的案例，展示了如何根据名称生成UUID。

使用UUID.nameUUIDFromBytes()生成名称基UUID

UUID.nameUUIDFromBytes()方法接受一个字节数组作为输入，并生成一个名称基UUID。通常，这个字节数组是由名称字符串转换而来。

public class NameBasedUUIDExample {
    public static void main(String[] args) {
        // 假设我们要为一个特定的名称生成UUID
        String name = "com.example.myapp";
        // 将名称转换为字节数组
        byte[] nameBytes = name.getBytes(StandardCharsets.UTF_8);
        // 生成名称基UUID
        UUID nameBasedUUID = UUID.nameUUIDFromBytes(nameBytes);
        // 打印生成的UUID
        System.out.println("Name-based UUID: " + nameBasedUUID);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

在这个例子中，我们根据给定的名称生成了一个名称基UUID，并将其打印出来。

在文件系统中使用名称基UUID

名称基UUID常用于文件系统，例如，为文件生成唯一的名称。

public class FileSystemUUIDExample {
    public static void main(String[] args) {
        // 生成名称基UUID
        UUID uniqueFileName = UUID.nameUUIDFromBytes("uniqueFileName".getBytes(StandardCharsets.UTF_8));
        // 创建一个基于UUID的文件名
        String fileName = "data_" + uniqueFileName.toString() + ".txt";
        // 假设我们使用这个文件名保存数据
        try (FileWriter writer = new FileWriter(fileName)) {
            writer.write("This is some unique data.");
        } catch (IOException e) {
            e.printStackTrace();
        }
        // 打印生成的文件名
        System.out.println("Generated file with name: " + fileName);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

在这个例子中，我们为一个文件生成了一个唯一的名称，并尝试将一些数据写入该文件。

在网络协议中使用名称基UUID

名称基UUID也可以用于网络协议中，例如，生成一个唯一的会话标识符或API密钥。

public class NetworkProtocolUUIDExample {
    public static void main(String[] args) {
        // 生成名称基UUID作为会话ID
        UUID sessionId = UUID.nameUUIDFromBytes("session-123".getBytes(StandardCharsets.UTF_8));
        // 打印生成的会话ID
        System.out.println("Session ID: " + sessionId);
        // 会话ID可以被用于跟踪和识别网络会话
    }
}
1
2
3
4
5
6
7
8
9

在这个例子中，我们生成了一个名称基UUID作为会话ID，并将其打印出来。这个会话ID可以用于在网络通信中跟踪和识别特定的会话。

UUID的存储和表示

UUID作为一种128位的标识符，需要以一种可靠和一致的方式进行存储和表示。在Java中，UUID通常以字符串的形式表示，但在存储到数据库或网络传输时，需要考虑其编码和解码的过程。

UUID的字符串表示形式

UUID的标准字符串表示形式是由32个十六进制数字组成的，以连字符分为五组，形式为8-4-4-4-12。Java的UUID类提供了toString()方法来获取UUID的字符串表示。

public class UUIDStringRepresentation {
    public static void main(String[] args) {
        UUID uuid = UUID.randomUUID();
        // 获取UUID的字符串表示
        String uuidString = uuid.toString();
        System.out.println("UUID String Representation: " + uuidString);
    }
}
1
2
3
4
5
6
7
8

在这个例子中，我们生成了一个随机UUID并打印了其字符串表示形式。

在数据库中存储UUID

UUID因其唯一性，常被用于数据库中的主键或唯一索引。大多数现代数据库系统都支持UUID作为数据类型，或者可以将其存储为字符串。

// 假设我们有一个名为MyTable的数据库表，其中包含一个UUID类型的列
public class DatabaseStorageExample {
    public static void main(String[] args) {
        String connectionString = "jdbc:mysql://localhost:3306/mydb";
        String username = "user";
        String password = "pass";
        // 连接到数据库并插入数据的代码省略...
        // 假设我们有一个实体对象
        Entity entity = new Entity(UUID.randomUUID(), "Some data");
        // 将实体存储到数据库中
        // 插入代码省略...
    }
}

public class Entity {
    private UUID id;
    private String data;

    // 构造函数、getter和setter方法省略...
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

在这个例子中，我们创建了一个Entity类，它使用UUID作为唯一标识符。我们将实体对象存储到数据库中，其中UUID作为主键。

UUID在网络协议中的传输

UUID在网络协议中的传输需要进行编码，通常使用其字符串表示形式进行Base64编码或直接作为字符串传输。

public class UUIDNetworkTransmission {
    public static void main(String[] args) {
        UUID uuid = UUID.randomUUID();
        // 将UUID转换为字符串
        String uuidString = uuid.toString();
        // 对字符串进行Base64编码
        String encodedString = Base64.getEncoder().encodeToString(uuidString.getBytes(StandardCharsets.UTF_8));
        System.out.println("Base64 Encoded UUID: " + encodedString);
        // 通过网络传输编码后的字符串
        // 网络传输代码省略...
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

在这个例子中，我们将UUID转换为字符串，然后进行Base64编码，以便在网络协议中传输。

案例：UUID在Web应用中的使用

UUID在Web应用中有着广泛的应用，尤其是在生成会话ID、API密钥、订单号等需要唯一标识的场景。本节将通过案例展示UUID在Web应用中的几种典型用途。

生成会话ID

在Web应用中，为了跟踪用户的会话，通常会使用会话ID。由于UUID的唯一性，它非常适合用作会话ID。

import javax.servlet.http.HttpSession;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;

public class SessionIdExample extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request) {
        HttpSession session = request.getSession();
        UUID sessionId = (UUID) session.getId();
        // 将UUID会话ID添加到响应中
        request.setAttribute("sessionId", sessionId.toString());
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

在这个例子中，我们在一个简单的Servlet中获取了会话ID，并将其作为属性添加到响应中。

生成API密钥

API密钥是控制访问API的一种方式。使用UUID可以生成一个唯一的API密钥。

import java.util.UUID;

public class ApiKeyGenerator {
    public static String generateApiKey() {
        return UUID.randomUUID().toString().replaceAll("-", "");
    }
}

public class ApiClient {
    public static void main(String[] args) {
        String apiKey = ApiKeyGenerator.generateApiKey();
        System.out.println("Generated API Key: " + apiKey);
        // 使用apiKey进行API调用
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

在这个例子中，我们创建了一个ApiKeyGenerator类来生成不带连字符的UUID作为API密钥。

生成订单号

订单号是电子商务网站中用来唯一标识每个订单的标识符。使用UUID可以确保每个订单号的唯一性。

public class OrderGenerator {
    public static UUID generateOrderUuid() {
        return UUID.randomUUID();
    }
}

public class ECommerceExample {
    public static void main(String[] args) {
        UUID orderUuid = OrderGenerator.generateOrderUuid();
        // 创建订单记录
        Order order = new Order(orderUuid, "Product1", 100.0);
        // 保存订单到数据库
    }

    static class Order {
        private UUID id;
        private String product;
        private double price;

        public Order(UUID id, String product, double price) {
            this.id = id;
            this.product = product;
            this.price = price;
            // 假设这里有一个将订单保存到数据库的方法
        }

        // Getter和Setter方法省略...
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

在这个例子中，我们创建了一个OrderGenerator类来生成订单UUID，并在一个模拟的电子商务系统中使用它作为订单号。

UUID的性能考量

在考虑使用UUID时，性能是一个不可忽视的因素。虽然UUID提供了高度的唯一性，但其生成过程可能会对系统性能产生影响。本节将探讨UUID生成的性能特点，并提供一些优化建议。

分析UUID生成的性能开销

UUID的生成通常涉及随机数生成器或散列函数，这些操作可能会消耗CPU资源。在高并发场景下，频繁地生成UUID可能会成为性能瓶颈。

public class UUIDPerformance {
    public static void main(String[] args) {
        long start = System.nanoTime();
        for (int i = 0; i < 100000; i++) {
            UUID.randomUUID();
        }
        long end = System.nanoTime();
        System.out.println("Time taken to generate 100,000 UUIDs: " + (end - start) + " nanoseconds");
    }
}
1
2
3
4
5
6
7
8
9
10

在这个例子中，我们测量了生成100,000个随机UUID所需的时间。这个简单的基准测试可以帮助我们了解UUID生成的性能开销。

优化UUID生成的性能

为了优化UUID的性能，可以采取以下措施：

重用UUID实例：在可能的情况下，尽量重用UUID实例，而不是频繁地生成新的UUID。
使用缓存：对于不需要高度随机性的UUID，可以使用缓存来存储已生成的UUID，以减少生成新UUID的频率。
选择合适的UUID版本：根据应用场景选择合适的UUID版本。例如，如果确定性唯一性足够，可以使用版本1的UUID，而不是随机性更高的版本4。

public class OptimizedUUIDGeneration {
    public static void main(String[] args) {
        List<UUID> uuidCache = new ArrayList<>();
        for (int i = 0; i < 10000; i++) {
            if (uuidCache.isEmpty()) {
                uuidCache.add(UUID.randomUUID());
            } else {
                System.out.println("Reusing UUID: " + uuidCache.get(0));
                uuidCache.remove(0); // 移除并返回缓存中的第一个UUID
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

在这个例子中，我们使用了一个简单的缓存来重用UUID实例，以减少UUID.randomUUID()的调用次数。

比较不同UUID生成策略的性能

不同的UUID生成策略有不同的性能特点。例如，版本1的UUID基于时间，可能在某些情况下比版本4的随机UUID生成更快。

public class CompareUUIDStrategies {
    public static void main(String[] args) {
        long timeTakenVersion1 = measureTime(() -> {
            for (int i = 0; i < 100000; i++) {
                new UUID(0, System.currentTimeMillis());
            }
        });

        long timeTakenVersion4 = measureTime(() -> {
            for (int i = 0; i < 100000; i++) {
                UUID.randomUUID();
            }
        });

        System.out.println("Time taken for version 1: " + timeTakenVersion1);
        System.out.println("Time taken for version 4: " + timeTakenVersion4);
    }

    private static long measureTime(Runnable runnable) {
        long start = System.nanoTime();
        runnable.run();
        return System.nanoTime() - start;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

在这个例子中，我们比较了生成版本1和版本4 UUID的性能。实际结果可能会因系统和JVM的不同而有所差异。

以下是关于“JAVA生成UUID”的技术文章的第九小节“UUID的替代方案”部分的内容，包含了充足的案例源码说明：

UUID的替代方案

虽然UUID提供了一个强大且普遍认可的方法来生成唯一标识符，但在某些特定场景下，我们可能需要考虑替代方案。这些替代方案可能基于不同的需求，如性能优化、特定数据结构的需求或兼容性考虑。

简短的ID生成

在某些情况下，UUID的128位长度可能显得过于冗长。我们可以使用一些算法来生成更短的ID，同时仍然保持足够高的唯一性。

public class ShortIDGenerator {
    private static final int ID_LENGTH = 10;
    private static final int MAX_VALUE = (int) Math.pow(36, ID_LENGTH);
    
    public static String generateId() {
        SecureRandom random = new SecureRandom();
        int nextInt;
        StringBuilder sb = new StringBuilder(ID_LENGTH);
        while (sb.length() < ID_LENGTH) {
            nextInt = random.nextInt(MAX_VALUE);
            sb.append(Integer.toString(nextInt, 36));
        }
        return sb.toString();
    }
}

public class ShortIDExample {
    public static void main(String[] args) {
        String shortId = ShortIDGenerator.generateId();
        System.out.println("Short ID: " + shortId);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

在这个例子中，我们创建了一个ShortIDGenerator类来生成一个基于36进制的短ID。

基于时间的ID生成

对于需要有序性的ID，可以使用基于时间的ID生成策略，如Twitter的Snowflake算法。这种算法生成的ID既有序又唯一，并且可以压缩时间戳和工作机器ID，从而节省空间。

public class SnowflakeIdWorker {
    private final long twepoch = 1288834974657L; // Twitter定义的起始时间戳
    private long sequence = 0; // 毫秒内序列
    private long lastTimestamp = -1L; // 上次生成ID的时间戳

    public synchronized long nextId() {
        long timestamp = timeGen(); // 获取时间戳
        // 如果当前时间小于上一次ID生成的时间戳，说明系统时钟回退过
        if (timestamp < lastTimestamp) {
            throw new RuntimeException(String.format("Clock moved backwards. Refusing to generate id for %d milliseconds", lastTimestamp - timestamp));
        }

        // 如果是同一时间生成的，则进行毫秒内序列
        if (lastTimestamp == timestamp) {
            sequence = (sequence + 1) & 3; // 这里3=0000 0011，即：0-3
            // 毫秒内序列溢出
            if (sequence == 0) {
                waitUntilNextMillis(timestamp);
            }
        } else {
            sequence = 0;
        }

        lastTimestamp = timestamp;
        return ((timestamp - twepoch) << 22) | (sequence << 20) | (workerId << 12) | datacenterId;
    }

    protected long timeGen() {
        return System.currentTimeMillis();
    }

    // 等待下一个毫秒,直到获得新的时间戳
    protected void waitUntilNextMillis(long lastTimestamp) {
        long timestamp = timeGen();
        while (timestamp <= lastTimestamp) {
            timestamp = timeGen();
        }
    }
}

public class SnowflakeExample {
    public static void main(String[] args) {
        SnowflakeIdWorker idWorker = new SnowflakeIdWorker(1, 1);
        long id = idWorker.nextId();
        System.out.println("Snowflake ID: " + id);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

在这个例子中，我们模拟了一个基于Snowflake算法的ID生成器，并生成了一个唯一的ID。

自定义ID生成策略

根据应用的特定需求，可以设计自定义的ID生成策略。例如，可以结合数据库序列、哈希函数或其他业务逻辑来生成ID。

public class CustomIdGenerator {
    private static final AtomicInteger counter = new AtomicInteger(0);
    private static final String prefix = "ID_";

    public static String generateCustomId() {
        int currentCount = counter.incrementAndGet();
        String hash = Integer.toHexString(currentCount).hashCode();
        return prefix + hash;
    }
}

public class CustomIDExample {
    public static void main(String[] args) {
        String customId = CustomIdGenerator.generateCustomId();
        System.out.println("Custom ID: " + customId);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

在这个例子中，我们创建了一个CustomIdGenerator类，它使用原子计数器和哈希函数来生成自定义的ID。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/天景科技苑/article/detail/767703