https://blog.csdn.net/fayeyiwang/article/details/52128206
https://tech.meituan.com/2017/04/21/mt-leaf.html
关于订单号的生成，有一些简单的方案
1，数据库自增长id
优势： 无需编码
缺陷：
大表不能做水平分表，否则插入删除时容易出现问题
高并发下插入数据需要加入失误机制
在业务操作父，子表（关联表）插入时，先要插入父表，再插入子表
2，时间戳+ 随机数
优势： 编程简单
缺陷： 随机数存在重复问题，即使在相同的时间戳下。每次插入数据库前需要校验下是否已经存在相同的数值。
3，时间戳+会员ID
优势： 同一时间，一个用户不会存在2张订单
缺陷： 会员ID也会透露出运营数据，鸡生蛋蛋生鸡的问题
4，GUID/UUID
优势： 简单
劣势： 用户不友好，索引关联效率较低
5 snowflake方案：
snowflake是Twitter开源的分布式ID 生成算法，结果是一个long型的ID
这种方案大致来说是一种以划分明明空间（UUID也算，由于比较常见，所以单独分析）来生成的ID 的一种算法，这种方案把64-bit分贝划分成多段，分开来提示机器，时间等；
其核心思想是： 使用41bit作为毫秒数，10bit作为机器的ID(5ge bit是数据中心，5个bit的机器ID),12bit 作为毫秒数内的流水号，最后一个符号位，永远是0.
比如在snowlake中的64-bit分别表示如下图（图片来自网络）表示image
整个结构是64位，所以我们在Java中可以使用long来进行存储。该算法实现基本就是二进制操作，单机每秒内理论上最多可以生成1024(2^12),也就是409.6万个ID(10244096=4194304)
0 - 0000000000 0000000000 0000000000 0000000000 0 - 00000 - 00000 - 000000000000
1位标识， 由于long基本类型在java中是带符号的，最高位是符号位，正数是0，负数是1，所以id一般是正数，最高位是0
41位时间戳（毫秒级），注意，41位时间戳不是存储当前时间的时间戳，而是存储时间戳的差值（当前时间戳-开始时间戳）得到的值），这里的开始时间戳，一般是我们的id生成器开始使用的时间，由我们的程序开始指定（如下面程序的IdWorker 类的starttime属性）。41位时间可以使用69年T = (1L << 41) / (1000L * 60 * 60 * 24 * 365) = 69
10 位的数据机器位，可以部署在1024个节点上，包括5位datacenterId和3位workerid.10 -bit机器可以分别表示1024台机器。如果我们对IDC划分有需求，还可以将10-bit分5bit给IDC,分5-bit给工作机器。这样就可以表示32IDC,每个IDC下可以有32台机器，可与根据自身需求定义。
12位序列： 毫秒内的计数，12位的计数顺序号支持每个节点每毫秒（同一个机器，同一时间戳）产生4096个ID 序号，12个自增序列号可以表示2^12个ID,理论上snowflake方案的QPS约为409.6w/s,这种分配方式可以保证在任何一个IDC的任何一台机器在任意毫秒内生成的ID都是不同的；
加起来刚好是64位，为一个long型；
优点：
整体上按照时间自增排序，并且排序整个分布式系统内不会产生ID碰撞（由数据中心ID和机器ID做区分），并且效率高，轻测试，SnowFlaje每秒能产生26万ID左右。
毫秒数在高位，自增序列在低位，整个ID都是趋势递增的
不依赖数据库等第三方系统，以服务的方式部署，稳定性更高，生成ID 的性能也是非常高的
可以根据自身业务特性分配bit位，非常灵活。
缺点：
强依赖机器时钟，如果机器上时钟回拨，会导致发号重复或者服务处于不可用状态
针对此，美团做出了改进：[https://github.com/Meituan-Dianping/Leaf](https://github.com/Meituan-Dianping/Leaf)
SnowFlake算法代码
public class SnowflakeIdWorker {
// ==============================Fields==================
/** 开始时间截 (2019-08-06) */
private final long twepoch = 1565020800000L;
/** 机器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);
}
}
}
snowflake实现方式1
apache.commons.lang3包
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
<version>3.6</version>
</dependency>
工具类
package com.datalook.util.common;
import org.apache.commons.lang3.time.DateFormatUtils;
import java.util.Date;
/**
*
* @Title: 订单号生成
* @ClassName:OrderIdUtils.java
* @Description:
*
* @Copyright 2016-2017 - Powered By 研发中心
* @author: 王延飞
* @date:2018年3月22日 下午7:43:30
* @version V1.0
*/
public class OrderIdUtils {
// 最近的时间戳
private long lastTimestamp=0;
//机器id 2位
private final String machineId;
// 0，并发控制
private long sequence = 0L;
// 序列号的最大值
private final int sequenceMax = 9999;
public OrderIdUtils(String machineId) {
this.machineId = machineId;
}
/**
* 生成订单号
*/
public synchronized String nextId(){
Date now=new Date();
String time= DateFormatUtils.format(now,"yyMMddHHmmssSSS");
long timestamp = now.getTime();
if (this.lastTimestamp == timestamp) {
// 如果上一个timestamp与新产生的相等，则sequence加一(0-4095循环);
// 对新的timestamp，sequence从0开始
this.sequence = this.sequence + 1 % this.sequenceMax;
if (this.sequence == 0) {
// 重新生成timestamp
timestamp = this.tilNextMillis(this.lastTimestamp);
}
} else {
this.sequence = 0;
}
this.lastTimestamp= timestamp;
StringBuilder sb=new StringBuilder(time).append(machineId).append(leftPad(sequence,4));
return sb.toString();
}
/**
* 补码
* @param i
* @param n
* @return
*/
private String leftPad(long i,int n){
String s = String.valueOf(i);
StringBuilder sb=new StringBuilder();
int c=n-s.length();
c=c<0?0:c;
for (int t=0;t<c;t++){
sb.append("0");
}
return sb.append(s).toString();
}
/**
* 等待下一个毫秒的到来, 保证返回的毫秒数在参数lastTimestamp之后
*/
private long tilNextMillis(long lastTimestamp) {
long timestamp = System.currentTimeMillis();
while (timestamp <= lastTimestamp) {
timestamp = System.currentTimeMillis();
}
return timestamp;
}
// 这里读取的是配置文件
// 机器id(我这里是01,正式环境建议使用机器IP)
// 注意：分布式环境,注意每台机器的id要保证不同;也可以使用机器ip,映射成一个数字编号（如01:192.168.55.12）
private static String myid= SysConstant.LOCAL_MACHINE_ID;
// 示例
private static OrderIdUtils instance = new OrderIdUtils(myid);
public static OrderIdUtils getInstance() {
return instance;
}
/**
*
* @Title: 获取订单号
* @return String
* @Description:
*
* @author: 王延飞
* @date: 2018年3月22日 下午7:56:56
*/
public static String getOrderNumber() {
OrderIdUtils orderId = OrderIdUtils.getInstance();
String nextId = orderId.nextId();
return nextId;
}
/**
* 调用
*/
public static void main(String[] args) {
OrderIdUtils orderId= OrderIdUtils.getInstance();
String nextId = orderId.nextId();
int length = nextId.length();
System.out.println(nextId);
System.out.println(length);
}
}
snowflake实现方式2
引入hutool依赖
<dependency>
<groupId>cn.hutool</groupId>
<artifactId>hutool-captcha</artifactId>
<version>5.0.6</version>
</dependency>
ID 生成器
public class IdGenerator {
private long workerId = 0;
@PostConstruct
void init() {
try {
workerId = NetUtil.ipv4ToLong(NetUtil.getLocalhostStr());
log.info("当前机器 workerId: {}", workerId);
} catch (Exception e) {
log.warn("获取机器 ID 失败", e);
workerId = NetUtil.getLocalhost().hashCode();
log.info("当前机器 workerId: {}", workerId);
}
}
/**
* 获取一个批次号，形如 2019071015301361000101237
* <p>
* 数据库使用 char(25) 存储
*
* @param tenantId 租户ID，5 位
* @param module 业务模块ID，2 位
* @return 返回批次号
*/
public synchronized String batchId(int tenantId, int module) {
String prefix = DateTime.now().toString(DatePattern.PURE_DATETIME_MS_PATTERN);
return prefix + tenantId + module + RandomUtil.randomNumbers(3);
}
@Deprecated
public synchronized String getBatchId(int tenantId, int module) {
return batchId(tenantId, module);
}
/**
* 生成的是不带-的字符串，类似于：b17f24ff026d40949c85a24f4f375d42
*
* @return
*/
public String simpleUUID() {
return IdUtil.simpleUUID();
}
/**
* 生成的UUID是带-的字符串，类似于：a5c8a5e8-df2b-4706-bea4-08d0939410e3
*
* @return
*/
public String randomUUID() {
return IdUtil.randomUUID();
}
private Snowflake snowflake = IdUtil.createSnowflake(workerId, 1);
public synchronized long snowflakeId() {
return snowflake.nextId();
}
public synchronized long snowflakeId(long workerId, long dataCenterId) {
Snowflake snowflake = IdUtil.createSnowflake(workerId, dataCenterId);
return snowflake.nextId();
}
/**
* 生成类似：5b9e306a4df4f8c54a39fb0c
* <p>
* ObjectId 是 MongoDB 数据库的一种唯一 ID 生成策略，
* 是 UUID version1 的变种，详细介绍可见：服务化框架－分布式 Unique ID 的生成方法一览。
*
* @return
*/
public String objectId() {
return ObjectId.next();
}
}
public static void main(String[] args) {
for (int i = 0; i <1000 ; i++) {
OrderIdUtils orderIdUtils=OrderIdUtils.getInstance();
String nextId=orderIdUtils.nextId();
int length=nextId.length();
System.out.println(nextId);
System.out.println(length);
}
}
}
