生成ID的方式

冰魄秋雨

于 2024-05-19 00:10:54 发布

阅读量582

点赞数 6

分类专栏：从产品中思考后端设计文章标签：后端 java

本文链接：https://blog.csdn.net/qq_17842663/article/details/139033783

版权

从产品中思考后端设计专栏收录该内容

4 篇文章 0 订阅

订阅专栏

在产品原型中，有一个编号，是需要特殊字段+年月日+数字的方式生产，这样就能够通过编号的方式，知道该编码是什么编码和哪天产生的。

比如订货单生产的编号：DHDD2024051300003
DHDD：表示订货单据
20240513：表示生产的日期为2024-05-13
00003：一串数字，唯一的

这种编码就能够很直观的表达单据的信息

一般生成ID的方式

生产单号的方式：

UUID
雪花算法：
自增序列（通过mysql或redis的方式）
特殊编码（特殊字段+日期+自增数）

UUID

在java中通过 java.util.UUID的方式来生成

String txNo = UUID.randomUUID().toString().replace("-", "");

UUID.randomUUID().toString()生成UUID 字符串的长度为 36 个字符，其中包括 32 个十六进制数字和 4 个分隔符，如果不需要分隔符，则直接替换掉
UUID的方式简单，支持分布式，但是缺点就是占用过多的空间，可读性差

雪花算法

雪花算法是一种全局ID生成算法，其核心思想是将64位的long型ID分为四个部分，分别为：时间戳、工作机器ID、数据中心ID和序列号

public class SnowflakeIdWorker{  
    /** 开始时间截 (2015-01-01) */
    private final long twepoch = 1288834974657L;

    /** 机器id所占的位数 */
    private final long workerIdBits = 5L;

    /** 数据标识id所占的位数 */
    private final long datacenterIdBits = 5L;

    /** 支持的最大机器id，结果是31 (这个移位算法可以很快的计算出几位二进制数所能表示的最大十进制数) */
    private final long maxWorkerId = -1L ^ (-1L << workerIdBits);

    /** 支持的最大数据标识id，结果是31 */
    private final long maxDatacenterId = -1L ^ (-1L << datacenterIdBits);

    /** 序列在id中占的位数 */
    private final long sequenceBits = 12L;

    /** 机器ID向左移12位 */
    private final long workerIdShift = sequenceBits;

    /** 数据标识id向左移17位(12+5) */
    private final long datacenterIdShift = sequenceBits + workerIdBits;

    /** 时间截向左移22位(5+5+12) */
    private final long timestampLeftShift = sequenceBits + workerIdBits
            + datacenterIdBits;

    /** 生成序列的掩码，这里为4095 (0b111111111111=0xfff=4095) */
    private final long sequenceMask = -1L ^ (-1L << sequenceBits);

    /** 工作机器ID(0~31) */
    private long workerId;

    /** 数据中心ID(0~31) */
    private long datacenterId;

    /** 毫秒内序列(0~4095) */
    private long sequence = 0L;

    /** 上次生成ID的时间截 */
    private long lastTimestamp = -1L;
    
    /**
     * 构造函数
     * 
     * @param workerId
     *            工作ID (0~31)
     * @param datacenterId
     *            数据中心ID (0~31)
     */
    public SnowflakeId(long workerId, long datacenterId) {
        if (workerId > maxWorkerId || workerId < 0) {
            throw new IllegalArgumentException(String.format(
                    "worker Id can't be greater than %d or less than 0",
                    maxWorkerId));
        }
        if (datacenterId > maxDatacenterId || datacenterId < 0) {
            throw new IllegalArgumentException(String.format(
                    "datacenter Id can't be greater than %d or less than 0",
                    maxDatacenterId));
        }
        this.workerId = workerId;
        this.datacenterId = datacenterId;
    }

    /**
     * 获得下一个ID (该方法是线程安全的)
     * 
     * @return SnowflakeId
     */
    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) & sequenceMask;
            // 毫秒内序列溢出
            if (sequence == 0) {
                // 阻塞到下一个毫秒,获得新的时间戳
                timestamp = tilNextMillis(lastTimestamp);
            }
        }
        // 时间戳改变，毫秒内序列重置
        else {
            sequence = 0L;
        }

        // 上次生成ID的时间截
        lastTimestamp = timestamp;

        // 移位并通过或运算拼到一起组成64位的ID
        return ((timestamp - twepoch) << timestampLeftShift) //
                | (datacenterId << datacenterIdShift) //
                | (workerId << workerIdShift) //
                | sequence;
    }

    /**
     * 阻塞到下一个毫秒，直到获得新的时间戳
     * 
     * @param lastTimestamp
     *            上次生成ID的时间截
     * @return 当前时间戳
     */
    protected long tilNextMillis(long lastTimestamp) {
        long timestamp = timeGen();
        while (timestamp <= lastTimestamp) {
            timestamp = timeGen();
        }
        return timestamp;
    }

    /**
     * 返回以毫秒为单位的当前时间
     * 
     * @return 当前时间(毫秒)
     */
    protected long timeGen() {
        return System.currentTimeMillis();
    }
}

