1. Toy模板网首页
  2. > Toy博客

【智能排班系统】雪花算法生成分布式ID

8月前 作者：Hello Dam 分类：Toy博客 阅读(84) 违法举报

这篇具有很好参考价值的文章主要介绍了【智能排班系统】雪花算法生成分布式ID。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

雪花算法介绍

在复杂而庞大的分布式系统中，确保数据实体的唯一标识性是一项至关重要的任务，生成全局唯一且有序的ID生成机制成为必不可少的环节。雪花算法（Snowflake Algorithm）正是为此目的而生，以其简洁的设计、高效的表现与良好的扩展性赢得了业界的广泛认可。

起源与命名

雪花算法最早由Twitter公司于2010年左右设计并应用于其内部系统，旨在解决分布式环境中大规模、高并发的唯一ID生成问题。算法得名“雪花”，源于自然界中雪花的独特性——每片雪花的形态各异，象征着生成的ID如雪花般独一无二。这一形象化的命名，恰好体现了雪花算法所生成ID的特性：每个ID在全局范围内具有唯一性，且蕴含丰富的内部结构信息。

基本原理与结构

雪花算法的核心思想是将一个64位的长整型数字划分为多个部分，每个部分代表不同维度的信息。典型的雪花ID结构如下：

  • 符号位（1位）：通常为0，表示生成的ID为正数，符合大多数编程语言的长整数表示习惯。

  • 时间戳（41位）：记录了ID生成时的精确时间点，通常精确到毫秒级别。这使得ID具备了天然的时间顺序，同时也为系统提供了大致的时间范围参考。

  • 数据中心标识（5位）：用于区分不同的数据中心或地域，确保在多数据中心部署下ID的唯一性。

  • 机器标识（5位）：标识生成ID的工作节点，可以是服务器ID、进程ID等，确保同一数据中心内不同机器生成的ID不会冲突。

  • 序列号（12位）：在同一毫秒内，同一工作节点生成多个ID时，通过递增序列号来区分。序列号部分允许的最大值为4095（即每毫秒可以生成2^12个不重复ID），足以应对大部分场景下的瞬时并发需求。

这种划分方式确保了雪花ID在空间分布上既能容纳足够多的节点和并发请求，又能在时间维度上保持严格递增，从而满足全局唯一、趋势有序的需求。当然，每个部分的位数不是固定的，如果需求更复杂，可以增加相应部分的位数。例如，并发非常高，可以增加序列号的位数。

优势与特点

  • 全局唯一：由于时间戳、数据中心标识、机器标识和序列号的组合具有唯一性，雪花算法能确保在分布式环境中生成的每一个ID都是全球唯一的。

  • 趋势递增：时间戳作为ID的主要部分，使得生成的ID整体上按照时间顺序排列，有利于数据库索引优化，提升查询效率。

  • 高可用：在单个节点故障时，其他节点仍能继续生成ID，不会影响整个系统的运行。同时，通过合理分配数据中心和机器标识，可以轻松应对节点扩容或迁移。

  • 高效性：算法实现简单，生成ID过程几乎无锁，性能极高。并且由于ID为纯数字型，存储和传输效率高。

  • 易于解析：由于ID结构清晰，可以根据ID直接解析出其包含的时间、数据中心、机器等信息，便于日志分析、问题定位和数据归档。

应用场景

雪花算法适用于多种需要全局唯一ID的分布式场景，包括但不限于：

  • 数据库主键：作为数据库表的主键，确保每一行记录具有唯一标识，且插入顺序与生成时间相关联。

  • 消息队列：为消息系统中的消息生成唯一ID，便于消息追踪、去重和排序。

  • 分布式事务：在分布式事务中，为事务ID或操作记录分配唯一标识。

  • 分布式缓存：为缓存中的键生成唯一ID，避免键冲突。

代码实现

代码结构

【智能排班系统】雪花算法生成分布式ID,# 智能排班系统,算法,分布式,雪花算法

自定义机器标识

package com.dam.core.snowflake;

import cn.hutool.core.date.SystemClock;
import com.dam.core.snowflake.entity.WorkCenterInfo;
import lombok.extern.slf4j.Slf4j;
import com.dam.toolkit.SnowflakeIdUtil;
import org.springframework.beans.factory.annotation.Value;

