常见分布式id生成方案_分布式id生成方案

public static void main(String[] args) { 

//获取一个版本4根据随机字节数组的UUID。
UUID uuid = UUID.randomUUID();
System.out.println(uuid.toString().replaceAll("-", ""));
//获取一个版本3(基于名称)根据指定的字节数组的UUID。
byte[] nbyte = { 
10, 20, 30};
UUID uuidFromBytes = UUID.nameUUIDFromBytes(nbyte);
System.out.println(uuidFromBytes.toString().replaceAll("-", ""));
}

CREATE DATABASE `SEQ_ID`;
CREATE TABLE SEQID.SEQUENCE_ID (
id bigint(20) unsigned NOT NULL auto_increment, 
value char(10) NOT NULL default '',
PRIMARY KEY (id),
);
insert into SEQUENCE_ID(value)  VALUES ('values');

set @@auto_increment_offset = 1;     -- 起始值
set @@auto_increment_increment = 2;  -- 步长

set @@auto_increment_offset = 2;     -- 起始值
set @@auto_increment_increment = 2;  -- 步长

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`)
);

update id_generator set max_id = #{max_id+step}, version = version + 1 where version = # {version} and biz_type = XXX

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

public class SnowflakeIdWorker { 

/** * 起始的时间戳,2020-01-01 00:00:00 */
private final static long START_TIMESTAMP = 1577808000000L;
/** * 数据中心占用的位数 */
private final static long DATACENTER_ID_BIT = 5;
/** * 工作机器标识占用的位数 */
private final static long WORKER_ID_BIT = 5;
/** * 序列号占用的位数 */
private final static long SEQUENCE_BIT = 12;
/** * 支持的数据中心最大值 */
private final static long MAX_DATACENTER_ID = ~(-1L << DATACENTER_ID_BIT);
/** * 支持的工作机器标识最大值 */
private final static long MAX_WORKER_ID = ~(-1L << WORKER_ID_BIT);
/** * 支持的序列号最大值 */
private final static long MAX_SEQUENCE = ~(-1L << SEQUENCE_BIT);
/** * 工作机器标识向左移12位 */
private final static long WORKER_ID_LEFT = SEQUENCE_BIT;
/** * 数据中心向左移(12+5)位 */
private final static long DATACENTER_ID_LEFT = SEQUENCE_BIT + WORKER_ID_BIT;
/** * 时间戳向左移(12+5+5)位 */
private final static long TIMESTAMP_LEFT = DATACENTER_ID_LEFT + DATACENTER_ID_BIT;
/** * 数据中心 */
private final long datacenterId;
/** * 工作机器标识 */
private final long workerId;
/** * 序列号 */
private long sequence = 0L;
/** * 上一次时间戳 */
private long lastTimestamp = -1L;
/** * 构造函数 * * @param datacenterId 数据中心 (0~31) * @param workerId 工作机器标识 (0~31) */
public SnowflakeIdWorker(long datacenterId, long workerId) { 

if (datacenterId > MAX_DATACENTER_ID || datacenterId < 0) { 

throw new IllegalArgumentException("datacenterId can't be greater than MAX_DATACENTER_ID or less than 0");
}
if (workerId > MAX_WORKER_ID || workerId < 0) { 

throw new IllegalArgumentException("workerId can't be greater than MAX_WORKER_ID or less than 0");
}
this.datacenterId = datacenterId;
this.workerId = workerId;
}
/** * 获取下一个ID (该方法是线程安全的) * * @return long SnowflakeId */
public synchronized long nextId() { 

long currentTimestamp = currentTimeMillis();
//如果当前时间小于上一次ID生成的时间戳，说明系统时钟回退过这个时候应当抛出异常
if (currentTimestamp < lastTimestamp) { 

throw new RuntimeException("Clock moved backwards. Refusing to generate id");
}
//如果是同一时间生成的，则进行毫秒内序列
if (currentTimestamp == lastTimestamp) { 

//相同毫秒内，序列号自增
sequence = (sequence + 1) & MAX_SEQUENCE;
//同一毫秒的序列数已经达到最大
if (sequence == 0L) { 

currentTimestamp = nextTimeMillis();
}
} else { 

//不同毫秒内，序列号置为0
sequence = 0L;
}
//上次生成ID的时间戳
lastTimestamp = currentTimestamp;
//移位并通过或运算拼到一起组成64位的ID
//时间戳部分
return (currentTimestamp - START_TIMESTAMP) << TIMESTAMP_LEFT
//数据中心部分
| datacenterId << DATACENTER_ID_LEFT
//工作机器标识部分
| workerId << WORKER_ID_LEFT
//序列号部分
| sequence;
}
/** * 阻塞到下一个毫秒，直到获得新的时间戳 * * @return 当前时间戳 */
private long nextTimeMillis() { 

long mill = currentTimeMillis();
while (mill <= lastTimestamp) { 

mill = currentTimeMillis();
}
return mill;
}
/** * 返回以毫秒为单位的当前时间 * * @return 当前时间(毫秒) */
private long currentTimeMillis() { 

return System.currentTimeMillis();
}
public static void main(String[] args) { 

SnowflakeIdWorker snowflake = new SnowflakeIdWorker(2, 3);
for (int i = 0; i < (1 << 10); i++) { 

System.out.println(snowflake.nextId());
}
}
}

DROP TABLE IF EXISTS `leaf_alloc`;
CREATE TABLE `leaf_alloc` (
`biz_tag` varchar(128)  NOT NULL DEFAULT '' COMMENT '业务key',
`max_id` bigint(20) NOT NULL DEFAULT '1' COMMENT '当前已经分配了的最大id',
`step` int(11) NOT NULL COMMENT '初始步长，也是动态调整的最小步长',
`description` varchar(256)  DEFAULT NULL COMMENT '业务key的描述',
`update_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '数据库维护的更新时间',
PRIMARY KEY (`biz_tag`)
) ENGINE=InnoDB;

