CREATE TABLE t_user (
    id BIGINT PRIMARY KEY AUTO_INCREMENT,
    username VARCHAR(50) NOT NULL
);

-- 查看当前自增值
SHOW TABLE STATUS LIKE 't_user';

-- 手动设置起始值
ALTER TABLE t_user AUTO_INCREMENT = 10000;

-- 方式一：SERIAL 语法糖（自动创建序列 + 设置默认值）
CREATE TABLE t_user (
    id BIGSERIAL PRIMARY KEY,
    username VARCHAR(50) NOT NULL
);
-- 等价于：
-- CREATE SEQUENCE t_user_id_seq;
-- id BIGINT PRIMARY KEY DEFAULT nextval('t_user_id_seq');

-- 方式二：手动创建序列（更灵活）
CREATE SEQUENCE t_user_seq START WITH 10000 INCREMENT BY 1;

CREATE TABLE t_user (
    id BIGINT PRIMARY KEY DEFAULT nextval('t_user_seq'),
    username VARCHAR(50) NOT NULL
);

-- 批量分配：预取一批 ID
SELECT nextval('t_user_seq') FROM generate_series(1, 100);

-- 推荐写法（取代 SERIAL）
CREATE TABLE t_user (
    id BIGINT GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
    username VARCHAR(50) NOT NULL
);

-- 优势：防止手动插入覆盖序列值
-- GENERATED ALWAYS：禁止手动插入
-- GENERATED BY DEFAULT：允许手动插入时覆盖

-- 创建序列
CREATE SEQUENCE t_user_seq
    START WITH 1
    INCREMENT BY 1
    CACHE 500          -- 预缓存500个值，减少递归调用
    NOORDER            -- 不保证顺序（RAC 环境下提升性能）
    NOCYCLE;

-- 使用序列
INSERT INTO t_user (id, username) VALUES (t_user_seq.NEXTVAL, '张三');

-- 获取当前会话最后一次 NEXTVAL 的值
SELECT t_user_seq.CURRVAL FROM dual;

// Java 原生 UUID（版本4，随机）
UUID uuid = UUID.randomUUID();        // 36字符：550e8400-e29b-41d4-a716-446655440000
String id = uuid.toString().replace("-", "");  // 32字符：550e8400e29b41d4a716446655440000

// MySQL 内置 UUID
SELECT UUID();  -- 550e8400-e29b-41d4-a716-446655440000

-- MySQL 8.0+：有序 UUID（替换时间戳字节顺序）
SELECT UUID_TO_BIN(UUID(), TRUE);  -- 16字节二进制，有序

UUID v7 结构（128位）：
| 48位毫秒时间戳 | 4位版本(0111) | 12位随机 | 2位变体 | 62位随机 |

-- PostgreSQL 17+ 原生支持
SELECT gen_random_uuid();  -- UUID v4
-- UUID v7 需扩展或自定义函数

-- MySQL 8.0 中生成有序 UUID
SELECT UUID_TO_BIN(UUID(), TRUE) AS ordered_uuid;

问题链：
UUID 无序 → 每次插入落到 B+ 树随机位置
  → 频繁页分裂（Page Split）
    → 大量随机 I/O
      → 写入性能严重下降

此外：
UUID 36字符 → 二级索引叶子节点存储主键值
  → 索引膨胀（36字节 vs BIGINT 8字节）
    → 内存利用率低，磁盘占用大

Snowflake ID 结构（64位 = 8字节 = Java long）：

 0 | 00000000 00000000 00000000 00000000 00000000 0 | 00000 00000 | 000000000000
 │  │                   41位时间戳                   │  10位机器ID  │   12位序列号  │
符号位                                                │(5位数据中心+5位机器)│

- 每毫秒可生成 4096 个 ID（单节点）
- 可用 69 年（从纪元开始计算）
- 支持 1024 个节点（32 个数据中心 × 32 台机器）

public class SnowflakeIdGenerator {
    private final long epoch = 1609459200000L; // 2021-01-01 起始纪元
    private final long workerIdBits = 5L;
    private final long datacenterIdBits = 5L;
    private final long sequenceBits = 12L;