/**
 * 雪花算法模板生成
 *
 */
@Slf4j
public abstract class AbstractWorkIdChooseTemplate {

    /**
     * 是否使用 {@link SystemClock} 获取当前时间戳
     */
    @Value("${sss.snowflake.is-use-system-clock:false}")
    private boolean isUseSystemClock;

    /**
     * 根据自定义策略获取 WorkId 生成器
     *
     * @return
     */
    protected abstract WorkCenterInfo chooseWorkId();

    /**
     * 选择 WorkId 并初始化雪花
     */
    public void chooseAndInit() {
        // 模板方法模式: 通过调用抽象方法获取 WorkId 来创建雪花算法，抽象方法的具体实现交给子类
        WorkCenterInfo workCenterInfo = chooseWorkId();
        long workId = workCenterInfo.getWorkId();
        long dataCenterId = workCenterInfo.getDataCenterId();
        // 生成机器标识之后，初始化工具类的雪花算法静态对象
        Snowflake snowflake = new Snowflake(workId, dataCenterId, isUseSystemClock);
        log.info("Snowflake type: {}, workId: {}, dataCenterId: {}", this.getClass().getSimpleName(), workId, dataCenterId);
        SnowflakeIdUtil.initSnowflake(snowflake);
    }
}

RandomWorkIdChoose和LocalRedisWorkIdChoose主要用来实现抽象方法chooseWorkId来生成工作中心ID和数据中心ID

  • RandomWorkIdChoose：随机生成
  • LocalRedisWorkIdChoose：使用Redis的lua脚本，保证分布式部署的时候，每台机器的数据中心ID或工作中心ID不同

RandomWorkIdChoose

通过随机生成的dataCenterId和workId很容易发生冲突，属项目没有Redis的无奈之举。但是在日常开发中，项目基本都是需要使用Redis的，所以RandomWorkIdChoose也很少会使用。

package com.dam.core.snowflake;

import com.dam.core.snowflake.entity.WorkCenterInfo;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.InitializingBean;

/**
 * 使用随机数获取雪花 WorkId
 */
@Slf4j
public class RandomWorkIdChoose extends AbstractWorkIdChooseTemplate implements InitializingBean {

    @Override
    protected WorkCenterInfo chooseWorkId() {
        int start = 0, end = 31;
        return new WorkCenterInfo(getRandom(start, end), getRandom(start, end));
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        chooseAndInit();
    }

    private static long getRandom(int start, int end) {
        long random = (long) (Math.random() * (end - start + 1) + start);
        return random;
    }
}

LocalRedisWorkIdChoose

通过使用Redis来记录上一台机器所申请的dataCenterId和workId，新机器申请标识的时候，通过对已有dataCenterId或workId进行递增从而找到没有被使用的dataCenterId和workId组合。但是因为位数的约束，不重复数肯定有一个上限，需要根据集群大小来调整数据中心和工作中心的位数

package com.dam.core.snowflake;

import cn.hutool.core.collection.CollUtil;
import com.dam.ApplicationContextHolder;
import com.dam.core.snowflake.entity.WorkCenterInfo;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.core.io.ClassPathResource;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.script.DefaultRedisScript;
import org.springframework.scripting.support.ResourceScriptSource;

import java.util.ArrayList;
import java.util.List;

/**
 * 使用 Redis 获取雪花 WorkId
 */
@Slf4j
public class LocalRedisWorkIdChoose extends AbstractWorkIdChooseTemplate implements InitializingBean {

    private RedisTemplate stringRedisTemplate;

    public LocalRedisWorkIdChoose() {
        System.out.println("执行 LocalRedisWorkIdChoose -----------------------");
        StringRedisTemplate bean = ApplicationContextHolder.getBean(StringRedisTemplate.class);
//        System.out.println("bean = " + bean);
        this.stringRedisTemplate = bean;
    }

