首頁手記 Java分布式ID入門教程

Java分布式ID入門教程

標簽：

Java

概述

本文介绍了Java分布式ID入门的相关知识，包括分布式ID的基本概念、生成原则和常用生成方案，如Snowflake算法和UUID。文章还详细讲解了如何在Java项目中集成和使用分布式ID生成器，并探讨了其在单体应用和微服务架构中的应用场景。

分布式ID的基本概念

什么是分布式ID

分布式ID是指在分布式系统中生成和分配的唯一标识符。在互联网应用中，每个对象（例如用户、订单、文章等）都需要一个全局唯一的标识符。分布式环境下，这些对象可能分布在不同的服务器上，因此需要一种机制来生成唯一且全局可用的ID。

分布式ID的作用和意义

分布式ID在分布式系统中具有重要意义。它能够保证每个对象在整个系统中的唯一性，避免数据冲突和重复。同时，分布式ID通常具备自增、有序、易于解析等特性，使得系统在高并发环境下更加高效稳定。

作用

唯一性：确保每个ID在系统中唯一，避免重复。
全局唯一：在分布式系统中，确保不同节点生成的ID全局唯一。
有序性：ID按时间顺序生成，便于排序和查询。
易解析：ID结构清晰，易于解析，便于定位和恢复数据。

意义

提升系统性能：有序的ID便于数据库的索引和查询。
减少冲突：通过唯一ID避免数据冲突，提高系统的可维护性和可扩展性。
简化开发：提供一致的ID生成机制，简化开发流程。
增强可靠性：分布式ID生成器通常具备容错和高可用特性，提高系统的可靠性和稳定性。

分布式ID的生成原则

唯一性：生成的ID在整个系统中唯一。
全局唯一性：分布式系统中各节点生成的ID全局唯一。
有序性：ID按时间顺序生成，便于排序和查询。
易于解析：ID结构清晰，易于解析，便于定位和恢复数据。
可扩展性：生成器能够处理大量并发请求。
高性能：生成ID的速度快，不影响系统性能。
容错性：生成器具有容错机制，即使部分节点失效仍能正常工作。
易于维护：生成器易于维护和管理。

Java中常用的分布式ID生成方案

使用Snowflake算法生成ID

Snowflake算法是一种广泛使用的分布式ID生成算法，由Twitter开源。它采用64位整型ID，其中一部分用于表示时间戳，一部分用于表示工作节点ID，剩余部分用于序列号。

Snowflake算法的结构

41位时间戳（毫秒级）：代表自定义的时间起点到当前时间的毫秒数。
10位工作节点ID：可容纳1024个节点。
12位序列号：每毫秒内可生成4096个ID。

示例代码实现

public class SnowflakeIdGenerator {
    private static final long EPOCH = 1288834974657L; // 2010-12-11 11:22:57
    private static final long WORKER_ID_BITS = 10L;
    private static final long DATA_CENTER_ID_BITS = 5L;
    private static final long MAX_WORKER_ID = -1L ^ (-1L << WORKER_ID_BITS);
    private static final long MAX_DATA_CENTER_ID = -1L ^ (-1L << DATA_CENTER_ID_BITS);
    private static final long SEQUENCE_BITS = 12L;

    private static final long WORKER_ID_SHIFT = SEQUENCE_BITS;
    private static final long DATA_CENTER_ID_SHIFT = SEQUENCE_BITS + WORKER_ID_BITS;
    private static final long TIMESTAMP_LEFT_SHIFT = SEQUENCE_BITS + WORKER_ID_BITS + DATA_CENTER_ID_BITS;

    private static final long SEQUENCE_MASK = -1L ^ (-1L << SEQUENCE_BITS);

    private static final long WORKER_ID = 1L;
    private static final long DATA_CENTER_ID = 1L;

    private long sequence = 0L;
    private long lastTimestamp = -1L;