    private final long maxWorkerId = ~(-1L << workerIdBits);        // 31
    private final long maxDatacenterId = ~(-1L << datacenterIdBits); // 31
    private final long sequenceMask = ~(-1L << sequenceBits);        // 4095

    private final long workerIdShift = sequenceBits;                           // 12
    private final long datacenterIdShift = sequenceBits + workerIdBits;         // 17
    private final long timestampShift = sequenceBits + workerIdBits
                                        + datacenterIdBits;                    // 22

    private final long workerId;
    private final long datacenterId;
    private long sequence = 0L;
    private long lastTimestamp = -1L;

    public SnowflakeIdGenerator(long workerId, long datacenterId) {
        if (workerId > maxWorkerId || workerId < 0) {
            throw new IllegalArgumentException("worker Id error");
        }
        if (datacenterId > maxDatacenterId || datacenterId < 0) {
            throw new IllegalArgumentException("datacenter Id error");
        }
        this.workerId = workerId;
        this.datacenterId = datacenterId;
    }

    public synchronized long nextId() {
        long timestamp = System.currentTimeMillis();

        // 时钟回拨检测
        if (timestamp < lastTimestamp) {
            throw new RuntimeException("Clock moved backwards");
        }

        // 同一毫秒内，序列号自增
        if (lastTimestamp == timestamp) {
            sequence = (sequence + 1) & sequenceMask;
            if (sequence == 0) {
                timestamp = tilNextMillis(lastTimestamp);
            }
        } else {
            sequence = 0L;
        }

        lastTimestamp = timestamp;

        return ((timestamp - epoch) << timestampShift)
                | (datacenterId << datacenterIdShift)
                | (workerId << workerIdShift)
                | sequence;
    }

    private long tilNextMillis(long lastTimestamp) {
        long timestamp = System.currentTimeMillis();
        while (timestamp <= lastTimestamp) {
            timestamp = System.currentTimeMillis();
        }
        return timestamp;
    }
}

号段模式工作流：

  应用启动
    ↓
  从数据库获取号段 [1, 1000]（step=1000）
    ↓
  内存中分配：1, 2, 3, ..., 999
    ↓
  消耗到 10% 时，异步预加载下一段 [1001, 2000]
    ↓
  当前号段用完 → 无缝切换到备用号段

CREATE TABLE id_segment (
    id BIGINT AUTO_INCREMENT PRIMARY KEY,
    biz_tag VARCHAR(64) NOT NULL COMMENT '业务标识（如 order、user）',
    max_id BIGINT NOT NULL DEFAULT 1 COMMENT '当前最大已分配 ID',
    step INT NOT NULL COMMENT '步长（每次预分配的 ID 数量）',
    version BIGINT NOT NULL DEFAULT 0 COMMENT '乐观锁版本号',
    description VARCHAR(256) COMMENT '描述',
    update_time TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
                 ON UPDATE CURRENT_TIMESTAMP,
    UNIQUE KEY uk_biz_tag (biz_tag)
) ENGINE=InnoDB;

-- 获取号段（乐观锁 + CAS 更新）
UPDATE id_segment
SET max_id = max_id + step,
    version = version + 1
WHERE biz_tag = 'order' AND version = #{currentVersion};

-- 获取更新后的 max_id
SELECT max_id, step FROM id_segment WHERE biz_tag = 'order';
-- 号段范围：[max_id - step + 1, max_id]

  ┌──────────────┐     ┌──────────────┐
  │  当前号段      │     │  备用号段      │
  │  [1, 1000]    │     │  [1001, 2000] │
  │  消耗中...     │     │  已预加载 ✓    │
  └──────────────┘     └──────────────┘

当前号段消耗到 10% → 触发异步加载备用号段
当前号段用完 → 原子切换到备用号段 → 旧备用变为当前，开始加载新备用

TSID 结构（64位 = Java long）：

 adjustable
<---------->
----------┼----------┼----------┼----------
 time (42 bits)       node       counter
                      (10 bits)  (12 bits)

