如何自定义Mybatis-Plus分布式ID生成器(解决ID长度超过JavaScript整数安全范围问题)

缩短雪花算法后空间划分（可根据实际需求调整）：
1. 高位 32bit 作为秒级时间戳, 时间戳减去固定值(2024 年时间戳)
2. 5bit 作为机器标识, 最高可部署 32 台机器
3. 最后 16bit 作为自增序列, 单节点最高每秒 2^16 = 65536 个 id

import com.baomidou.mybatisplus.core.incrementer.identifiergenerator;
import lombok.extern.slf4j.slf4j;
import org.springframework.stereotype.component;
/**
 * 符合 javascript 整数安全范围的自定义id生成器
 *
 * @author panda
 */
@slf4j
@component
public class jssafeidgenerator implements identifiergenerator {
    /** 初始偏移时间戳 2024-01-01 */
    private static final long offset = 1704067200l;
    /** 机器id (0~15 保留 16~31作为备份机器) */
    private static final long worker_id;
    /** 机器id所占位数 (5bit, 支持最大机器数 2^5 = 32)*/
    private static final long worker_id_bits = 5l;
    /** 自增序列所占位数 (16bit, 支持最大每秒生成 2^16 = ‭65536‬) */
    private static final long sequence_id_bits = 16l;
    /** 机器id偏移位数 */
    private static final long worker_shift_bits = sequence_id_bits;
    /** 自增序列偏移位数 */
    private static final long offset_shift_bits = sequence_id_bits + worker_id_bits;
    /** 机器标识最大值 (2^5 / 2 - 1 = 15) */
    private static final long worker_id_max = ((1 << worker_id_bits) - 1) >> 1;
    /** 备份机器id开始位置 (2^5 / 2 = 16) */
    private static final long back_worker_id_begin = (1 << worker_id_bits) >> 1;
    /** 自增序列最大值 (2^16 - 1 = ‭65535) */
    private static final long sequence_max = (1 << sequence_id_bits) - 1;
    /** 发生时间回拨时容忍的最大回拨时间 (秒) */
    private static final long back_time_max = 1l;
    /** 上次生成id的时间戳 (秒) */
    private static long lasttimestamp = 0l;
    /** 当前秒内序列 (2^16)*/
    private static long sequence = 0l;
    /** 备份机器上次生成id的时间戳 (秒) */
    private static long lasttimestampbak = 0l;
    /** 备份机器当前秒内序列 (2^16)*/
    private static long sequencebak = 0l;
    static {
        // 初始化机器id 可配置文件获取
        long workerid = 1;
        if (workerid < 0 || workerid > worker_id_max) {
            throw new illegalargumentexception(string.format("worker-id [%d] 越界, 有效范围: 0 ~ %d ", workerid, worker_id_max));
        }
        worker_id = workerid;
    }
    @override
    public synchronized number nextid(object entity) {
        return nextid(systemclock.now() / 1000);
    }
    /**
     * 主机器自增序列
     * @param timestamp 当前unix时间戳
     * @return long
     */
    private static synchronized long nextid(long timestamp) {
        if (timestamp < lasttimestamp) {
            log.warn("时钟回拨, 启用备份机器id: now: [{}] last: [{}]", timestamp, lasttimestamp);
            return nextidbackup(timestamp);
        }
        if (timestamp != lasttimestamp) {
            lasttimestamp = timestamp;
            sequence = 0l;
        }
        if (0l == (++sequence & sequence_max)) {
            sequence--;
            return nextidbackup(math.max(timestamp, lasttimestampbak));
        }
        return ((timestamp - offset) << offset_shift_bits) | (worker_id << worker_shift_bits) | sequence;
    }
    /**
     * 备份机器自增序列
     * @param timestamp 当前unix时间戳
     * @return long
     */
    private static long nextidbackup(long timestamp) {
        if (timestamp < lasttimestampbak) {
            if (lasttimestampbak - (systemclock.now() / 1000) <= back_time_max) {
                timestamp = lasttimestampbak;
            } else {
                throw new runtimeexception(string.format("时钟回拨: now: [%d] last: [%d]", timestamp, lasttimestampbak));
            }
        }
        if (timestamp != lasttimestampbak) {
            lasttimestampbak = timestamp;
            sequencebak = 0l;
        }
        if (0l == (++sequencebak & sequence_max)) {
            return nextidbackup(timestamp + 1);
        }
        return ((timestamp - offset) << offset_shift_bits) | ((worker_id ^ back_worker_id_begin) << worker_shift_bits) | sequencebak;
    }
}

import java.util.concurrent.scheduledthreadpoolexecutor;
import java.util.concurrent.timeunit;
import java.util.concurrent.atomic.atomiclong;
/**
 * 缓存时间戳解决system.currenttimemillis()高并发下性能问题
 *
 * @author panda
 **/
public class systemclock {
    private final long period;
    private final atomiclong now;
    private systemclock(long period) {
        this.period = period;
        this.now = new atomiclong(system.currenttimemillis());
        scheduleclockupdating();
    }
    /**
     * 尝试下枚举单例法
     */
    private enum systemclockenum {
        system_clock;
        private systemclock systemclock;
        systemclockenum() {
            systemclock = new systemclock(1);
        }
        public systemclock getinstance() {
            return systemclock;
        }
    }
    /**
     * 获取单例对象
     * @return com.cmallshop.module.core.commons.util.sequence.systemclock
     */
    private static systemclock getinstance() {
        return systemclockenum.system_clock.getinstance();
    }
    /**
     * 获取当前毫秒时间戳
     * @return long
     */
    public static long now() {
        return getinstance().now.get();
    }
    /**
     * 起一个线程定时刷新时间戳
     */
    private void scheduleclockupdating() {
        scheduledthreadpoolexecutor scheduler = new scheduledthreadpoolexecutor(1, runnable -> {
            thread thread = new thread(runnable, "system clock");
            thread.setdaemon(true);
            return thread;
        });
        scheduler.scheduleatfixedrate(() -> now.set(system.currenttimemillis()), period, period, timeunit.milliseconds);
    }
}

import com.baomidou.mybatisplus.core.config.globalconfig;
import lombok.requiredargsconstructor;
import org.springframework.context.annotation.bean;
import org.springframework.context.annotation.configuration;
@configuration
@requiredargsconstructor
public class mybatisplusconfiguration {
    @bean
    public globalconfig globalconfig() {
        globalconfig globalconfig = new globalconfig();
        globalconfig.setidentifiergenerator(new jssafeidgenerator());
        return globalconfig;
    }
}

import com.baomidou.mybatisplus.annotation.idtype;
import com.baomidou.mybatisplus.annotation.tableid;
import lombok.allargsconstructor;
import lombok.data;
import lombok.noargsconstructor;
import java.io.serializable;
@data
@noargsconstructor
@allargsconstructor
public class base implements serializable {
    @tableid(type = idtype.assign_id)
    private long id;
}