可以直接使用hutool工具的雪花算法工具类生产，如果使用到mybatis-plus，则

上述java代码生成ID的过程，超过了毫秒级生产数量，则延迟到下一秒中生成
可以直接使用hutool工具的雪花算法工具
IdUtil.getSnowflakeNextIdStr()
如果使用到了mybatis-plus 也可以使用
IdWorker.getIdStr();

自增序列

mysql 自增

创建一张表

CREATE TABLE SoWhat_ID.SEQUENCE_ID (
    `id` bigint(20) unsigned NOT NULL auto_increment, 
    `biz_type`  char(10) NOT NULL default '',
    `update_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
    PRIMARY KEY (id),
) ;

当我们需要一个ID的时候，向表中插入一条记录返回主键ID，但这种方式有一个比较致命的缺点，访问量激增时MySQL本身就是系统的瓶颈，用它来实现分布式服务风险比较大，不推荐

基于数据库的号段

CREATE TABLE id_generator (
  `id` int(10) NOT NULL,
  `max_id` bigint(20) NOT NULL COMMENT '当前最大id',
  `step` int(20) NOT NULL COMMENT '号段的步长',
  `biz_type`    int(20) NOT NULL COMMENT '业务类型',
  `version` int(20) NOT NULL COMMENT '版本号',
  PRIMARY KEY (`id`)
)

max_id ：当前最大的可用id
step ：代表号段的长度
biz_type ：代表不同业务类型
version ：是一个乐观锁，每次都更新version，保证并发时数据的正确性

每次获取一个号段的ID，并放于内存中，等这批号段ID用完，再次向数据库申请新号段，对max_id字段做一次update操作，update max_id= max_id + step，update成功则说明新号段获取成功，新的号段范围是(max_id ,max_id +step]。
update id_generator set max_id = {max_id+step}, version = version + 1 where version = {version} and biz_type = XX
由于多业务端可能同时操作，所以采用版本号 version 乐观锁方式更新，这种分布式ID生成方式不强依赖于数据库，不会频繁的访问数据库，对数据库的压力小很多。但是如果遇到了双十一或者秒杀类似的活动还是会对数据库有比较高的访问。

redis 自增

Redis 是单线程的，因此我们可以利用redis的incr命令实现ID的原子性自增


127.0.0.1:6379> set seq_id 1     // 初始化自增ID为1
OK
127.0.0.1:6379> incr seq_id      // 增加1，并返回递增后的数值
(integer) 2

特殊编码（特殊字段+日期+自增数）

这个依旧使用到了redis的自增方式，同时添加特殊字符和日期

public class BusinessNoGenerator {

    private static final String REDIS_ROOT_PREFX = "YMT:CMYERP:BusinessNo:";

    public static String buildPurOrderNo() {
        return create(NumberType.PURORDERNO);
    }
    
    @Getter
    private enum NumberType {
        // 采购订单号
        PURORDERNO("CGDD", 5, "yyyyMMdd"),
        ;
        private String prefx;

        //流水号的长度,默认为5位
        private int lenth = 5;

        //日期格式
        private String dateformat;

        //流水号使用Redis自增长,Redis的Key
        private String redisKey;

        private NumberType(String prefx, int lenth) {
            this.prefx = prefx;
            this.lenth = lenth;
        }

        private NumberType(String prefx, int lenth, String dateformat) {
            this.prefx = prefx;
            this.lenth = lenth;
            this.dateformat = dateformat;
        }

    }

    /**
     *
     * 通用业务单号组成规则：
     * 前缀 + 创建日期  + 流水号
     */
    private static String create(NumberType number) {
        StringBuffer sb = new StringBuffer();
        sb.append(number.getPrefx());
        //创建日期
        String dateformat = null;
        if (number.getDateformat() != null) {
            dateformat = DateUtils.format(new Date(), number.getDateformat());
            sb.append(dateformat);
            //带日期流水号
            sb.append(padIndex(getDateIndex(number, dateformat), number.getLenth()));
        } else {
            //流水号
            sb.append(padIndex(getIndex(number, dateformat), number.getLenth()));
        }

        return sb.toString();
    }

    // 流水号补零
    private static String padIndex(long index, int length) {
        return String.format("%0" + length + "d", index);
    }

    // 获取带日期自增流水号
    private static long getDateIndex(NumberType number, String dateformat) {
        String rediskey = REDIS_ROOT_PREFX + number.getRedisKey();
        if (dateformat != null) {
            rediskey += dateformat;
        }
        //自增流水号过期设置
        // TODO (redis工具类)
        RedisHelper.redisTemplate.expire(rediskey, Duration.ofSeconds(60 * 60 * 24 * 2));

        return RedisHelper.incr(rediskey);
    }

    // 获取自增流水号
    private static long getIndex(NumberType number, String dateformat) {
        String rediskey = REDIS_ROOT_PREFX + number.getRedisKey();
        if (dateformat != null) {
            rediskey += dateformat;
        }

        return RedisHelper.incr(rediskey);
    }
}