- time：毫秒时间戳，自 2020-01-01 起算
  42 位 → 有符号 long 可用 ~69 年，无符号 ~139 年
- node：节点标识，0~20 位可调（默认 10 位，支持 1024 节点）
- counter：同一毫秒内的计数器，初始值随机
  node bits + counter bits = 22 位（固定）
  → node=10 时 counter=12，每毫秒 4096 个 ID
  → node=0 时 counter=22，每毫秒 419 万个 ID（单机模式）

<!-- 方式一：Hypersistence TSID（Vlad Mihalcea，提供 Hibernate 集成） -->
<dependency>
    <groupId>io.hypersistence</groupId>
    <artifactId>hypersistence-tsid</artifactId>
    <version>2.1.3</version>
</dependency>

<!-- 方式二：TSID Creator（Fabio Lima，原版实现） -->
<dependency>
    <groupId>com.github.f4b6a3</groupId>
    <artifactId>tsid-creator</artifactId>
    <version>5.2.6</version>
</dependency>

import io.hypersistence.tsid.Tsid;

// 快速生成（使用静态工厂）
Tsid tsid = Tsid.fast();

// 获取数值（存入数据库 BIGINT）
long id = tsid.toLong();           // 如 809100737063473402

// 获取字符串（13字符，Crockford Base32）
String str = tsid.toString();      // 如 "0PEM0TNJ2SM7T"

// 从 ID 反推创建时间
Instant createdAt = tsid.getInstant();

// 场景一：指定节点 ID（分布式环境多节点）
int node = 256;   // 最大值：2^nodeBits - 1
Tsid.Factory factory = Tsid.Factory.builder()
        .withNodeBits(10)   // 节点位：0~20 可调
        .withNode(node)
        .build();

// 场景二：单机模式（无需节点 ID，最大化每毫秒 ID 数）
Tsid.Factory factory = Tsid.Factory.builder()
        .withNodeBits(0)    // 无节点位，counter 占 22 位
        .build();           // 每毫秒可生成 419 万个 ID

// 场景三：自定义纪元
Instant customEpoch = Instant.parse("2000-01-01T00:00:00Z");
Tsid.Factory factory = Tsid.Factory.builder()
        .withCustomEpoch(customEpoch)
        .build();

// 场景四：模拟 Twitter Snowflake 结构
int datacenter = 1, worker = 1;
int snowflakeNode = (datacenter << 5) | worker;
Tsid.Factory factory = Tsid.Factory.builder()
        .withCustomEpoch(Instant.ofEpochMilli(1288834974657L))
        .withNode(snowflakeNode)
        .withRandomFunction(x -> new byte[x])  // 计数器从 0 开始
        .build();

@Entity
@Table(name = "t_order")
public class Order {

    @Id
    private Long id;

    private String orderNo;

    @PrePersist
    public void prePersist() {
        if (id == null) {
            id = Tsid.fast().toLong();
        }
    }

    // 从 ID 反推创建时间（无需额外的 create_time 字段）
    public Instant getCreatedAt() {
        return Tsid.from(id).getInstant();
    }
}

import io.hypersistence.tsid.Tsid;
import org.hibernate.engine.spi.SharedSessionContractImplementor;
import org.hibernate.id.IdentifierGenerator;

public class TsidGenerator implements IdentifierGenerator {

    @Override
    public Long generate(SharedSessionContractImplementor session, Object object) {
        return Tsid.fast().toLong();
    }
}

// 实体中使用
@Entity
@Table(name = "t_order")
public class Order {

    @Id
    @GeneratedValue(generator = "tsid-generator")
    @GenericGenerator(name = "tsid-generator", strategy = "com.example.TsidGenerator")
    private Long id;
}

@Component
public class TsidIdListener {

    @BeforeConvert
    public void assignId(Object entity) {
        if (entity instanceof BaseEntity base && base.getId() == null) {
            base.setId(Tsid.fast().toLong());
        }
    }
}

连续生成的 TSID 字符串序列：

