Skuid生成器 简单易用 高性能 高可用的id生成系统

ID是数据的唯一标识，传统的做法是利用UUID和数据库的自增ID，在互联网企业中，大部分公司使用的都是Mysql，并且因为需要事务支持，所以通常会使用Innodb存储引擎，UUID太长以及无序，所以并不适合在Innodb中来作为主键，自增ID比较合适，但是随着公司的业务发展，数据量将越来越大，需要对数据进行分表，而分表后，每个表中的数据都会按自己的节奏进行自增，很有可能出现ID冲突。这时就需要一个单独的机制来负责生成唯一ID，生成出来的ID也可以叫做分布式ID，或全局ID。

下面来是各个生成分布式ID的机制。

下面是我想到的一套策略： 类似滴滴的TinyId生成类似

/**
* @author :
* @program:es-server
* @description: 生成唯一码 <br>
* @create:2019-10-09 15-42
* @return:
*/
public interface SequenceService {
/**
* 方法: generateUniqueKey <br>
* 描述: 根据指定key生成唯一自增值 <br>
* 作者: 
* 时间: 2019-10-09 15-42
* @param key 系统标识
* @param limit
* @return
*/
public Long generateUniqueKey(CommonGenerateKey key, long limit) ;
}

//系统标识key 枚举

package com.ouyue.xiwen.esserver.common.enums;
import lombok.Getter;

public enum CommonGenerateKey {

    API_ACCESS_KEY("API_ACCESS_KEY", "ACCESS_KEY,系统自动生成"),
    ACCOUNTBILLNO("ACCOUNTBILLNO", "账单编号序列"),
    PAYROLLREQUISITIONNO("PAYROLLREQUISITIONNO","请款单号序列"),
    WAY_BILL_NO("WAY_BILL_NO","运输单号序列"),
    ;
    @Getter
    private String key;
    @Getter
    private String des;

    CommonGenerateKey(String intValue, String des) {
        this.key = intValue;
        this.des = des;
    }

    public String toString() {
        return this.des;
    }
}


/**
 * @author :
 * @program:es-server
 * @description:生成唯一码 <br>
 * @create:2019-10-09 15-44
 */
public class SequenceServiceImpl implements SequenceService {

    protected static final Logger logger = LoggerFactory.getLogger(SequenceServiceImpl.class);

    @Resource
    private SequenceDao sequenceDao;


    private final ConcurrentHashMap<String, Map.Entry<Long, Long>> keyMap = new ConcurrentHashMap<>();

    /**
     * 方法: updateBySkuId <br>
     * 描述: 根据sku全量更新 <br>
     * @author :
    * @create:2019-10-09 15-44
     *
     * @return
     */

    public Long generateUniqueKey(CommonGenerateKey key, long limit) {
        // 默认缓存到本地的key域
        if (limit <= 3) {
            limit = 10;
        }
        synchronized (key.getKey()) {
            Map.Entry<Long, Long> entry = keyMap.get(key.getKey());
            if (entry == null) {
                Long generateUniqueKey = sequenceDao.generateUniqueKey(key, limit);
                keyMap.put(key.getKey(), Maps.immutableEntry(generateUniqueKey, generateUniqueKey + limit - 1));
                logger.info("击穿db:" + (generateUniqueKey));
                return generateUniqueKey;
            } else {
                Long start = entry.getKey();
                Long end = entry.getValue();
                Long result = start + 1;
                if (end - start < 2) {
                    keyMap.remove(key.getKey());
                } else {
                    keyMap.put(key.getKey(), Maps.immutableEntry(result, end));
                }
                logger.info("走缓存:" + result);
                return result;
            }
        }
    }

}

/**
 * @author :
 * @program:es-server
 * @description:
 * @create:2019-10-09 15-45
 */
@Component
public class SequenceDao {

    protected static final Logger logger = LoggerFactory.getLogger(SequenceDao.class);

    @Resource
    private DBSequenceMapper dbSequenceMapper;