    @Override
    public WorkCenterInfo chooseWorkId() {
        DefaultRedisScript redisScript = new DefaultRedisScript();
        redisScript.setScriptSource(new ResourceScriptSource(new ClassPathResource("lua/chooseWorkIdLua.lua")));
        List<Long> luaResultList = null;
        try {
            redisScript.setResultType(List.class);
            luaResultList = (ArrayList) this.stringRedisTemplate.execute(redisScript, null);
        } catch (Exception ex) {
            log.error("Redis Lua 脚本获取 WorkId 失败", ex);
        }
        return CollUtil.isNotEmpty(luaResultList) ? new WorkCenterInfo(luaResultList.get(0), luaResultList.get(1)) : new RandomWorkIdChoose().chooseWorkId();
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        chooseAndInit();
    }
}
lua脚本

lua脚本旨在为不同的机器生成不同的数据中心ID或者工作中心ID，避免不同机器生成冲突的ID。但是由于数据中心部分和工作中心部分都是占5 bit，所以最多生成1024个不同的【数据中心、工作中心】组合，如果集群的机器数量大于1024，就要考虑给数据中心和工作中心分配更多的位数。

-- 定义了三个本地变量：
-- hashKey：表示在Redis中存储工作ID和数据中心ID的哈希表（Hash）的键名
-- dataCenterIdKey 和 workIdKey：分别表示哈希表中存储数据中心ID和工作ID的字段名
local hashKey = 'sss:snowflake_work_id_key'
local dataCenterIdKey = 'dataCenterId'
local workIdKey = 'workId'

-- 首先，检查哈希表hashKey是否存在。
-- 如果不存在（即首次初始化），则创建该哈希表并使用hincrby命令初始化dataCenterIdKey和workIdKey字段，初始值均为0
-- 然后返回一个数组 { 0, 0 }，表示当前工作ID和数据中心ID均为0
if (redis.call('exists', hashKey) == 0) then
    redis.call('hincrby', hashKey, dataCenterIdKey, 0)
    redis.call('hincrby', hashKey, workIdKey, 0)
    return { 0, 0 }
end

-- 若哈希表已存在，从哈希表中获取当前的dataCenterId和workId值，并将其转换为数字类型
local dataCenterId = tonumber(redis.call('hget', hashKey, dataCenterIdKey))
local workId = tonumber(redis.call('hget', hashKey, workIdKey))

-- 定义最大值常量max为31，用于判断ID是否达到上限
local max = 31
-- 定义两个局部变量resultWorkId和resultDataCenterId，用于存储最终要返回的新工作ID和数据中心ID
local resultWorkId = 0
local resultDataCenterId = 0

-- 如果两者均达到上限（dataCenterId == max且workId == max），将它们重置为0
if (dataCenterId == max and workId == max) then
    redis.call('hset', hashKey, dataCenterIdKey, '0')
    redis.call('hset', hashKey, workIdKey, '0')

-- 若只有工作ID未达上限（workId ~= max），递增工作ID（hincrby），并将新的工作ID作为结果，数据中心ID保持不变
elseif (workId ~= max) then
    resultWorkId = redis.call('hincrby', hashKey, workIdKey, 1)
    resultDataCenterId = dataCenterId

-- 若只有数据中心ID未达上限（dataCenterId ~= max），递增数据中心ID，将新的数据中心ID作为结果，同时将工作ID重置为0
elseif (dataCenterId ~= max) then
    resultWorkId = 0
    resultDataCenterId = redis.call('hincrby', hashKey, dataCenterIdKey, 1)
    redis.call('hset', hashKey, workIdKey, '0')
end

return { resultWorkId, resultDataCenterId }

实体类

SnowflakeIdInfo

package com.dam.core.snowflake.entity;

import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * 雪花算法组成部分，通常用来反解析使用
 */
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class SnowflakeIdInfo {

    /**
     * 时间戳
     */
    @JsonSerialize(using = ToStringSerializer.class)
    private Long timestamp;

    /**
     * 工作机器节点 ID
     */
    private Integer workerId;

    /**
     * 数据中心 ID
     */
    private Integer dataCenterId;

    /**
     * 自增序号，当高频模式下时，同一毫秒内生成 N 个 ID，则这个序号在同一毫秒下，自增以避免 ID 重复
     */
    private Integer sequence;

    /**
     * 通过基因法生成的序号，会和 {@link SnowflakeIdInfo#sequence} 共占 12 bit
     */
    private Integer gene;
}

