从UUID到替代方案：探索Java中唯一ID生成的多种方法

已于 2024-04-15 01:05:49 修改
阅读量6.7k 收藏 38
点赞数 29
分类专栏： 王也《Java》 文章标签： java 开发语言
于 2024-04-15 00:57:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/java_wudg/article/details/137759401
版权

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

今天我们来聊聊UUID。

在这里插入图片描述

UUID的基本知识

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

  1. 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);

    在这个例子中，我们使用UUID类的构造函数生成了一个版本1的UUID和一个版本4的UUID。

  2. 不同版本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);

    在这个例子中，我们使用nameUUIDFromBytes方法根据一个字符串名称生成了一个版本3的UUID。

  3. UUID的标准化组织和规范

    UUID遵循RFC 4122标准，由IETF（Internet Engineering Task Force）定义。这个标准详细描述了UUID的结构、版本、以及生成算法。

    // 示例：根据RFC 4122生成UUID
// 通常不需要手动实现，java.util.UUID类已提供了标准的实现

    在实际应用中，我们通常不需要手动实现UUID的生成，因为java.util.UUID类已经提供了符合标准的实现。

Java中生成UUID的方法

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

  1. 使用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);
    }
}

    在这个例子中，我们生成了一个随机UUID并打印到控制台。

  2. 使用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);
    }
}

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

  3. 使用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);
    }
}

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

  4. 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");
        }
    }
}

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

案例：生成随机UUID

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

  1. 生成并打印随机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());
    }
}

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

  2. 生成多个随机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());
        }
    }
}

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

  3. 使用随机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);
    }
}

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

案例：根据名称生成UUID

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

  1. 使用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);
    }
}

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

  2. 在文件系统中使用名称基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);
    }
}

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

  3. 在网络协议中使用名称基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可以被用于跟踪和识别网络会话
    }
}

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

UUID的存储和表示

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

  1. 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);
    }
}

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

  2. 在数据库中存储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方法省略...
}

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

  3. 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);
        // 通过网络传输编码后的字符串
        // 网络传输代码省略...
    }
}

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

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

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

  1. 生成会话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());
    }
}

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

  2. 生成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调用
    }
}

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

  3. 生成订单号

    订单号是电子商务网站中用来唯一标识每个订单的标识符。使用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方法省略...
    }
}

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

UUID的性能考量

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

  1. 分析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");
    }
}

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

  2. 优化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
            }
        }
    }
}

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

  3. 比较不同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和版本4 UUID的性能。实际结果可能会因系统和JVM的不同而有所差异。

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

UUID的替代方案

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

  1. 简短的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);
    }
}

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

  2. 基于时间的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);
    }
}

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

  3. 自定义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);
    }
}

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