leaf.name=com.sankuai.leaf.opensource.test
leaf.segment.enable=true
leaf.jdbc.url=jdbc:mysql://localhost:3306/leaf_test?useUnicode=true&characterEncoding=utf8&characterSetResults=utf8
leaf.jdbc.username=root
leaf.jdbc.password=root
leaf.snowflake.enable=false
#leaf.snowflake.zk.address=
#leaf.snowflake.port=

leaf.snowflake.enable=true
leaf.snowflake.zk.address=127.0.0.1
leaf.snowflake.port=2181

CREATE TABLE `tiny_id_info` (
`id` bigint(20) unsigned NOT NULL AUTO_INCREMENT COMMENT '自增主键',
`biz_type` varchar(63) NOT NULL DEFAULT '' COMMENT '业务类型，唯一',
`begin_id` bigint(20) NOT NULL DEFAULT '0' COMMENT '开始id，仅记录初始值，无其他含义。初始化时begin_id和max_id应相同',
`max_id` bigint(20) NOT NULL DEFAULT '0' COMMENT '当前最大id',
`step` int(11) DEFAULT '0' COMMENT '步长',
`delta` int(11) NOT NULL DEFAULT '1' COMMENT '每次id增量',
`remainder` int(11) NOT NULL DEFAULT '0' COMMENT '余数',
`create_time` timestamp NOT NULL DEFAULT '2010-01-01 00:00:00' COMMENT '创建时间',
`update_time` timestamp NOT NULL DEFAULT '2010-01-01 00:00:00' COMMENT '更新时间',
`version` bigint(20) NOT NULL DEFAULT '0' COMMENT '版本号',
PRIMARY KEY (`id`),
UNIQUE KEY `uniq_biz_type` (`biz_type`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8 COMMENT 'id信息表';
CREATE TABLE `tiny_id_token` (
`id` int(11) unsigned NOT NULL AUTO_INCREMENT COMMENT '自增id',
`token` varchar(255) NOT NULL DEFAULT '' COMMENT 'token',
`biz_type` varchar(63) NOT NULL DEFAULT '' COMMENT '此token可访问的业务类型标识',
`remark` varchar(255) NOT NULL DEFAULT '' COMMENT '备注',
`create_time` timestamp NOT NULL DEFAULT '2010-01-01 00:00:00' COMMENT '创建时间',
`update_time` timestamp NOT NULL DEFAULT '2010-01-01 00:00:00' COMMENT '更新时间',
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8 COMMENT 'token信息表';
INSERT INTO `tiny_id_info` (`id`, `biz_type`, `begin_id`, `max_id`, `step`, `delta`, `remainder`, `create_time`, `update_time`, `version`)
VALUES
(1, 'test', 1, 1, 100000, 1, 0, '2018-07-21 23:52:58', '2018-07-22 23:19:27', 1);
INSERT INTO `tiny_id_info` (`id`, `biz_type`, `begin_id`, `max_id`, `step`, `delta`, `remainder`, `create_time`, `update_time`, `version`)
VALUES
(2, 'test_odd', 1, 1, 100000, 2, 1, '2018-07-21 23:52:58', '2018-07-23 00:39:24', 3);
INSERT INTO `tiny_id_token` (`id`, `token`, `biz_type`, `remark`, `create_time`, `update_time`)
VALUES
(1, '0f673adf80504e2eaa552f5d791b644c', 'test', '1', '2017-12-14 16:36:46', '2017-12-14 16:36:48');
INSERT INTO `tiny_id_token` (`id`, `token`, `biz_type`, `remark`, `create_time`, `update_time`)
VALUES
(2, '0f673adf80504e2eaa552f5d791b644c', 'test_odd', '1', '2017-12-14 16:36:46', '2017-12-14 16:36:48');

datasource.tinyid.names=primary
datasource.tinyid.primary.driver-class-name=com.mysql.jdbc.Driver
datasource.tinyid.primary.url=jdbc:mysql://ip:port/databaseName?autoReconnect=true&useUnicode=true&characterEncoding=UTF-8
datasource.tinyid.primary.username=root
datasource.tinyid.primary.password=123456

获取分布式自增ID: http://localhost:9999/tinyid/id/nextIdSimple?bizType=test&token=0f673adf80504e2eaa552f5d791b644c'
返回结果: 3
批量获取分布式自增ID: http://localhost:9999/tinyid/id/nextIdSimple?bizType=test&token=0f673adf80504e2eaa552f5d791b644c&batchSize=10'
返回结果:  4,5,6,7,8,9,10,11,12,13

<dependency>
<groupId>com.xiaoju.uemc.tinyid</groupId>
<artifactId>tinyid-client</artifactId>
<version>${tinyid.version}</version>
</dependency>

tinyid.server =localhost:9999
tinyid.token =0f673adf80504e2eaa552f5d791b644c

// 获取单个分布式自增ID
Long id =  TinyId.nextId("test");
// 按需批量分布式自增ID
List< Long > ids =  TinyId.nextId("test" , 10);