WorkCenterInfo

package com.dam.core.snowflake.entity;

import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * WorkId 包装器
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
public class WorkCenterInfo {
    /**
     * 工作ID
     */
    @JsonSerialize(using = ToStringSerializer.class)
    private Long workId;

    /**
     * 数据中心ID
     */
    @JsonSerialize(using = ToStringSerializer.class)
    private Long dataCenterId;
}

雪花算法类

package com.dam.core.snowflake;

import cn.hutool.core.date.SystemClock;
import cn.hutool.core.lang.Assert;
import cn.hutool.core.util.IdUtil;
import cn.hutool.core.util.RandomUtil;
import cn.hutool.core.util.StrUtil;
import com.dam.core.IdGenerator;
import com.dam.core.snowflake.entity.SnowflakeIdInfo;

import java.io.Serializable;
import java.util.Date;

/**
 * 雪花算法真正生成ID的类
 *
 * Twitter的Snowflake 算法
 * 分布式系统中，有一些需要使用全局唯一ID的场景，有些时候我们希望能使用一种简单一些的ID，并且希望ID能够按照时间有序生成。
 *
 * snowflake的结构如下(每部分用-分开):
 *
 * 符号位（1bit）- 时间戳相对值（41bit）- 数据中心标志（5bit）- 机器标志（5bit）- 递增序号（12bit）
 * 0 - 0000000000 0000000000 0000000000 0000000000 0 - 00000 - 00000 - 000000000000
 * 
 * 第一位为未使用(符号位表示正数)，接下来的41位为毫秒级时间(41位的长度可以使用69年)<br>
 * 然后是5位datacenterId和5位workerId(10位的长度最多支持部署1024个节点）<br>
 * 最后12位是毫秒内的计数（12位的计数顺序号支持每个节点每毫秒产生4096个ID序号）
 * 
 * 并且可以通过生成的id反推出生成时间,datacenterId和workerId
 * 
 * 参考：http://www.cnblogs.com/relucent/p/4955340.html<br>
 * 关于长度是18还是19的问题见：https://blog.csdn.net/unifirst/article/details/80408050
 *
 * @author Looly
 * @since 3.0.1
 */
public class Snowflake implements Serializable, IdGenerator {

    private static final long serialVersionUID = 1L;

    /**
     * 默认的起始时间，为Thu, 04 Nov 2010 01:42:54 GMT
     */
    private static long DEFAULT_TWEPOCH = 1288834974657L;

    /**
     * 默认回拨时间，2S
     */
    private static long DEFAULT_TIME_OFFSET = 2000L;

    private static final long WORKER_ID_BITS = 5L;

    // 最大支持机器节点数0~31，一共32个
    @SuppressWarnings({"PointlessBitwiseExpression", "FieldCanBeLocal"})
    private static final long MAX_WORKER_ID = -1L ^ (-1L << WORKER_ID_BITS);

    private static final long DATA_CENTER_ID_BITS = 5L;

    // 最大支持数据中心节点数0~31，一共32个
    @SuppressWarnings({"PointlessBitwiseExpression", "FieldCanBeLocal"})
    private static final long MAX_DATA_CENTER_ID = -1L ^ (-1L << DATA_CENTER_ID_BITS);

    // 序列号12位（表示只允许workId的范围为：0-4095）
    private static final long SEQUENCE_BITS = 12L;

    // 机器节点左移12位
    private static final long WORKER_ID_SHIFT = SEQUENCE_BITS;

    // 数据中心节点左移17位
    private static final long DATA_CENTER_ID_SHIFT = SEQUENCE_BITS + WORKER_ID_BITS;

    // 时间毫秒数左移22位
    private static final long TIMESTAMP_LEFT_SHIFT = SEQUENCE_BITS + WORKER_ID_BITS + DATA_CENTER_ID_BITS;

    // 序列掩码，用于限定序列最大值不能超过4095
    private static final long SEQUENCE_MASK = ~(-1L << SEQUENCE_BITS);

    /**
     * 初始化时间点
     */
    private final long twepoch;

    private final long workerId;

    private final long dataCenterId;

    private final boolean useSystemClock;

