Uuid、数据库自增、雪花算法、基于redis自研等数据库唯一ID生成策略对比
Uuid、数据库自增、雪花算法、基于redis自研等数据库唯一ID生成策略对比
使用环境
分布式、高并发下全局唯一，趋势递增，效率高，控制并发
先直接上个对比图吧，下面大量干货警告
一、Uuid（java1.5后自带生成工具类）
Uuid是按照开放软件基金会(osf)制定的标准计算用到了以太网开地址(MAC),纳米级时间,芯片id码和许多可能的数字
优点:
使用简单
不依赖其他组件
不影响数据库拓展
缺点:
数据库索引效率低
太过于无意义.用户不友好
长度36的字符串,空间占用大
应用集群环境,机器多的时候,重复几率大
使用方法
import java.util.UUID;
public class UTest {
public static void main(String[] args) {
UUID uuid = UUID.randomUUID();//生成的类型为uuid类型
String s = UUID.randomUUID().toString();//经过toString后可直接赋值到id上实现存储
System.out.println(uuid);
System.out.println(s);
}
}
也可以适当的自定义内容
public class UUIDGenerator {
public UUIDGenerator() {
}
/**
* 获得一个UUID
* @return String UUID
*/
public static String getUUID(){
String s = UUID.randomUUID().toString();
//去掉“-”符号
return s.substring(0,8)+s.substring(9,13)+s.substring(14,18)+s.substring(19,23)+s.substring(24);
}
/**
* 获得指定数目的UUID
* @param number int 需要获得的UUID数量
* @return String[] UUID数组
*/
public static String[] getUUID(int number){
if(number < 1){
return null;
}
String[] ss = new String[number];
for(int i=0;i二、数据库自增
Mysql 整型自增索引之所以快是因为mysql 采用b+树对整型进行了加速
Mysql使用auto_increment, oracle使用sequence序列
集群环境下,不同的库,设置不同的初始值,每次自增加 100
Mysql下修改起点和步长的方式
设置起点
Set @@auto_increment_offset=1 // 设置起点为1
设置步长
Set@@auto_increment_increment=100 // 设置步长为100
查看参数
show VARIABLES like 'auto_%' // 查看参数
优点:
无需编码
性能也过得去
索引友好
缺点:
大表不能做水平分表,否则插入删除易出现问题(已经存在很大数据的时候再分表,容易出现问题)
依赖前期规划,拓展麻烦
依赖mysql内部维护自增锁,高并发下插入数据影响性能
在业务操作父,子(关联表)插入时,要先父表 后子表
相对于uuid 其实 数据库自增表的效率稍低
特点是 : 互斥 排他 可重入
CREATE TABLE TABLE_1
( ID INT UNSIGNED NOT NULL PRIMARY KEY AUTO_INCREMENT, // ID列为无符号整型，该列值不可以为空，并不可以重复，而且自增。
NAME VARCHAR(5) NOT NULL )
AUTO_INCREMENT = 100;
三、雪花算法（snowflake算法）
Snowfake算法是twitter’开源的分布式id生成算法,结果就是long长整型的id
优点:
性能较优,速度快
无需第三方依赖,实现也简单
可以根据实际情况调整和拓展算法,方便灵活 (开源)
缺点:
依赖时间机器,如果发生回拨会导致生成id重复,业界使用一般是根据雪花算法进行拓展的
(可以把这个服务单独做成一个服务用于生成id,但是会连累生成效率)
源码
package com.cnblogs.util;
/**
* Twitter_Snowflake
* SnowFlake的结构如下(每部分用-分开):
* 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和5位workerId
* 12位序列，毫秒内的计数，12位的计数顺序号支持每个节点每毫秒(同一机器，同一时间戳)产生4096个ID序号
* 加起来刚好64位，为一个Long型。
* SnowFlake的优点是，整体上按照时间自增排序，并且整个分布式系统内不会产生ID碰撞(由数据中心ID和机器ID作区分)，并且效率较高，经测试，SnowFlake每秒能够产生26万ID左右。
*/
public class SnowflakeIdWorker {
// ==============================Fields===========================================
/** 开始时间截 (201-01-01) */
private final long twepoch = 1514736000000L;
/** 机器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 < 10; i++) {
long id = idWorker.nextId();
System.out.println(Long.toBinaryString(id));
System.out.println(id);
}
}
}
代码简单，但是在分布式系统使用的时候有一些问题：
-
不同服务器如何使用不同workId，datacenterId？
-
该类设置为单例初始化？
解决办法如下：
-
该微服务启动的时候，workId和datacenterId作为参数传入
-
使用Component注解，将SnowflakeIdWorker类设为单例初始化
package com.cnblogs;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.exception.ExceptionUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.stereotype.Component;
import tech.fullink.eaglehorn.lzfentrance.util.SnowflakeIdWorker;
import javax.annotation.PostConstruct;
import java.util.Set;
import java.util.concurrent.TimeUnit;
/**
* @author
* Date: 2018/10/26
* Time: 17:00:35
*/
@Slf4j
@Component
public class SnowflakeComponent {
@Value("${server.datacenterId}")
private long datacenterId;
@Value("${server.workId}")
private long workId;
private static volatile SnowflakeIdWorker instance;
public SnowflakeIdWorker getInstance() {
if (instance == null) {
synchronized (SnowflakeIdWorker.class) {
if (instance == null) {
log.info("when instance, workId = {}, datacenterId = {}", workId, datacenterId);
instance = new SnowflakeIdWorker(workId, datacenterId);
}
}
}
return instance;
}
}
调用代码
package com.cnflogs;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
import com.cnflogs.SnowflakeComponent;
/**
* @author
*/
@Slf4j
@RestController
public class TestController {
@Autowired
private SnowflakeComponent snowflakeComponent;
/**
* 获取订单号
*
* @return
*/
@RequestMapping(value = "order/no", method = RequestMethod.GET)
long getOrderNo() {
return snowflakeComponent.getInstance().nextId();
}
}
我们用的是spring boot，对应的配置文件bootstrap.yml配置如下：注意要传递的参数配置一定要放在bootstrap.yml里面，而不是application.yml
###################### server info #####################
server:
port: 10000
ssl:
enabled: false
error:
whitelabel:
enabled: false
workId: 0
datacenterId: 0 #雪花算法的数据中心id，在java 启动命令中定义，四台为0，1，2，3
spring:
application:
name:test
启动方式：
java -jar -Xms256m -Xmx512m -Dserver.workId=1 -Dserver.datacenterId=1 /home/admin/jars/test.jar
不同的服务器 -Dserver.workId -Dserver.datacenterId设置为不同的值。
这样就能正常使用了。
四、基于Redis自研等数据库唯一id策略
Java 中 基本类型所占的字节
Oracle 产生序列号的方式
利用增长计数api,业务系统在自增长的基础上,配合其他信息组成一个唯一id
Redis的incr(key) api用于将key的值进行递增,并返回增长数值
如果key不存在,则创建并赋值为0
利用redis的特性: 单线程原子操作,自增计数api,数据有效机制ex
实例
业务编码+地区+自增数值
key的命名规范
系统名:+ 模块:+ 功能: + key 例如: 163:study:order:id
优点:
拓展性强,可以方便的结合业务进行处理
利用redis操作原子性的特征,可以保证在并发的时候不会重复
缺点:
引入redis就意味着引入其他三方依赖
增加一侧网络开销
需要对reids服务实现高可用
高可用
自动分片
哨兵模式
注意: 集群并不能做高可用,因为redis集群中没有选举机制,所以需要采用哨兵(选举的机制)的机制配置高可用
利用springboot整个redis
pom文件
4.0.0
com.example
demo
0.0.1-SNAPSHOT
jar
demo
Demo project for Spring Boot
org.springframework.boot
spring-boot-starter-parent
1.5.8.RELEASE
UTF-8
UTF-8
1.8
org.springframework.boot
spring-boot-starter-data-redis
org.springframework.boot
spring-boot-starter-web
org.projectlombok
lombok
true
org.springframework.boot
spring-boot-starter-test
test
org.springframework.boot
spring-boot-maven-plugin
yml文件
spring:
application:
name: redis-demo
redis:
database: 0
host: 127.0.0.1
port: 6379
timeout: 0 # 连接超时时间（毫秒）
pool:
max-active: 20 # 连接池最大连接数（使用负值表示没有限制）
max-idle: 20 # 连接池中的最大空闲连接
max-wait: -1 # 连接池最大阻塞等待时间（使用负值表示没有限制）
min-idle: 0 # 连接池中的最小空闲连接
server:
port: 8080
servlet:
context-path: /redis-demo
Redis config 配置
package com.example.demo.config;
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.interceptor.KeyGenerator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import java.util.Arrays;
/**
* @Title: redis配置类
* @Package RedisConfig
* redis配置类
* @author syliu
* @create 2017/9/29 0029
*/
@Configuration
public class RedisConfig {
@Bean
public RedisTemplate redisTemplate(RedisConnectionFactory factory) {
StringRedisTemplate template = new StringRedisTemplate(factory);
Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
ObjectMapper objectMapper = new ObjectMapper();
objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
jackson2JsonRedisSerializer.setObjectMapper(objectMapper);
template.setValueSerializer(jackson2JsonRedisSerializer);
template.afterPropertiesSet();
return template;
}
}
生成方式
package com.example.demo.service;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import java.util.Calendar;
import java.util.Date;
/**
* @author syliu
* 利用redis生成数据库全局唯一性id
*/
@Service
public class PrimaryKeyService {
@Autowired
private RedisTemplate redisTemplate;
/**
* 获取年的后两位加上一年多少天+当前小时数作为前缀
* @param date
* @return
*/
public String getOrderIdPrefix(Date date) {
Calendar calendar = Calendar.getInstance();
calendar.setTime(date);
int year = calendar.get(Calendar.YEAR);
int month = calendar.get(Calendar.MONTH);
int day = calendar.get(Calendar.DAY_OF_MONTH);
int hour = calendar.get(Calendar.HOUR_OF_DAY);
//补两位,因为一年最多三位数
String monthFormat = String.format("%1$02d", month+1);
//补两位，因为日最多两位数
String dayFormat = String.format("%1$02d", day);
//补两位，因为小时最多两位数
String hourFormat = String.format("%1$02d", hour);
return year + monthFormat + dayFormat+hourFormat;
}
/**
* 生成订单
* @param prefix
* @return
*/
public Long orderId(String prefix) {
String key = "DEMO_ORDER_ID_" + prefix;
String orderId = null;
try {
Long increment = redisTemplate.opsForValue().increment(key,1);
//往前补6位
orderId=prefix+String.format("%1$06d",increment);
} catch (Exception e) {
System.out.println("生成订单号失败");
e.printStackTrace();
}
return Long.valueOf(orderId);
}
}
测试类
package com.example.demo;
import com.example.demo.service.PrimaryKeyService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import java.util.Date;
@RunWith(SpringRunner.class)
@SpringBootTest
public class DemoApplicationTests {
@Autowired
private PrimaryKeyService primaryKeyService;
@Test
public void contextLoads() {
long startMillis = System.currentTimeMillis();
String orderIdPrefix = primaryKeyService.getOrderIdPrefix(new Date());
for (int i = 0; i < 10; i++) {
Long aLong = primaryKeyService.orderId(orderIdPrefix);
System.out.println(aLong);
}
long endMillis = System.currentTimeMillis();
System.out.println("生成速度:"+(endMillis-startMillis)+",单位毫秒");
}
}
主要资料来自参考
https://blog.csdn.net/qq_35977237/article/details/84338473
https://blog.csdn.net/kai3123919064/article/details/88771395
https://www.cnblogs.com/cs99lzzs/p/9869414.html