文章目录
前言
数据库主键的设计是数据库架构中的一个重要环节，不同的主键生成策略适用于不同的场景和需求
以下是几种常见的主键设计方法及其优缺点比较：
1. 自增ID（Auto-Increment）
优点:
- 实现简单，数据库自动管理，无需开发者介入。
- 递增的特性使得数据插入速度快，因为插入总是发生在索引的末尾。
- 易于理解和使用，便于查询和排序。
缺点:
- 分布式系统中难以保证全局唯一，因为每个节点的计数器独立增长。
- 数据泄露风险，自增ID容易暴露数据库的规模和增长速度。
- 如果发生大量删除操作，可能导致主键ID不连续，影响美观但不影响功能。
2. GUID (Globally Unique Identifier)
优点:
- 全球唯一，无论在任何系统、任何地点生成，都能保证唯一性。
- 无需依赖数据库，可以在客户端生成，适合分布式系统。
- 支持提前生成ID，有利于并行处理和离线操作。
缺点:
- 长度较大（通常为32字符），占用更多的存储空间和索引空间。
- 无序的特性可能导致索引碎片，降低插入性能。
- 不易读，不便于人工识别和调试。
3. 雪花算法（Snowflake）
雪花算法（Snowflake Algorithm）是一种用于生成唯一ID的算法，最初由Twitter公司开发。它是为了解决分布式系统中生成全局唯一ID的需求而设计的。在分布式系统中，如果不同节点生成的ID可能会发生冲突，这就需要一种机制来保证生成的ID在整个系统中唯一。
雪花算法的设计考虑了以下几个因素：
- 时间戳（Timestamp）：使用当前时间来确保生成的ID是递增的，这样可以保证生成的ID是有序的。
- 机器ID（Machine ID）：将机器的唯一标识（比如机器的MAC地址）作为一部分ID，确保不同机器生成的ID不会冲突。
- 序列号（Sequence Number）：用来解决同一毫秒内生成多个ID时的冲突问题。
Java中如何使用雪花算法来设计数据库主键呢？下面是一个简单的示例：
public class SnowflakeIdGenerator {
// 定义机器ID，可以通过配置文件或其他方式设置
private long machineId;
// 定义序列号
private long sequence = 0L;
// 定义初始时间戳
private long twepoch = 1622874000000L; // 2021-06-05 00:00:00
// 定义各部分占位数
private long machineIdBits = 5L;
private long maxMachineId = -1L ^ (-1L << machineIdBits);
private long sequenceBits = 12L;
private long sequenceMask = -1L ^ (-1L << sequenceBits);
// 定义机器ID左移位数
private long machineIdShift = sequenceBits;
// 定义时间戳左移位数
private long timestampLeftShift = sequenceBits + machineIdBits;
// 上次生成ID的时间戳
private long lastTimestamp = -1L;
public SnowflakeIdGenerator(long machineId) {
if (machineId > maxMachineId || machineId < 0) {
throw new IllegalArgumentException("Machine ID can't be greater than " + maxMachineId + " or less than 0");
}
this.machineId = machineId;
}
public synchronized long nextId() {
long timestamp = timeGen();
if (timestamp < lastTimestamp) {
throw new RuntimeException("Clock moved backwards. Refusing to generate id for " + (lastTimestamp - timestamp) + " milliseconds");
}
if (lastTimestamp == timestamp) {
sequence = (sequence + 1) & sequenceMask;
if (sequence == 0) {
// 当同一毫秒内的序列号超过上限时，等待下一毫秒
timestamp = tilNextMillis(lastTimestamp);
}
} else {
sequence = 0L;
}
lastTimestamp = timestamp;
return ((timestamp - twepoch) << timestampLeftShift) | (machineId << machineIdShift) | sequence;
}
private long tilNextMillis(long lastTimestamp) {
long timestamp = timeGen();
while (timestamp <= lastTimestamp) {
timestamp = timeGen();
}
return timestamp;
}
private long timeGen() {
return System.currentTimeMillis();
}
public static void main(String[] args) {
SnowflakeIdGenerator idGenerator = new SnowflakeIdGenerator(1); // 传入机器ID
for (int i = 0; i < 10; i++) {
System.out.println(idGenerator.nextId());
}
}
}
在这个示例中，我们通过nextId()方法来生成雪花算法生成的唯一ID。首先，我们需要设置一个机器ID，确保不同的机器有不同的ID。然后，调用nextId()方法即可生成一个唯一的ID，这个ID包含了时间戳、机器ID和序列号三部分。最后，我们可以将生成的ID作为数据库表的主键。
值得注意的是，雪花算法生成的ID是趋势递增的，因此在数据库中使用时可能会带来一定的优势，比如辅助索引的性能优化。但也要注意在高并发情况下可能出现的一些问题，比如时钟回拨等。
优点:
- 结合了自增ID和GUID的优点，生成的ID是趋势递增的，且全局唯一。
- 高性能，适用于分布式环境，能够按需分配workerId和数据中心id，保证唯一性。
- ID较短（一般为64位），相比GUID节省存储空间。
- 有序性有助于索引优化。
缺点:
- 需要一个中心节点（或者多个，但需要协调）来生成ID，有一定的运维成本。
- 时钟回拨问题可能会影响ID的生成，需要特殊处理。
然而，雪花算法依赖于时间戳，因此时钟回拨（clock rollback）会对其造成问题。
处理时钟回拨的方法
1. 简单等待
当检测到时钟回拨时，直接等待直到时间回到正确的时间。这是最简单的处理方式，但会导致 ID 生成暂停一段时间。
public class SnowflakeIdGenerator {
private long lastTimestamp = -1L;
public synchronized long nextId() {
long timestamp = timeGen();
// 如果当前时间小于上一次生成ID的时间戳，说明系统时钟回拨
if (timestamp < lastTimestamp) {
// 等待直到时钟追上
while (timestamp < lastTimestamp) {
timestamp = timeGen();
}
}
lastTimestamp = timestamp;
return generateId(timestamp);
}
private long timeGen() {
return System.currentTimeMillis();
}
private long generateId(long timestamp) {
// 生成ID的逻辑
return timestamp;
}
}
2. 配置时钟回拨安全窗口
允许一定范围内的时钟回拨，在这个范围内继续生成 ID，但如果超出这个范围则抛出异常或采取其他措施。
public class SnowflakeIdGenerator {
private long lastTimestamp = -1L;
private static final long MAX_BACKWARD_MS = 5L; // 允许的最大时钟回拨时间
public synchronized long nextId() {
long timestamp = timeGen();
if (timestamp < lastTimestamp) {
long offset = lastTimestamp - timestamp;
if (offset <= MAX_BACKWARD_MS) {
// 等待，直到时钟追上
try {
Thread.sleep(offset + 1);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
timestamp = timeGen();
if (timestamp < lastTimestamp) {
throw new RuntimeException("Clock moved backwards. Refusing to generate id");
}
} else {
throw new RuntimeException("Clock moved backwards. Refusing to generate id");
}
}
lastTimestamp = timestamp;
return generateId(timestamp);
}
private long timeGen() {
return System.currentTimeMillis();
}
private long generateId(long timestamp) {
// 生成ID的逻辑
return timestamp;
}
}
3. 使用不同的机器 ID
在分布式系统中，每台机器有唯一的机器 ID。当检测到时钟回拨时，改变机器 ID 来避免冲突。这种方法需要协调机器 ID 的分配。
public class SnowflakeIdGenerator {
private long lastTimestamp = -1L;
private long machineId;
private static final long MAX_MACHINE_ID = 1023L;
public SnowflakeIdGenerator(long machineId) {
if (machineId < 0 || machineId > MAX_MACHINE_ID) {
throw new IllegalArgumentException("Machine ID out of range");
}
this.machineId = machineId;
}
public synchronized long nextId() {
long timestamp = timeGen();
if (timestamp < lastTimestamp) {
machineId = (machineId + 1) & MAX_MACHINE_ID;
if (machineId == 0) {
// 如果机器ID回到0，说明时钟回拨过大，拒绝生成ID
throw new RuntimeException("Clock moved backwards. Refusing to generate id");
}
timestamp = timeGen();
}
lastTimestamp = timestamp;
return generateId(timestamp, machineId);
}
private long timeGen() {
return System.currentTimeMillis();
}
private long generateId(long timestamp, long machineId) {
// 生成ID的逻辑，包含时间戳和机器ID
return (timestamp << 22) | (machineId << 12);
}
}
小结
- 简单等待：当检测到时钟回拨时，等待直到时钟恢复到正确时间。这种方法简单但会导致 ID 生成暂停。
- 时钟回拨安全窗口：允许一定范围内的时钟回拨，如果超出这个范围则抛出异常或采取其他措施。
- 不同的机器 ID：当检测到时钟回拨时，改变机器 ID 来避免冲突。这种方法需要协调机器 ID 的分配。
稳定的雪花算法实现方案
以下是一个经过优化的方案，涵盖时钟回拨问题、分布式系统中的唯一性问题和高可用性问题
- 机器 ID 和数据中心 ID：通过配置不同的机器 ID 和数据中心 ID 来确保分布式系统中的唯一性。
- 时钟回拨处理：使用递增序列和缓存的时间戳来处理时钟回拨问题。
- 高可用性：结合 Redis 或数据库来生成分布式唯一 ID。
示例实现
1. 定义雪花算法类
public class SnowflakeIdGenerator {
private static final long EPOCH = 1609459200000L; // 自定义纪元时间（2021-01-01）
private static final long DATA_CENTER_ID_BITS = 5L;
private static final long MACHINE_ID_BITS = 5L;
private static final long SEQUENCE_BITS = 12L;
private static final long MAX_DATA_CENTER_ID = ~(-1L << DATA_CENTER_ID_BITS);
private static final long MAX_MACHINE_ID = ~(-1L << MACHINE_ID_BITS);
private static final long MAX_SEQUENCE = ~(-1L << SEQUENCE_BITS);
private static final long MACHINE_ID_SHIFT = SEQUENCE_BITS;
private static final long DATA_CENTER_ID_SHIFT = SEQUENCE_BITS + MACHINE_ID_BITS;
private static final long TIMESTAMP_SHIFT = SEQUENCE_BITS + MACHINE_ID_BITS + DATA_CENTER_ID_BITS;
private final long dataCenterId;
private final long machineId;
private long sequence = 0L;
private long lastTimestamp = -1L;
public SnowflakeIdGenerator(long dataCenterId, long machineId) {
if (dataCenterId > MAX_DATA_CENTER_ID || dataCenterId < 0) {
throw new IllegalArgumentException(String.format("DataCenter ID can't be greater than %d or less than 0", MAX_DATA_CENTER_ID));
}
if (machineId > MAX_MACHINE_ID || machineId < 0) {
throw new IllegalArgumentException(String.format("Machine ID can't be greater than %d or less than 0", MAX_MACHINE_ID));
}
this.dataCenterId = dataCenterId;
this.machineId = machineId;
}
public synchronized long nextId() {
long timestamp = timeGen();
if (timestamp < lastTimestamp) {
throw new RuntimeException("Clock moved backwards. Refusing to generate id for " + (lastTimestamp - timestamp) + " milliseconds");
}
if (timestamp == lastTimestamp) {
sequence = (sequence + 1) & MAX_SEQUENCE;
if (sequence == 0) {
timestamp = tilNextMillis(lastTimestamp);
}
} else {
sequence = 0L;
}
lastTimestamp = timestamp;
return ((timestamp - EPOCH) << TIMESTAMP_SHIFT)
| (dataCenterId << DATA_CENTER_ID_SHIFT)
| (machineId << MACHINE_ID_SHIFT)
| sequence;
}
private long tilNextMillis(long lastTimestamp) {
long timestamp = timeGen();
while (timestamp <= lastTimestamp) {
timestamp = timeGen();
}
return timestamp;
}
private long timeGen() {
return System.currentTimeMillis();
}
}
2. 使用 Redis 或数据库实现分布式唯一 ID
为了进一步提高高可用性和唯一性，可以结合 Redis 或数据库实现分布式唯一 ID 生成。这里是一个使用 Redis 的示例：
import redis.clients.jedis.Jedis;
public class DistributedIdGenerator {
private final SnowflakeIdGenerator snowflakeIdGenerator;
private final Jedis jedis;
public DistributedIdGenerator(long dataCenterId, long machineId, String redisHost, int redisPort) {
this.snowflakeIdGenerator = new SnowflakeIdGenerator(dataCenterId, machineId);
this.jedis = new Jedis(redisHost, redisPort);
}
public long nextId() {
long id = snowflakeIdGenerator.nextId();
String key = "snowflake:" + id;
while (jedis.exists(key)) {
id = snowflakeIdGenerator.nextId();
key = "snowflake:" + id;
}
jedis.setex(key, 3600, "1"); // 设置过期时间，避免长期存储
return id;
}
}
解释
-
基本雪花算法：
EPOCH：自定义的纪元时间。DATA_CENTER_ID_BITS、MACHINE_ID_BITS和SEQUENCE_BITS：数据中心 ID、机器 ID 和序列号的位数。nextId方法：生成唯一 ID，并处理时钟回拨问题。
-
分布式唯一 ID：
- 使用 Redis 确保 ID 唯一性：在生成 ID 后，将其存储在 Redis 中，检查是否重复。
jedis.setex(key, 3600, "1")：使用带过期时间的键来避免长期存储。
-
时钟回拨处理：
- 当检测到时钟回拨时，抛出异常或等待时间前进。
- 使用
tilNextMillis方法等待直到时间前进。
小结
这种方案结合了雪花算法的高性能和 Redis 的分布式存储能力，解决了时钟回拨问题，并确保在分布式环境下生成唯一 ID。通过这些措施，可以实现一个稳定、高效的分布式唯一 ID 生成系统。
其他方法
- 复合主键：结合多个字段作为主键，适用于表中没有自然唯一标识符的场景。但增加了查询和维护的复杂性。
- 业务相关ID：如订单号，易于理解且与业务紧密相关，但可能需要额外的逻辑来保证唯一性，且扩展性较差。
总结
选择哪种主键生成策略取决于具体的应用场景：
- 对于单体应用或简单的分布式系统，自增ID可能是最简单高效的选择。
- 在分布式系统中，尤其是跨多个数据中心时，雪花算法因其高性能和全局唯一性成为优选。
- 当全局唯一性是首要考虑因素，且对存储空间不太敏感时，GUID是合适的选择。
- 具体场景下，也可以根据业务需求考虑复合主键或业务相关ID的方案。
扫一扫
976
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