    /**
     * 允许的时钟回拨毫秒数
     */
    private final long timeOffset;

    /**
     * 当在低频模式下时，序号始终为0，导致生成ID始终为偶数<br>
     * 此属性用于限定一个随机上限，在不同毫秒下生成序号时，给定一个随机数，避免偶数问题。<br>
     * 注意次数必须小于{@link #SEQUENCE_MASK}，{@code 0}表示不使用随机数。<br>
     * 这个上限不包括值本身。
     */
    private final long randomSequenceLimit;

    /**
     * 自增序号，当高频模式下时，同一毫秒内生成N个ID，则这个序号在同一毫秒下，自增以避免ID重复。
     */
    private long sequence = 0L;

    private long lastTimestamp = -1L;

    /**
     * 构造，使用自动生成的工作节点ID和数据中心ID
     */
    public Snowflake() {
        this(IdUtil.getWorkerId(IdUtil.getDataCenterId(MAX_DATA_CENTER_ID), MAX_WORKER_ID));
    }

    /**
     * @param workerId 终端ID
     */
    public Snowflake(long workerId) {
        this(workerId, IdUtil.getDataCenterId(MAX_DATA_CENTER_ID));
    }

    /**
     * @param workerId     终端ID
     * @param dataCenterId 数据中心ID
     */
    public Snowflake(long workerId, long dataCenterId) {
        this(workerId, dataCenterId, false);
    }

    /**
     * @param workerId         终端ID
     * @param dataCenterId     数据中心ID
     * @param isUseSystemClock 是否使用{@link SystemClock} 获取当前时间戳
     */
    public Snowflake(long workerId, long dataCenterId, boolean isUseSystemClock) {
        this(null, workerId, dataCenterId, isUseSystemClock);
    }

    /**
     * @param epochDate        初始化时间起点（null表示默认起始日期）,后期修改会导致id重复,如果要修改连workerId dataCenterId，慎用
     * @param workerId         工作机器节点id
     * @param dataCenterId     数据中心id
     * @param isUseSystemClock 是否使用{@link SystemClock} 获取当前时间戳
     * @since 5.1.3
     */
    public Snowflake(Date epochDate, long workerId, long dataCenterId, boolean isUseSystemClock) {
        this(epochDate, workerId, dataCenterId, isUseSystemClock, DEFAULT_TIME_OFFSET);
    }

    /**
     * @param epochDate        初始化时间起点（null表示默认起始日期）,后期修改会导致id重复,如果要修改连workerId dataCenterId，慎用
     * @param workerId         工作机器节点id
     * @param dataCenterId     数据中心id
     * @param isUseSystemClock 是否使用{@link SystemClock} 获取当前时间戳
     * @param timeOffset       允许时间回拨的毫秒数
     * @since 5.8.0
     */
    public Snowflake(Date epochDate, long workerId, long dataCenterId, boolean isUseSystemClock, long timeOffset) {
        this(epochDate, workerId, dataCenterId, isUseSystemClock, timeOffset, 0);
    }

    /**
     * @param epochDate           初始化时间起点（null表示默认起始日期）,后期修改会导致id重复,如果要修改连workerId dataCenterId，慎用
     * @param workerId            工作机器节点id
     * @param dataCenterId        数据中心id
     * @param isUseSystemClock    是否使用{@link SystemClock} 获取当前时间戳
     * @param timeOffset          允许时间回拨的毫秒数
     * @param randomSequenceLimit 限定一个随机上限，在不同毫秒下生成序号时，给定一个随机数，避免偶数问题，0表示无随机，上限不包括值本身。
     * @since 5.8.0
     */
    public Snowflake(Date epochDate, long workerId, long dataCenterId, boolean isUseSystemClock, long timeOffset, long randomSequenceLimit) {
        this.twepoch = (null != epochDate) ? epochDate.getTime() : DEFAULT_TWEPOCH;
        this.workerId = Assert.checkBetween(workerId, 0, MAX_WORKER_ID);
        this.dataCenterId = Assert.checkBetween(dataCenterId, 0, MAX_DATA_CENTER_ID);
        this.useSystemClock = isUseSystemClock;
        this.timeOffset = timeOffset;
        this.randomSequenceLimit = Assert.checkBetween(randomSequenceLimit, 0, SEQUENCE_MASK);
    }