    public synchronized long nextId() {
        long timestamp = timeGen();

        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) & SEQUENCE_MASK;
            if (sequence == 0) {
                timestamp = tilNextMillis(lastTimestamp);
            }
        } else {
            sequence = 0L;
        }

        lastTimestamp = timestamp;

        return ((timestamp - EPOCH) << TIMESTAMP_LEFT_SHIFT) |
                (DATA_CENTER_ID << DATA_CENTER_ID_SHIFT) |
                (WORKER_ID << WORKER_ID_SHIFT) |
                sequence;
    }

    private long tilNextMillis(long lastTimestamp) {
        long timestamp = timeGen();
        while (timestamp <= lastTimestamp) {
            timestamp = timeGen();
        }
        return timestamp;
    }

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

使用示例

public class Main {
    public static void main(String[] args) {
        SnowflakeIdGenerator idGenerator = new SnowflakeIdGenerator();
        for (int i = 0; i < 10; i++) {
            System.out.println(idGenerator.nextId());
        }
    }
}

使用UUID生成ID及其优缺点

UUID（Universally Unique Identifier）是一种128位的唯一标识符，由16个字节组成，通常表示为32个16进制数字，用4个“-”分隔为5组。

优点

全局唯一性：UUID在全球范围内是唯一的。
无需特殊硬件：不需要特定的硬件支持。
简单易用：可以直接在程序中生成，不需要复杂的配置。

缺点

不易解析：不便于解析和定位。
存储空间大：占用更多存储空间。
性能较低：生成UUID的性能不如Snowflake算法。

示例代码实现

import java.util.UUID;

public class UuidIdGenerator {
    public static String nextId() {
        return UUID.randomUUID().toString();
    }
}

public class Main {
    public static void main(String[] args) {
        UuidIdGenerator idGenerator = new UuidIdGenerator();
        for (int i = 0; i < 10; i++) {
            System.out.println(idGenerator.nextId());
        }
    }
}

其他生成方案简介

取模法

通过取模运算生成ID，适用于简单的场景，但容易出现ID冲突。

数据库自增ID

某些数据库（如MySQL）支持自增字段，可以在数据库中生成ID。但这种方法在分布式环境下容易出现冲突。

中心化ID生成器

使用中心服务生成并分配ID，方法简单但增加了中心化系统的复杂性。

分布式锁

使用分布式锁来保证唯一的ID生成，但这种方式性能较低。

如何在Java项目中集成分布式ID生成器

选择合适的分布式ID生成方案

选择合适的分布式ID生成方案需要考虑项目的需求和特点，以下是一些选择建议：

并发量：如果并发量高，建议使用Snowflake算法或类似算法。
可用性：如果需要高度可用性，建议选择中心化ID生成器。
性能：如果性能是关键，推荐使用Snowflake算法。
简单性：如果系统规模较小，可以考虑使用UUID或数据库自增ID。

在项目中引入相关依赖

使用Maven或Gradle等构建工具引入相关依赖，例如Snowflake算法可以使用com.github.snowflake:enhanced-uid。

Maven配置

<dependency>
    <groupId>com.github.snowflake</groupId>
    <artifactId>enhanced-uid</artifactId>
    <version>1.0.0</version>
</dependency>

Gradle配置

dependencies {
    implementation 'com.github.snowflake:enhanced-uid:1.0.0'
}

如何调用分布式ID生成器

调用分布式ID生成器通常需要初始化生成器，并通过方法调用来生成ID。

初始化生成器

import com.github.snowflake.snowflake.SnowflakeIdGenerator;
import com.github.snowflake.snowflake.config.SnowflakeProperties;

public class IdGeneratorFactory {
    private static SnowflakeIdGenerator snowflakeIdGenerator;

    static {
        SnowflakeProperties snowflakeProperties = new SnowflakeProperties();
        snowflakeProperties.setDatacenterId(1L);
        snowflakeProperties.setWorkerId(1L);
        snowflakeIdGenerator = new SnowflakeIdGenerator(snowflakeProperties);
    }

    public static SnowflakeIdGenerator getSnowflakeIdGenerator() {
        return snowflakeIdGenerator;
    }
}

调用生成器

public class SnowflakeIdService {
    public long generateId() {
        return IdGeneratorFactory.getSnowflakeIdGenerator().nextId();
    }
}

