16位分布式id生成工具--雪花算法--程序毕用，主键自动增加过时了

一、什么是分布式系统唯一ID
在复杂分布式系统中，往往需要对大量的数据和消息进行唯一标识。
如在金融、电商、支付、等产品的系统中，数据日渐增长，对数据分库分表后需要有一个唯一ID来标识一条数据或消息，数据库的自增ID显然不能满足需求，此时一个能够生成全局唯一ID的系统是非常必要的。
二、snowflake雪花算法生成ID
这种方案大致来说是一种以划分命名空间（UUID也算，由于比较常见，所以单独分析）来生成ID的一种算法，这种方案把64-bit分别划分成多段，分开来标示机器、时间等
雪花算法ID优点：
毫秒数在高位，自增序列在低位，整个ID都是趋势递增的。
不依赖数据库等第三方系统，以服务的方式部署，稳定性更高，生成ID的性能也是非常高的。
可以根据自身业务特性分配bit位，非常灵活。
三、64-bit太长，想做16位的方便存储使用
使用时，注入CustomIdGenerator
然后调用结课如下：

    @Autowired
    private CustomIdGenerator customIdGenerator;
    public void add(User user){
   
       Long aLong = customIdGenerator.nextId(user);
        user.setId(aLong);//设置id
}

CustomIdGenerator 类

import com.baomidou.mybatisplus.core.incrementer.IdentifierGenerator;
import org.springframework.stereotype.Component;

/**
 * @author james
 * @Description 自定义ID生成长度为16位
 * .
 * @since 2022年11月10日
 */
@Component
public class CustomIdGenerator implements IdentifierGenerator {
   
	@Override
	public Long nextId(Object esntity) {
   
		// 填充自己的Id生成器，
		return IdGenerator16Bit.generateId();
	}
}


 

  
 

IdGenerator16Bit 类

import java.util.Date;
import java.util.UUID;

/**
 * @author james
 * @Description TODO
 * .
 * @since 2022年11月10日
 */
public class IdGenerator16Bit {
   
	private static IdGenerator16Bit instance = new IdGenerator16Bit(0);

	public static IdGenerator16Bit initDefaultInstance(int machineId) {
   
		instance = new IdGenerator16Bit(machineId);
		return instance;
	}

	public static IdGenerator16Bit getInstance() {
   
		return instance;
	}

	public static long generateId() {
   
		return instance.nextId();
	}

	// total bits=53(max 2^53-1：9007199254740992-1)

	// private final static long TIME_BIT = 40; // max: 2318-06-04
	private final static long MACHINE_BIT = 5; // max 31
	private final static long SEQUENCE_BIT = 8; // 256/10ms

	/**
	 * mask/max value
	 */
	private final static long MAX_MACHINE_NUM = -1L ^ (-1L << MACHINE_BIT);
	private final static long MAX_SEQUENCE = -1L ^ (-1L << SEQUENCE_BIT);

	private final static long MACHINE_LEFT = SEQUENCE_BIT;
	private final static long TIMESTMP_LEFT = MACHINE_BIT + SEQUENCE_BIT;

	private long machineId;
	private long sequence = 0L;
	private long lastStmp = -1L;

	private IdGenerator16Bit(long machineId) {
   
		if (machineId > MAX_MACHINE_NUM || machineId < 0) {
   
			throw new IllegalArgumentException(
					"machineId can't be greater than " + MAX_MACHINE_NUM + " or less than 0");
		}
		this.machineId = machineId;
	}

	/**
	 * generate new ID
	 *
	 * @return
	 */
	public synchronized long nextId() {
   
		long currStmp = getTimestamp();
		if (currStmp < lastStmp) {
   
			throw new RuntimeException("Clock moved backwards.  Refusing to generate id");
		}

		if (currStmp == lastStmp) {
   
			sequence = (sequence + 1) & MAX_SEQUENCE;
			if (sequence == 0L) {
   
				currStmp = getNextTimestamp();
			}
		} else {
   
			sequence = 0L;
		}

		lastStmp = currStmp;

		return currStmp << TIMESTMP_LEFT //
				| machineId << MACHINE_LEFT //
				| sequence;
	}

	private long getNextTimestamp() {
   
		long mill = getTimestamp();
		while (mill <= lastStmp) {
   
			mill = getTimestamp();
		}
		return mill;
	}

	private long getTimestamp() {
   
		// per 10ms
		return System.currentTimeMillis() / 10;// 10ms
	}

	public static Date parseIdTimestamp(long id) {
   
		return new Date((id >>> TIMESTMP_LEFT) * 10);
	}

	public static String uuid() {
   
		return UUID.randomUUID().toString().replaceAll("-", "");
	}
}


 

  
 

原创不易，用途很大，特别不重复的id，点赞+关注+收藏