    /**
     * 根据Snowflake的ID，获取机器id
     *
     * @param id snowflake算法生成的id
     * @return 所属机器的id
     */
    public long getWorkerId(long id) {
        return id >> WORKER_ID_SHIFT & ~(-1L << WORKER_ID_BITS);
    }

    /**
     * 根据Snowflake的ID，获取数据中心id
     *
     * @param id snowflake算法生成的id
     * @return 所属数据中心
     */
    public long getDataCenterId(long id) {
        return id >> DATA_CENTER_ID_SHIFT & ~(-1L << DATA_CENTER_ID_BITS);
    }

    /**
     * 根据Snowflake的ID，获取生成时间
     *
     * @param id snowflake算法生成的id
     * @return 生成的时间
     */
    public long getGenerateDateTime(long id) {
        return (id >> TIMESTAMP_LEFT_SHIFT & ~(-1L << 41L)) + twepoch;
    }

    /**
     * 下一个ID
     *
     * @return ID
     */
    @Override
    public synchronized long nextId() {
        long timestamp = genTime();
        if (timestamp < this.lastTimestamp) {
            if (this.lastTimestamp - timestamp < timeOffset) {
                // 容忍指定的回拨，避免NTP校时造成的异常
                timestamp = lastTimestamp;
            } else {
                // 如果服务器时间有问题(时钟后退) 报错。
                throw new IllegalStateException(StrUtil.format("Clock moved backwards. Refusing to generate id for {}ms", lastTimestamp - timestamp));
            }
        }
        if (timestamp == this.lastTimestamp) {
            final long sequence = (this.sequence + 1) & SEQUENCE_MASK;
            if (sequence == 0) {
                timestamp = tilNextMillis(lastTimestamp);
            }
            this.sequence = sequence;
        } else {
            // issue#I51EJY
            if (randomSequenceLimit > 1) {
                sequence = RandomUtil.randomLong(randomSequenceLimit);
            } else {
                sequence = 0L;
            }
        }
        lastTimestamp = timestamp;
        return ((timestamp - twepoch) << TIMESTAMP_LEFT_SHIFT) | (dataCenterId << DATA_CENTER_ID_SHIFT) | (workerId << WORKER_ID_SHIFT) | sequence;
    }

    /**
     * 下一个ID（字符串形式）
     *
     * @return ID 字符串形式
     */
    @Override
    public String nextIdStr() {
        return Long.toString(nextId());
    }

    // ------------------------------------------------------------------------------------------------------------------------------------ Private method start

    /**
     * 循环等待下一个时间
     *
     * @param lastTimestamp 上次记录的时间
     * @return 下一个时间
     */
    private long tilNextMillis(long lastTimestamp) {
        long timestamp = genTime();
        // 循环直到操作系统时间戳变化
        while (timestamp == lastTimestamp) {
            timestamp = genTime();
        }
        if (timestamp < lastTimestamp) {
            // 如果发现新的时间戳比上次记录的时间戳数值小，说明操作系统时间发生了倒退，报错
            throw new IllegalStateException(StrUtil.format("Clock moved backwards. Refusing to generate id for {}ms", lastTimestamp - timestamp));
        }
        return timestamp;
    }

    /**
     * 生成时间戳
     *
     * @return 时间戳
     */
    private long genTime() {
        return this.useSystemClock ? SystemClock.now() : System.currentTimeMillis();
    }
    
    /**
     * 解析雪花算法生成的 ID 为对象
     *
     * @param snowflakeId 雪花算法 ID
     * @return
     */
    public SnowflakeIdInfo parseSnowflakeId(long snowflakeId) {
        SnowflakeIdInfo snowflakeIdInfo = SnowflakeIdInfo.builder().sequence((int) (snowflakeId & ~(-1L << SEQUENCE_BITS))).workerId((int) ((snowflakeId >> WORKER_ID_SHIFT)
                & ~(-1L << WORKER_ID_BITS))).dataCenterId((int) ((snowflakeId >> DATA_CENTER_ID_SHIFT)
                        & ~(-1L << DATA_CENTER_ID_BITS)))
                .timestamp((snowflakeId >> TIMESTAMP_LEFT_SHIFT) + twepoch).build();
        return snowflakeIdInfo;
    }
}