public class Main {
    public static void main(String[] args) {
        SnowflakeIdService idService = new SnowflakeIdService();
        for (int i = 0; i < 10; i++) {
            System.out.println(idService.generateId());
        }
    }
}

分布式ID生成器的使用场景和案例

单体应用中的应用场景

单体应用中的分布式ID生成器可以用于生成用户ID、订单ID、文章ID等唯一标识符。

示例代码

public class OrderService {
    private SnowflakeIdGenerator idGenerator;

    public OrderService(SnowflakeIdGenerator idGenerator) {
        this.idGenerator = idGenerator;
    }

    public void createOrder() {
        long orderId = idGenerator.nextId();
        System.out.println("Order ID: " + orderId);
    }
}

public class Main {
    public static void main(String[] args) {
        SnowflakeIdGenerator idGenerator = IdGeneratorFactory.getSnowflakeIdGenerator();
        OrderService orderService = new OrderService(idGenerator);
        orderService.createOrder(); // 修改为 createOrder()
    }
}

微服务架构中的应用场景

微服务架构中，分布式ID生成器可以用于生成跨服务的全局唯一ID。

示例代码

import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ObjectNode;

public class OrderService {
    private SnowflakeIdGenerator idGenerator;

    public OrderService(SnowflakeIdGenerator idGenerator) {
        this.idGenerator = idGenerator;
    }

    public ObjectNode createOrder() {
        long orderId = idGenerator.nextId();
        ObjectNode order = new ObjectMapper().createObjectNode();
        order.put("orderId", orderId);
        return order;
    }
}

public class Main {
    public static void main(String[] args) {
        SnowflakeIdGenerator idGenerator = IdGeneratorFactory.getSnowflakeIdGenerator();
        OrderService orderService = new OrderService(idGenerator);
        ObjectNode order = orderService.createOrder();
        System.out.println(order.toString());
    }
}

其他典型使用场景

日志生成

生成全局唯一的日志ID。

任务调度

生成全局唯一的任务ID。

缓存键生成

生成全局唯一的缓存键。

分布式锁

生成全局唯一的锁ID。

示例代码

public class LogService {
    private SnowflakeIdGenerator idGenerator;

    public LogService(SnowflakeIdGenerator idGenerator) {
        this.idGenerator = idGenerator;
    }

    public void generateLogId() {
        long logId = idGenerator.nextId();
        System.out.println("Log ID: " + logId);
    }
}

public class Main {
    public static void main(String[] args) {
        SnowflakeIdGenerator idGenerator = IdGeneratorFactory.getSnowflakeIdGenerator();
        LogService logService = new LogService(idGenerator);
        logService.generateLogId();
    }
}

示例代码

public class TaskService {
    private SnowflakeIdGenerator idGenerator;

    public TaskService(SnowflakeIdGenerator idGenerator) {
        this.idGenerator = idGenerator;
    }

    public void generateTaskId() {
        long taskId = idGenerator.nextId();
        System.out.println("Task ID: " + taskId);
    }
}

public class Main {
    public static void main(String[] args) {
        SnowflakeIdGenerator idGenerator = IdGeneratorFactory.getSnowflakeIdGenerator();
        TaskService taskService = new TaskService(idGenerator);
        taskService.generateTaskId();
    }
}

示例代码

public class CacheService {
    private SnowflakeIdGenerator idGenerator;

    public CacheService(SnowflakeIdGenerator idGenerator) {
        this.idGenerator = idGenerator;
    }

    public String generateCacheKey() {
        long cacheKey = idGenerator.nextId();
        return String.valueOf(cacheKey);
    }
}

public class Main {
    public static void main(String[] args) {
        SnowflakeIdGenerator idGenerator = IdGeneratorFactory.getSnowflakeIdGenerator();
        CacheService cacheService = new CacheService(idGenerator);
        String cacheKey = cacheService.generateCacheKey();
        System.out.println("Cache Key: " + cacheKey);
    }
}

示例代码

public class LockService {
    private SnowflakeIdGenerator idGenerator;