程序员王也
关注
专栏目录
可笑，你竟然不知道 Java 如何生成 UUID
2401_87167716的博客
09-18 814
方法会生成一个基于指定 UUID 字符串的 UUID 对象，如果指定的 UUID 字符串不符合 UUID 的格式，将抛出 IllegalArgumentException 异常。在上例中，M 是 1，N 是 a（二进制为 1010，符合 10xx 的格式），这就意味着这个 UUID 是“版本 1”、“变体 1”的 UUID。要使用构造方法创建 UUID 对象的话，就需要传递两个参数，long 型的最高位 UUID 和最低位的 UUID。在 Java 中，就有一个叫 UUID 的类，在。
JAVA自带的方法生成唯一ID
01-23
java中有自带的方法可以自动帮助我们实现id的获取，可以作为稳定的工具类。可自定义。
java获取uuid
weixin_41203765的博客
09-19 573
根据不同的需求和偏好，我们可以选择以上任何一种方法来获取UUID。方法三：使用JDK自带的MessageDigest类。方法一：使用java.util.UUID库。方法二：使用Apache Commons库。
Java中生成唯一ID的方法
王浩的技术博客
12-19 2万+
有时我们不依赖于数据库中自动递增的字段产生唯一ID,比如多表同一字段需要统一一个唯一ID,这时就需要用程序来生成一个唯一的全局ID。 UUID 从Java 5开始， UUID 类提供了一种生成唯一ID的简单方法。UUID是通用唯一识别码 (Universally Unique Identifier)的缩写，UUID来源于OSF(Open Software Foundation，开源软件基金会)的D...
JAVA生成全局唯一ID 使用 java.util.UUID
Java 初学者
06-20 1363
有时我们不依赖于数据库中自动递增的字段产生唯一ID,比如多表同一字段需要统一一个唯一ID,这时就需要用程序来生成一个唯一的全局ID,然后在数据库事务中同时插入到多章表中实现同步. 在java中有个类工具很好的实现产生唯一ID(UUID),但是由数字和字母及中划线组成的,故数据库字段应该设置为char 并相应的建立索引. UUID是128位整数(16字节)的全局唯一标识符(Universally...
java生成唯一ID
m0_64053569的博客
07-18 1684
可以直接用cn.hutool 中的雪花算法生成id。相比第一种性能有所提升。
java生成唯一id（uuid）（不依赖jdk5，自己实现的）
03-17
NULL 博文链接：https://jarorwar.iteye.com/blog/553875
Android生成唯一标识符UUID(完全替代IMEI)
03-13
这个类提供了`randomUUID()`方法，它会生成一个基于当前时间的随机UUID，保证在全局范围内的唯一性。 ```java UUID uniqueId = UUID.randomUUID(); String uuidString = uniqueId.toString(); ``` 生成的UUID字符...
Java开发：从UUID转向ULID，提升唯一标识的效率与安全性
"Java开发中从UUID转向ULID的探讨" 在软件开发中，我们经常需要生成唯一的标识符，这通常涉及到使用UUID或ULID。UUID（通用唯一标识符）是一种广泛使用的机制，用于生成全局唯一的128位数字，表示为36个字符的字符...
项目系统唯一ID生成策略方案汇总
weixin_43381988的博客
08-19 1738
我的个人博客 百度搜索：【迷你酷吧】网址：https://www.minikuba.com，迷你酷吧是一个基于程序员经验为基础分享技术文章、算法解题、大厂面试真题、热门项目的平台，致力于为大家提供更多涵盖前后端技术、技能的学习，助力广大热衷编程开发者全面发展。本文链接：https://www.minikuba.com/article/199 分布式系统唯一ID生成方案简介 系统唯一ID是我们在设计一个系统的时候常常会遇见的问题，也常常因为使用那种ID策略这个问题而纠结。生成ID的方法有很多，适应不同的
浏览器指纹（Browser Fingerprint）fingerprintjs2：浏览器获取本地主机MAC地址/GUID，进行设备绑定和身份验证。（浏览器端js为本机生成固定的uuid）
最新发布
iOS逆向与安全
10-17 251
需求： 限制指定MAC地址登录站点实现方案： 基于object 标签的。
java根据时间生成唯一ID
06-12
java根据时间生成唯一ID,普通的根据时间生成的ID放在循环内很容易重复。
JAVA UUID 生成全球唯一ID
09-02
GUID是一个128位长的数字，一般用16进制表示。算法的核心思想是结合机器的网卡、当地时间、一个随即数来生成GUID。从理论上讲，如果一台机器每秒产生10000000个GUID，则可以保证（概率意义上）3240年不重复
浅谈JAVA如何生成UUID唯一标识
08-18
主要介绍了浅谈JAVA如何生成UUID唯一标识，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
【Java】配置redis 注解 @Async 实现异步调用方法 uuid 完整代码（个人梳理）
博桑根本提不起劲的博客
01-23 523
【Java】配置redis 注解 @Async 实现异步方法 uuid 完整代码（个人梳理） 【Java】配置redis 注解 @Async 实现异步方法 uuid 完整代码（个人梳理） 文章目录【Java】配置redis 注解 @Async 实现异步方法 uuid 完整代码（个人梳理）前言一、配置redis.xml二、配置Jedis工具类1.JedisClient2.配置JedisClientSingleImpl配置ProcessMsg工具类Controller层接口Service接口里Serv
Java生成唯一ID的方式有哪些？
毛豆的博客
03-25 1937
雪花算法是一种分布式系统中用于生成唯一ID的算法，由Twitter开源。Java实现这一算法需要编写相对复杂的代码来保证ID的唯一性和顺序性，这里不详细展开代码实现。在使用数据库时，可以依靠数据库的自增字段来生成唯一ID。选择合适的方法主要基于你的具体需求，如是否需要跨应用程序的全局唯一性、是否在分布式系统中、以及ID生成的速度要求等。另一种简单的方法是直接使用当前的时间戳来生成ID。这种方法生成的ID不是全局唯一的，但在某些情况下足够使用。UUID是一种普遍采用的生成唯一ID的方法，Java通过。
JAVA生成唯一主键uuid的方法 (UUID方法)
热门推荐
请大家直接把问题写在评论区或留言，不要只说一句"你好 或 在吗"，我会尽快回复的。
06-05 2万+
在平时开发时，如果没有定义数据库自动生成ID的机制，可以使用java自带的uuid生成随机唯一主键，在插入数据库时，可以直接给ID主键赋值；这个uuid方法，在java自带的utils包里，就可以直接调用：示例：public static String getUUID(){ UUID uuid=UUID.randomUUID(); String uuidStr=uuid...
SnowFlake分布式唯一ID 生成器
diyujun6099的博客
08-01 1627
Snowflake生成IDtwitter开发的一套全局唯一ID生成算法，要点如下：41位的时间序列(精确到毫秒，41位的长度可以使用69年) 10位的机器标识(10位的长度最多支持部署1024个节点) 12位的计数顺序号(12位的计数顺序号支持每个节点每毫秒产生4096个ID序号) 最高位是符号位，始终为0。简单可靠，性能好，趋势有序，不引入第三方系统。缺点是有使用时间限制，8-100年...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值