    /**
     * 方法: updateBySkuId <br>
     * 描述: 根据sku全量更新 <br>
     * 作者: 
     * 时间: 2019年10月9日
     *
     * @return
     */

    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public Long generateUniqueKey(CommonGenerateKey key, long limit) {
        for (int i = 0; i < 20; i++) {
            DBSequence oldSequence = selectByKey(key.getKey());
            if (oldSequence == null) {
                oldSequence = createSequence(key.getKey());
                boolean insert = insert(oldSequence);
                if (!insert) {
                    ExceptionUtil.serviceException("创建seq失败");
                }
            }
            oldSequence.setNewValue(oldSequence.getSeqValue() + limit);
            boolean result = update(oldSequence);
            if (!result) {
                try {
                    logger.error("Sequence.generateKey fail sleep {}", i * 10);
                    Thread.sleep(i * 10);
                } catch (InterruptedException e) {
                    logger.error("Sequence.generateKey sleep {}", key, e);
                }
                continue;
            }
            DBSequence newsequence = selectByKey(key.getKey());
            if (NumberUtils.compare(newsequence.getSeqValue(), oldSequence.getNewValue()) == 0) {
                logger.info("击穿db:" + (oldSequence.getSeqValue() + 1));
                return oldSequence.getSeqValue() + 1;
            }
        }
        ExceptionUtil.serviceException("数据库异常");
        return -1l;
    }

    /**
     * 方法: updateBySkuId <br>
     * 描述: 根据sku全量更新 <br>
     * 作者: 
     * 时间: 2019年10月9日
     *
     * @return
     */
    public boolean insert(DBSequence squence) {
        try {
            squence.setDbUpdateTime(new Date());
            int update = dbSequenceMapper.insertSelective(squence);
            return update > 0;
        } catch (Exception e) {
            logger.error("Sequence.update error {}", JSONObject.toJSONString(squence), e);
            ExceptionUtil.serviceException(ExceptionCode.DB_ERROR);
            return false;
        }
    }

    /**
     * 方法: updateBySkuId <br>
     * 描述: 根据sku全量更新 <br>
     * 作者: 
     * 时间: 2019年10月9日
     * @return
     */
    public boolean update(DBSequence squence) {
        try {
            int update = dbSequenceMapper.updateByPrimaryKeySelective(squence);
            return update > 0;
        } catch (Exception e) {
            logger.error("Sequence.update error {}", JSONObject.toJSONString(squence), e);
            ExceptionUtil.serviceException(ExceptionCode.DB_ERROR);
            return false;
        }
    }

    /**
     * 方法: updateBySkuIdSelective <br>
     * 描述: 根据sku更新 <br>
     * 作者: 
     * 时间: 2019年10月9日
     *
     * @return
     */
    public DBSequence selectByKey(String key) {
        try {
            return dbSequenceMapper.selectBySeqKey(key);
        } catch (Exception e) {
            logger.error("Sequence.selectByKey error {}", key, e);
            ExceptionUtil.serviceException(ExceptionCode.DB_ERROR);
            return null;
        }
    }

    private DBSequence createSequence(String key) {
        DBSequence seq = new DBSequence();
        seq.setSeqKey(key);
        seq.setSeqValue(1l);
        seq.setRemark("system创建");
        seq.setDbCreateTime(new Date());
        return seq;
    }
}



数据库表字段值


CREATE TABLE `db_sequence` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键',
  `seq_key` varchar(50) NOT NULL COMMENT '序号键',
  `seq_value` bigint(20) DEFAULT '0' COMMENT '序号值',
  `remark` varchar(100) DEFAULT '' COMMENT '备注',
  `new_value` bigint(20) DEFAULT '0' COMMENT '新的序列值',
  `db_update_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '修改时间',
  `db_create_time` timestamp NOT NULL DEFAULT '2000-01-01 00:00:00' COMMENT '创建时间',
  PRIMARY KEY (`id`),
  UNIQUE KEY `unique_key` (`seq_key`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='自增序号表'/* BF=seq_key, POLICY=ims_single, STARTID=1, ASSIGNIDTYPE=USB */;

备注 /* BF=seq_key, POLICY=ims_single, STARTID=1, ASSIGNIDTYPE=USB */ 标识是 分布式数据库id 主键