01226N0640J7K
01226N0640J7M
01226N0640J7N
01226N0640J7P
01226N0640J7Q
01226N0640J7R
01226N0640J7S
01226N0640J7T
01226N0693HDA  ← 毫秒切换
01226N0693HDB
01226N0693HDC
...
^^ ^          ^
│  │          │
│  │          └── 随机部分（node + counter）
│  └── 时间戳部分（毫秒）
└── 时间戳高位

特点：
- 字符串天然按时间排序（字典序 = 时间序）
- 仅 13 字符（UUID v4 需要 36 字符）
- 可安全用于 URL、日志、前端展示
- 兼容 JavaScript（Number 精度丢失问题 → 使用字符串）

# 原子自增
INCR order:id          # 返回 1, 2, 3, ...
INCRBY order:id 1000   # 一次分配 1000 个号段

# 带过期时间（按天重置）
SET order:20260525:id 0 EX 86400
INCR order:20260525:id

-- 两个数据库实例，步长为 2
-- 数据库 A：起始值 1，步长 2 → 生成 1, 3, 5, 7, ...
SET @@auto_increment_increment = 2;
SET @@auto_increment_offset = 1;

-- 数据库 B：起始值 2，步长 2 → 生成 2, 4, 6, 8, ...
SET @@auto_increment_increment = 2;
SET @@auto_increment_offset = 2;

// 策略一：IDENTITY — 使用数据库自增（MySQL AUTO_INCREMENT, PostgreSQL SERIAL）
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;

// 策略二：SEQUENCE — 使用数据库序列（Oracle, PostgreSQL）
@Id
@GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "user_seq")
@SequenceGenerator(name = "user_seq",
                   sequenceName = "t_user_seq",
                   allocationSize = 1,     // 每次 nextval 调用分配的 ID 数
                   initialValue = 1)
private Long id;

// 策略三：TABLE — 用独立表模拟序列（跨数据库兼容，性能差）
@Id
@GeneratedValue(strategy = GenerationType.TABLE, generator = "user_table_gen")
@TableGenerator(name = "user_table_gen",
                table = "id_generator",
                pkColumnName = "gen_name",
                pkColumnValue = "user_id",
                valueColumnName = "gen_value",
                allocationSize = 50)
private Long id;

// 策略四：UUID（Hibernate 扩展，JPA 标准不内置）
@Id
@GeneratedValue(generator = "uuid2")
@GenericGenerator(name = "uuid2", strategy = "uuid2")
@Column(columnDefinition = "VARCHAR(36)")
private String id;

// 正确的配合使用
// 数据库端：CREATE SEQUENCE t_user_seq INCREMENT BY 50;
// JPA 端：
@SequenceGenerator(name = "user_seq",
                   sequenceName = "t_user_seq",
                   allocationSize = 50)  // 与 INCREMENT BY 一致

@Data
@TableName("t_user")
public class User {

    // 雪花算法（默认策略）
    @TableId(value = "id", type = IdType.ASSIGN_ID)
    private Long id;
}

# application.yml 全局配置
mybatis-plus:
  global-config:
    db-config:
      id-type: assign_id          # 全局主键策略（默认雪花算法）

开始
  ↓
是否分库分表 / 微服务？
  ├── 否 → 单库自增（MySQL AUTO_INCREMENT / PG SEQUENCE）
  └── 是
        ↓
      是否需要严格递增？
        ├── 否 → TSID（推荐）/ 雪花算法（无需协调、高性能）
        └── 是
              ↓
            是否对高可用有极高要求？
              ├── 否 → Redis INCR
              └── 是 → 号段模式（Leaf-segment）

t_order 表：
  id          BIGINT AUTO_INCREMENT PRIMARY KEY   -- 聚簇索引主键，有序写入
  order_no    BIGINT NOT NULL UNIQUE              -- 雪花算法生成的业务订单号
  ...

好处：
  1. 主键有序 → InnoDB 写入性能最优
  2. 业务 ID 全局唯一 → 分库分表、跨服务引用时使用
  3. 主键短小 → 二级索引紧凑，内存利用率高