    public LockService(SnowflakeIdGenerator idGenerator) {
        this.idGenerator = idGenerator;
    }

    public void generateLockId() {
        long lockId = idGenerator.nextId();
        System.out.println("Lock ID: " + lockId);
    }
}

public class Main {
    public static void main(String[] args) {
        SnowflakeIdGenerator idGenerator = IdGeneratorFactory.getSnowflakeIdGenerator();
        LockService lockService = new LockService(idGenerator);
        lockService.generateLockId();
    }
}

分布式ID的常见问题及解决方案

ID重复的问题及解决方案

ID重复是一个常见的问题，通常可以通过以下方式解决：

序列号重置：在Snowflake算法中，序列号在每毫秒内重置，以避免重复。
时间戳同步：确保所有节点的时间戳同步。
ID范围分配：为每个节点分配不同的ID范围。

示例代码

import java.util.concurrent.atomic.AtomicLong;

public class IdGenerator {
    private static final AtomicLong idGenerator = new AtomicLong(0);

    public static synchronized long nextId() {
        return idGenerator.incrementAndGet();
    }
}

public class Main {
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            System.out.println(IdGenerator.nextId());
        }
    }
}

雪崩效应的应对措施

雪崩效应是指在高并发场景下，生成器无法处理大量请求，导致系统崩溃。可以通过以下方式应对：

限流：限制生成器的请求频率。
缓存：使用缓存存储部分生成的ID。
多节点：增加多个生成器节点，分散压力。

示例代码

import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class IdGenerator {
    private static final ThreadPoolExecutor executor = new ThreadPoolExecutor(1, 10,
            60L, TimeUnit.SECONDS,
            new LinkedBlockingQueue<>(100));

    public static synchronized long nextId() {
        return executor.submit(() -> {
            Thread.sleep(10); // 模拟生成ID的操作
            return System.currentTimeMillis();
        }).get();
    }
}

public class Main {
    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            System.out.println(IdGenerator.nextId());
        }
    }
}

性能优化的策略

性能优化可以通过以下方式实现：

并行生成：使用多线程并行生成ID。
减少阻塞：避免生成器中的阻塞操作。
异步处理：使用异步处理减少等待时间。

示例代码

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ThreadPoolExecutor;

public class IdGenerator {
    private static final ThreadPoolExecutor executor = new ThreadPoolExecutor(1, 10,
            60L, TimeUnit.SECONDS,
            new LinkedBlockingQueue<>(100));

    public static CompletableFuture<Long> nextIdAsync() {
        return CompletableFuture.supplyAsync(() -> {
            Thread.sleep(10); // 模拟生成ID的操作
            return System.currentTimeMillis();
        }, executor);
    }
}

public class Main {
    public static void main(String[] args) {
        CompletableFuture<Long>[] futures = new CompletableFuture[10];
        for (int i = 0; i < futures.length; i++) {
            futures[i] = IdGenerator.nextIdAsync();
        }

        for (CompletableFuture<Long> future : futures) {
            System.out.println(future.join());
        }
    }
}

分布式ID生成器的测试和维护

如何测试分布式ID生成器的正确性和性能

测试分布式ID生成器需要确保ID的唯一性和性能。可以通过以下步骤实现：

单元测试：编写单元测试用例，验证ID生成的正确性。
性能测试：使用JMeter或LoadRunner等工具进行性能测试，模拟高并发场景。
集成测试：在真实环境中进行集成测试，验证在实际应用中的表现。

示例代码

import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;

public class IdGeneratorTest {
    private SnowflakeIdGenerator idGenerator = IdGeneratorFactory.getSnowflakeIdGenerator();

    @Test
    public void testIdUniqueness() {
        long id1 = idGenerator.nextId();
        long id2 = idGenerator.nextId();
        assertNotEquals(id1, id2);
    }

    @Test
    public void testIdOrder() {
        long id1 = idGenerator.nextId();
        long id2 = idGenerator.nextId();
        assertTrue(id1 < id2);
    }
}

维护和更新分布式ID生成器的注意事项

