本文目录
前言
如今，随着互联网业务发展的需要，很多传统的单体应用都转向分布式应用的方向演变，这也随之带来了一系列的技术挑战。例如，在分布式系统中，存在多个请求读写数据的情况，在插入数据时怎么给这些数据生成全局唯一ID呢？
全局唯一ID的要求
一般来说，分布式系统对全局唯一的ID设计有几个要求：
1、全局唯一性：不能出现重复的id号，基本要求。
2、信息安全：防止恶意用户通过规律获取id
3、数据递增：保证我下一个ID一定大于上一个ID。
生成ID的方法有很多，除了满足上面的要求之外，还需要根据不同的需求和场景来选择相应的策略，因为每种生成ID的策略都是有利弊的，下面为大家讲解几种常见的ID生成方法。
1、数据库自增长字段
这是最常见的生成ID方式，在建表是直接给ID设置自增长的属性即可，例如下面的sql语句：
CREATE TABLE `faiDomain` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`aid` int(11) NULL，
PRIMARY KEY (`id`)
）ENGINE=InnoDB AUTO_INCREMENT=2839 DEFAULT CHARSET=utf8;1.1、优点
①简单，直接，取决于数据库方面的性能。
②数字ID天然排序，对分页或者需要排序的结果很有帮助。
1.2、缺点
①不同的数据库语法和实现不同，数据库迁移时候需要额外处理。
②一般由sql语句在单表生成，不便于扩展。
③在单个数据库或读写分离的情况下，只有一个主库可以生成ID，有单点故障的风险。
④分库分表的时候会很麻烦，因为每条记录的ID很依赖表。
1.3、优化
针对主库单点来设计原则，如果有多个Master库，则每个Master库设置的起始数字不一样，增长的步长一样，可以是Master的个数。
比如：Master1 生成的是 1，4，7，10，Master2生成的是2,5,8,11 Master3生成的是 3,6,9,12。这样就可以有效生成集群中的唯一ID，也可以大大降低ID生成数据库操作的负载。
2、UUID
UUID也是比较常用的ID生成方式，有以下几部分组成：
（1）当前日期和时间，UUID的第一个部分与时间有关，如果你在生成一个UUID之后，过几秒又生成一个UUID，则第一个部分不同，其余相同。
（2）时钟序列。
（3）全局唯一的IEEE机器识别号，如果有网卡，从网卡MAC地址获得，没有网卡以其他方式获得。
2.1、优点
① 简单，代码简单，如Java中就有现成的工具类可以生成。示例代码如下：
String str = UUID.randomUUID().toString();② 生成的ID性能非常好，使用字符串存储，而且全球唯一，不会重复。
③ 因为生成的是字符串，不依赖数据库，所以迁移时候不影响。
2.2、缺点
① UUID存储的是64位的无排序字符串，无法保证趋势递增（要求3）
② 无序的字符，查询慢
③ 存储空间比较大，传输的数据量大
④ 不可读，都是字符串，你说呢？
3、用中间件Redis生成ID
当使用数据库来生成ID的性能达不到要求时，我们可以尝试引入中间件来生成ID，比如常见的mongodb、redis等，这里我们介绍一下redis生成ID的方案。
因为Redis是单线程的，所以可以用来生成全局唯一的ID，可以用redis的RedisAtomicLong生成自增的ID值 。示例代码如下：
@Autowired
private RedisTemplate<String,Serializable> mRedisTemp;
/**
* 获取自增长ID
* @param key
* @return
*/
public long generate(String key) {
RedisAtomicLong counter = new RedisAtomicLong(key,mRedisTemp.getConnectionFactory());
return counter.incrementAndGet();
}
/**
* 获取有过期时间的自增长ID
* @param key
* @param expireTime
* @return
*/
public long generate(String key,Date expireTime) {
RedisAtomicLong counter = new RedisAtomicLong(key, mRedisTemp.getConnectionFactory());
counter.expireAt(expireTime);
return counter.incrementAndGet();
}
/**
* 获取能按固定步长增长的有过期时间的ID
* @param key
* @param increment
* @return
*/
public long generate(String key,int increment,Date expireTime) {
RedisAtomicLong counter = new RedisAtomicLong(key, mRedisTemp.getConnectionFactory());
counter.expireAt(expireTime);
return counter.addAndGet(increment);
}代码中有设定过期时间和固定步长增长ID的方法，所以，用redis可以满足全局ID趋势增长的要求，如果有多台redis服务器，我们可以根据不同的增长数和初始值来设定，这样，即使是不同的服务器也不会有重复的ID。
而且，因为redis的key可以设定过期时间，所以，比较好的做法是将流水号的生成策略与日期和增长号绑定，例如订单号 = 日期 + 当日自增长号，key的过期时间可以设成一天的时间，这样就可以在redis中生成每天从0开始的id了。
3.1、优点
① 因为是用redis来生成id，不依赖数据库，而且性能优于数据库。
② ID天然排序，对分页或者需要排序的结果很方便。
3.2、缺点
① 需要引入redis中间件，增加系统复杂度。
② 需要编码和配置的工作量相对较大。
当然，我个人认为这两个所谓的缺点有点吹毛求疵了，毕竟如今的分布式中已经广泛应用了redis，不存在增加系统复杂度的问题，至于说编码和配置的工作量大，对开发人员来说无非是前期增加点工作量，后期就容易维护了，用多出的这一丁点工作量就能换取系统需求的实现以及后期维护的方便，我觉得是完全值得的。
4、Twitter的snowflake算法
snowflake是Twitter开源的分布式ID生成算法，结果是一个long型的ID。
4.1、结构
snowflake生成的Id由五部分组成，结构如下：
0 - 0000000000 0000000000 0000000000 0000000000 0 - 00000 - 00000 - 000000000000
第一位为未使用，接下来的41位为毫秒级时间(41位的长度可以使用69年)，然后是5位datacenterId和5位workerId(10位的长度最多支持部署1024个节点） ，最后12位是毫秒内的计数（12位的计数顺序号支持每个节点每毫秒产生4096个ID序号）
一共加起来刚好64位，为一个Long型。(转换成字符串后长度最多19)
snowflake生成的ID整体上按照时间自增排序，并且整个分布式系统内不会产生ID碰撞（由datacenter和workerId作区分），并且效率较高。经测试snowflake每秒能够产生26万个ID。
4.2、源码
snowflake的项目地址是 https://github.com/twitter/snowflake ，读者有兴趣可以自己下载查看。
下面是摘抄网上的大神们贴出的一段源码，每行代码都加了注释，非常用心。
/**
* Twitter_Snowflake<br>
* SnowFlake的结构如下(每部分用-分开):<br>
* 0 - 0000000000 0000000000 0000000000 0000000000 0 - 00000 - 00000 - 000000000000 <br>
* 1位标识，由于long基本类型在Java中是带符号的，最高位是符号位，正数是0，负数是1，所以id一般是正数，最高位是0<br>
* 41位时间截(毫秒级)，注意，41位时间截不是存储当前时间的时间截，而是存储时间截的差值（当前时间截 - 开始时间截)
* 得到的值），这里的的开始时间截，一般是我们的id生成器开始使用的时间，由我们程序来指定的（如下下面程序IdWorker类的startTime属性）。41位的时间截，可以使用69年，年T = (1L << 41) / (1000L * 60 * 60 * 24 * 365) = 69<br>
* 10位的数据机器位，可以部署在1024个节点，包括5位datacenterId和5位workerId<br>
* 12位序列，毫秒内的计数，12位的计数顺序号支持每个节点每毫秒(同一机器，同一时间截)产生4096个ID序号<br>
* 加起来刚好64位，为一个Long型。<br>
* SnowFlake的优点是，整体上按照时间自增排序，并且整个分布式系统内不会产生ID碰撞(由数据中心ID和机器ID作区分)，并且效率较高，经测试，SnowFlake每秒能够产生26万ID左右。
*/
public class SnowflakeIdWorker {
// ==============================Fields===========================================
/** 开始时间截 (2015-01-01) */
private final long twepoch = 1420041600000L;
/** 机器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;
//==============================Constructors=====================================
/**
* 构造函数
* @param workerId 工作ID (0~31)
* @param datacenterId 数据中心ID (0~31)
*/
public SnowflakeIdWorker(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;
}
// ==============================Methods==========================================
/**
* 获得下一个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();
}
//==============================Test=============================================
/** 测试 */
public static void main(String[] args) {
SnowflakeIdWorker idWorker = new SnowflakeIdWorker(0, 0);
for (int i = 0; i < 1000; i++) {
long id = idWorker.nextId();
System.out.println(Long.toBinaryString(id));
System.out.println(id);
}
}
}总结
以上就是比较常用的生成ID方法，值得说明的是，没有哪一种技术是十全十美的，每种技术策略都有它独特的应用场景，所以，在实际应用中，要根据业务的需要来选择相应的技术支持，只有适合的才是最好的。