MyBatis使用雪花ID的实现

MyBatis使用雪花ID的实现

目录一、实现MyBatis ID构建接口二、雪花ID生成工具类

一、实现MyBatis ID构建接口

@Slf4j

@Component

public class CustomIdGenerator implements IdentifierGenerator {

@Override

public Long nextId(Object entity) {

//生成ID

long id = SnowFlakeUtils.nextId();

log.info("生成ID: " + id);

return id;

}

}

二、雪花ID生成工具类

@Slf4j

public class SnowFlakeUtils {

/** 初始偏移时间戳 */

private static final long OFFSET = 1546300800L;

/** 机器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;

/** 自增序ELAqezWG列最大值 (2^16 - 1 = 65535) */

private static final long SEQUENCE_MAX = (1 << SEQUENCE_ID_BITS) - 1;

/** 发生时间回拨时容忍的最大回拨时间 (秒) */

private static final long BACK_TIME_MAX = 1000L;

/** 上次生成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 = getWorkId();

if (workerId < 0 || workerId > WORKER_ID_MAX) {

throw new IllegalArgumentException(String.format("cmallshop.workerId范围: 0 ~ %d 目前: %d", WORKER_ID_MAX, workerId));

}

WORKER_ID = workerId;

}

private static Long getWorkId(){

try {

String hostAddress = Inet4Address.getLocalHost().getHostAddress();

int[] ints = StringUtils.toCodePoints(hostAddress);

int sums = 0;

for(int b : ints){

sums += b;

}

return (long)(sums % WORKER_ID_MAX);

} catch (UnknownHostException e) {

// 如果获取失败，则使用随机数备用

return RandomUtils.nextLong(0,WORKER_ID_MAX-1);

}

}

/** 私有构造函数禁止外部访问 */

private SnowFlakeUtils() {}

/**

* 获取自增序列

* @return long

*/

public static long nextId() {

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)) {

// 秒内序列用尽

// log.warn("秒内[{}]序列用尽, 启用备份机器ID序列", timestamp);

sequence--;

return nextIdBackup(timestamp);

}

return ((timestamp - OFFSET) << OFFSET_SHIFT_BITS) | (WORKER_ID << WORKER_SHIFT_BITS) | sequence;

}

/**

* 备份机器自增序列

* @param timestamp 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)) {

// 秒内序列用尽

// logger.warn("秒内[{}]序列用尽, 备份机器ID借取下一秒序列", timestamp);

return nextIdBackup(timestamp + 1);

}

return ((timestamp - OFFSET) << OFFSET_SHIFT_BITS) | ((WORKER_ID ^ BACK_WORKER_ID_BEGIN) << WORKER_SHIFT_BITS) | sequenceBak;

}

/**

* 并发数

*/

private static final int THREAD_NUM = 30000;

private static volatile CountDownLatch countDownLatch = new CountDownLatch(THREAD_NUM);

public static void main(String[] args) {

ConcurrentHashMap map = new ConcurrentHashMap<>(THREAD_NUM);

List list = Collections.synchronizedList(new LinkedList<>());

for (int i = 0; i < THREAD_NUM; i++) {

Thread thread = new Thread(() -> {

// 所有的线程在这里等待

try {

countDownLatch.await();

Long id = SnowFlakeUtils.nextId();

list.add(id);

map.put(id,1L);

} catch (InterruptedException e) {

e.printStackTrace();

}

});

thread.start();

// 启动后，倒计时计数器减一，代表有一个线程准备就绪了

countDownLatch.countDown();

}

try{

Thread.sleep(50000);

}catch (Exception e){

e.printStackTrace();

}

System.out.println("listSize:"+list.size());

System.out.println("mapSize:"+map.size());

System.out.println(map.size() == THREAD_NUM);

}

}

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。