维护和更新分布式ID生成器需要注意以下几点：

备份数据：定期备份生成器的数据，防止数据丢失。
监控性能：实时监控生成器的性能，及时发现并解决性能瓶颈。
容错机制：确保生成器具有容错机制，防止单点故障导致系统崩溃。
版本管理：管理生成器的版本，确保所有节点使用相同版本。
文档更新：更新技术文档，确保团队成员了解最新改动。

示例代码

import com.github.snowflake.snowflake.SnowflakeIdGenerator;
import com.github.snowflake.snowflake.config.SnowflakeProperties;

public class IdGeneratorFactory {
    private static SnowflakeIdGenerator snowflakeIdGenerator;

    static {
        SnowflakeProperties snowflakeProperties = new SnowflakeProperties();
        snowflakeProperties.setDatacenterId(1L);
        snowflakeProperties.setWorkerId(1L);
        snowflakeIdGenerator = new SnowflakeIdGenerator(snowflakeProperties);
    }

    public static void updateIdGenerator(SnowflakeProperties properties) {
        snowflakeIdGenerator = new SnowflakeIdGenerator(properties);
    }

    public static SnowflakeIdGenerator getIdGenerator() {
        return snowflakeIdGenerator;
    }
}

public class Main {
    public static void main(String[] args) {
        SnowflakeProperties properties = new SnowflakeProperties();
        properties.setDatacenterId(2L);
        properties.setWorkerId(2L);
        IdGeneratorFactory.updateIdGenerator(properties);

        SnowflakeIdGenerator idGenerator = IdGeneratorFactory.getIdGenerator();
        for (int i = 0; i < 10; i++) {
            System.out.println(idGenerator.nextId());
        }
    }
}

通过以上内容，您应该能够理解分布式ID的基本概念、生成方案、使用方法以及常见问题的解决方案。希望这些信息对您的项目有所帮助。如果您需要进一步的技术支持，可以参考MooC网提供的相关课程和资源。

點擊查看更多內容

為 TA 點贊

若覺得本文不錯，就分享一下吧！

評論

評論

共同學習，寫下你的評論

評論加載中...

展開查看更多評論

作者其他優質文章

正在加載中

慕村225694

手記
篇

粉絲

9

獲贊與收藏

35

關注作者，訂閱最新文章

閱讀免費教程

Java并發工具

23個小節 19869 321

Java 并發原理入門教程

26個小節 40058 581

Java 入門教程

50個小節 351819 3256

推薦

評論

收藏

共同學習，寫下你的評論



感謝您的支持，我會繼續努力的～

掃碼打賞，你說多少就多少

贊賞金額會直接到老師賬戶

支付方式

打開微信掃一掃，即可進行掃碼打賞哦

今天注冊有機會得

100積分直接送

付費專欄免費學

大額優惠券免費領

立即參與放棄機會

點擊
抽獎

慕課手記新用戶專享福利

恭喜你，你的運氣太好了，居然抽中了 100個積分！

恭喜你，抽中了價值元的專欄！

太棒了，直接落到你賬戶里！

積分商城里的羅技鼠標、機械鍵盤、
Kindle 閱讀器、小米平衡車
Apple iPad （10.2英寸）、大額優惠券
在等著你去兌換了噢

作者：

免費贈送

兌換碼：1111222211 復制

優惠券可用于購買實戰課、體系課
無門檻使用

先去看看，有什么好東西馬上兌換我愛學習，選課去


亚洲在线久爱草,狠狠天天香蕉网,天天搞日日干久草,伊人亚洲日本欧美

熱搜

最近搜索清空

Java分布式ID入門教程

作用

意义

Snowflake算法的结构

示例代码实现

使用示例

优点

缺点

示例代码实现

取模法

数据库自增ID

中心化ID生成器

分布式锁

Maven配置

Gradle配置

初始化生成器

调用生成器

示例代码

示例代码

日志生成

任务调度

缓存键生成

分布式锁

示例代码

示例代码

示例代码

示例代码

示例代码

示例代码

示例代码

示例代码

示例代码

閱讀免費教程