配置类

根据项目是否配置Redis进而判断选择注入LocalRedisWorkIdChoose还是RandomWorkIdChoose。若项目有Redis，则注入LocalRedisWorkIdChoose，反之，注入RandomWorkIdChoose

package com.dam.config;

import com.dam.ApplicationContextHolder;
import com.dam.core.snowflake.LocalRedisWorkIdChoose;
import com.dam.core.snowflake.RandomWorkIdChoose;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;

/**
 * 分布式 ID 自动装配
 *
 */
@Import(ApplicationContextHolder.class)
@Configuration
public class DistributedIdAutoConfiguration {

    /**
     * 本地 Redis 构建雪花 WorkId 选择器
     */
    @Bean
    public LocalRedisWorkIdChoose redisWorkIdChoose() {
        return new LocalRedisWorkIdChoose();
    }

    /**
     * 随机数构建雪花 WorkId 选择器。如果项目未使用 Redis，使用该选择器
     */
    @Bean
    @ConditionalOnMissingBean(LocalRedisWorkIdChoose.class)
    public RandomWorkIdChoose randomWorkIdChoose() {
        return new RandomWorkIdChoose();
    }
}

雪花算法工具类

注意，SNOWFLAKE是一个静态变量，在AbstractWorkIdChooseTemplate抽象类的chooseAndInit方法中被初始化

package com.dam.toolkit;

import com.dam.core.snowflake.Snowflake;
import com.dam.core.snowflake.entity.SnowflakeIdInfo;

/**
 * 分布式雪花 ID 生成器
 *
 */
public final class SnowflakeIdUtil {

    /**
     * 雪花算法对象
     */
    private static Snowflake SNOWFLAKE;

    /**
     * 初始化雪花算法
     */
    public static void initSnowflake(Snowflake snowflake) {
        SnowflakeIdUtil.SNOWFLAKE = snowflake;
    }

    /**
     * 获取雪花算法实例
     */
    public static Snowflake getInstance() {
        return SNOWFLAKE;
    }

    /**
     * 获取雪花算法下一个 ID
     */
    public static long nextId() {
        return SNOWFLAKE.nextId();
    }

    /**
     * 获取雪花算法下一个字符串类型 ID
     */
    public static String nextIdStr() {
        return Long.toString(nextId());
    }

    /**
     * 解析雪花算法生成的 ID 为对象
     */
    public static SnowflakeIdInfo parseSnowflakeId(String snowflakeId) {
        return SNOWFLAKE.parseSnowflakeId(Long.parseLong(snowflakeId));
    }

    /**
     * 解析雪花算法生成的 ID 为对象
     */
    public static SnowflakeIdInfo parseSnowflakeId(long snowflakeId) {
        return SNOWFLAKE.parseSnowflakeId(snowflakeId);
    }

}

说明

本文代码来源于马哥 12306 的代码，本人只是根据自己的理解进行少量修改并应用到智能排班系统中。代码仓库为12306，该项目含金量较高，有兴趣的朋友们建议去学习一下。文章来源地址https://www.toymoban.com/news/detail-846516.html

到了这里，关于【智能排班系统】雪花算法生成分布式ID的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • 分布式唯一ID生成算法——雪花算法（SnowFlake）

    分布式唯一ID生成算法——雪花算法（SnowFlake）

    SnowFlake算法 据国家大气研究中心的查尔斯·奈特称，一般的雪花大约由10^19个水分子组成。在雪花形成过程中，会形成不同的结构分支，所以说大自然中不存在两片完全一样的雪花，每一片雪花都拥有自己漂亮独特的形状。 雪花算法表示生成的id如雪花般独一无二。 snowflake是

    2023年04月20日
    浏览(47)
  • 【Java笔记】分布式id生成-雪花算法

    【Java笔记】分布式id生成-雪花算法

    随着业务的增长，有些表可能要占用很大的物理存储空间，为了解决该问题，后期使用数据库分片技术。将一个数据库进行拆分，通过数据库中间件连接。如果数据库中该表选用ID自增策略，则可能产生重复的ID，此时应该使用分布式ID生成策略来生成ID。 snowflake是Twitter开源的

    2024年02月11日
    浏览(43)
  • 分布式ID（2）：雪花算法生成ID

    分布式ID（2）：雪花算法生成ID

    1 雪花算法简介 这种方案大致来说是一种以划分命名空间（UUID也算，由于比较常见，所以单独分析）来生成ID的一种算法，这种方案把64-bit分别划分成多段，分开来标示机器、时间等，比如在snowflake中的64-bit分别表示如下图（图片来自网络）所示： 41-bit的时间可以表示（1L

    2024年01月20日
    浏览(47)
  • 分布式Id生成之雪花算法（SnowFlake）

    分布式Id生成之雪花算法（SnowFlake）

    目录 前言 回顾二进制 二进制概念 运算法则 位（Bit） 字节（Byte） 字符 字符集 二进制原码、反码、补码 有符号数和无符号数 疑问：为什么不是-127 ～ 127 ？ 为什么需要分布式全局唯一ID以及分布式ID得业务需求？ ID生成规则部分硬性要求 ID生成系统的可用性要求 通用解决方

    2024年02月11日
    浏览(35)

  • 雪花算法，在分布式环境下实现高效的ID生成

    其实雪花算法比较简单，可能称不上什么算法，就是一种构造UID的方法。 点1：UID是一个long类型的41位时间戳，10位存储机器码，12位存储序列号。 点2：时间戳的单位是毫秒，可以同时链接1024台机器，每台机器每毫秒可以使用4096个序列号，我们会给生成id上一个同步锁，阻塞

    2024年02月15日
    浏览(56)

  • 对于现有的分布式id发号器的思考 id生成器 雪花算法 uuid

    目录 雪花id tinyid uuid 分布式id特点 业务编号 数据中心编号 当前时间 ip地址 当前序号 对于时钟回拨问题 发号器机器当期时间小于redis的时间 解决步骤 发号器机器当期时间等于redis时间 发号器机器当期时间大于redis最大的时间（相关的key不存在） 分布式id的单次获取和批次获

    2024年02月13日
    浏览(52)
  • 分布式唯一ID 雪花算法

    分布式唯一ID 雪花算法

           📝个人主页：五敷有你        🔥系列专栏：算法分析与设计 ⛺️稳中求进，晒太阳 雪花算法是 64 位 的二进制，一共包含了四部分： 1位是符号位，也就是最高位，始终是0，没有任何意义，因为要是唯一计算机二进制补码中就是负数，0才是正数。 41位是时间戳

    2024年04月10日
    浏览(46)
  • 分布式id解决方法--雪花算法

    分布式id解决方法--雪花算法

    uuid，jdk自带，但是数据库性能差，32位呀。 mysql数据库主键越短越好，B+tree产生节点分裂，大大降低数据库性能，所以uuid不建议。 redis的自增，但是要配置维护redis集群，就为了一个id，还要引入一套redis。费事，成本高。 如果有序自增别人就知道你的业务量多少了。 分布式

    2024年02月04日
    浏览(43)
  • C# 分布式自增ID算法snowflake（雪花算法）

    C# 分布式自增ID算法snowflake（雪花算法）

    分布式系统中，有一些需要使用全局唯一 ID 的场景，这种时候为了防止 ID 冲突可以使用36位的 UUID ，但是 UUID 有一些缺点，首先他相对比较长，另外 UUID 一般是无序的。有些时候我们希望能使用一种简单一些的 ID ，并且希望 ID 能够按照时间有序生成。而 Twitter 的 snowflake 解

    2024年04月10日
    浏览(48)
  • JAVA实用工具： 改良版雪花算法-分布式唯一ID神器

    JAVA实用工具： 改良版雪花算法-分布式唯一ID神器

    Seata内置了一个分布式UUID生成器，用于辅助生成全局事务ID和分支事务ID。具体如下特点： 高性能 全局唯一 趋势递增 这个分布式UUID生成器是基于雪花算法进行改良的，本文针对改良的方法、目的等进行总结 改良版雪花算法的实现原理参考如下： Seata基于改良版雪花算法的分

    2024年02月14日
    浏览(42)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包