雪花算法生成ID

前言
我們的數據庫在設計時一般有兩個ID，自增的id為主鍵，還有一個業務ID使用UUID生成。自增id在需要分表的情況下做為業務主鍵不太理想，所以我們增加了uuid作為業務ID,有了業務id仍然還存在自增id的原因具體我也說不清楚，只知道和插入的性能以及db的要求有關。

我個人一直想將這兩個ID換成一個字段來處理,所以要求這個id是數字類似的，且是趨拋增長的，這樣mysql創建索引以及查詢時性能會比較好。於時網上找到了雪花算法.關於雪花算法大家可以看一下我后面引用的資料。

ID生成器代碼:
從網上抄的，自己改的，目前我還沒有應用到實際項目中，如需應用，請先進行嚴格自測

 
import java.time.LocalDateTime;
import java.time.ZoneOffset;
import java.time.format.DateTimeFormatter;
 
/**
 * <p>
 *  在雪花算法基礎生稍做改造生成Long Id
 *  https://www.jianshu.com/p/d3881a6a895e
 * </p>
 * 1 - 41位 - 10位 - 12位
 * 0 - 41位 - 10位 - 12位
 * <p>
 * <PRE>
 * <BR>    修改記錄
 * <BR>-----------------------------------------------
 * <BR>    修改日期         修改人          修改內容
 * </PRE>
 *
 * @author cuiyh9
 * @version 1.0
 * @Date Created in 2018年11月29日 20:46
 * @since 1.0
 */
public final class ZfIdGenerator {
 
    /**
     * 起始的時間戳
     */
    private static final long START_TIME_MILLIS;
 
    /**
     * 每一部分占用的位數
     */
    private final static long SEQUENCE_BIT = 12; //序列號占用的位數
    private final static long WORKID_BIT = 10;   //機器標識占用的位數
 
    /**
     * 每一部分的最大值
     */
    private final static long MAX_WORK_NUM = -1L ^ (-1L << WORKID_BIT);
    private final static long MAX_SEQUENCE = -1L ^ (-1L << SEQUENCE_BIT);
 
    /**
     * 每一部分向左的位移
     */
    private final static long WORKID_SHIFT = SEQUENCE_BIT;
    private final static long TIMESTMP_SHIFT = WORKID_SHIFT + WORKID_BIT;
 
    private long sequence = 0L; //序列號
    private long lastStmp = -1L;
 
    /** workId */
    private long workId;
 
    static {
        String startDate = "2018-01-01 00:00:00";
        DateTimeFormatter df = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        LocalDateTime localDateTime = LocalDateTime.parse(startDate, df);
        START_TIME_MILLIS = localDateTime.toInstant(ZoneOffset.of("+8")).toEpochMilli();
 
    }
 
 
 
 
    /**
     * 獲取分部署式發號器
     * @param workId 每台服務需要傳一個服務id
     * @return
     */
    public static synchronized ZfIdGenerator getDistributedIdGenerator(long workId) {
        return new ZfIdGenerator(workId);
    }
 
    public static synchronized ZfIdGenerator getStandAloneIdGenerator() {
        long workId = MAX_WORK_NUM;
        return new ZfIdGenerator(workId);
    }
 
 
    private ZfIdGenerator(long workId) {
        if (workId > MAX_WORK_NUM || workId <= 0) {
            throw  new RuntimeException("workdId的值設置錯誤");
        }
        this.workId = workId;
    }
 
    /**
     * 生成id
     * @return
     */
    public synchronized long nextId() {
        long currStmp = System.currentTimeMillis();
        if (currStmp < START_TIME_MILLIS) {
            throw new RuntimeException("機器時間存在問題，請注意查看");
        }
 
        if (currStmp == lastStmp) {
            sequence =  (sequence + 1) & MAX_SEQUENCE;
            if (sequence == 0L) {
                currStmp = getNextMillis(currStmp);
            }
        } else {
            sequence = 0L;
        }
        lastStmp = currStmp;
 
        return ((currStmp - START_TIME_MILLIS) << TIMESTMP_SHIFT)
                | (workId << WORKID_SHIFT)
                | (sequence);
    }
 
    public long getNextMillis(long currStmp) {
        long millis = System.currentTimeMillis();
        while (millis <= currStmp) {
            millis = System.currentTimeMillis();
        }
        return millis;
    }
 
    /**
     * 獲取最大的工作數量
     * @return
     */
    public static long getMaxWorkNum() {
        return MAX_WORK_NUM;
    }
 
    public static void main(String[] args) {
        ZfIdGenerator idGenerator1 = ZfIdGenerator.getDistributedIdGenerator(1);
//        ZfIdGenerator idGenerator2 = ZfIdGenerator.getDistributedIdGenerator(2);
        for (int i = 0; i < 1000000; i++) {
            System.out.println(idGenerator1.nextId());
        }
 
//        System.out.println(idGenerator2.nextId());
 
 
 
    }
 
}

 

分布式情況
上面的ID生成器在單機情況下使用沒有問題，但如果在分布下使用，就需要分配不同的workId,如果workId相同，可能會導致生成的id相同。

解決方案：

1、使用java環境變量，人為通過-D預先設置workid.這種方案簡單，不會出現重復情況，但需要每個服務的啟動腳本不同.

2、使用sharding-jdbc中的算法，使用IP后幾位來做workId,這種方案也很簡單，不需要修改服務的啟動腳本,但在某些情況下會出現生成重復ID的情況，詳細見我下面的參考資料

3、使用zk，在啟動時給每個服務分配不同的workId,缺點：多了依賴，需要zk,優點:不會出現重復情況，且不需要修改服務的啟動腳本。這個是我個人使用的方案，實現思路為，系統啟動時創建一個永久性的結點(zookeeper保證原子性),然后在這個永久性的節點下，遍歷workId去zookeeper創建臨時結點，zookeeper會保證相同路徑只會有一個可能創建成功，如果創建失敗繼續遍歷即可。詳細可看一下代碼

實例化ID生成器如下(Spring boot項目):

 
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.SpringBootConfiguration;
import org.springframework.context.annotation.Bean;
 
/**
 * <p>TODO</p>
 * <p>
 * <PRE>
 * <BR>    修改記錄
 * <BR>-----------------------------------------------
 * <BR>    修改日期         修改人          修改內容
 * </PRE>
 *
 * @author cuiyh9
 * @version 1.0
 * @Date Created in 2018年11月30日 16:37
 * @since 1.0
 */
@Slf4j
@SpringBootConfiguration
public class IdGeneratorConfig {
 
    @Autowired
    private ZkClient zkClient;
 
    @Value("${idgenerator.zookeeper.parent.path}")
    private String IDGENERATOR_PARENT_PATH;
 
    @Bean
    public ZfIdGenerator idGenerator() {
        boolean flag = zkClient.createParent(IDGENERATOR_PARENT_PATH);
        if (!flag) {
            throw new RuntimeException("創建發號器父節點失敗");
        }
 
        // 獲取workId
        long workId = 0;
        long maxWorkNum = ZfIdGenerator.getMaxWorkNum();
        for (long i = 1; i < maxWorkNum; i++) {
            String workPath = IDGENERATOR_PARENT_PATH + "/" + i;
            flag = zkClient.createNotExistEphemeralNode(workPath);
            if (flag) {
                workId =  i;
                break;
            }
        }
 
        if (workId == 0) {
            throw new RuntimeException("獲取機器id失敗");
        }
        log.warn("idGenerator workId:{}", workId);
        return ZfIdGenerator.getDistributedIdGenerator(workId);
 
    }
}

ZkClient代碼(基於apache curator)

注意apache curator版本，我最初使用的是4.x版本，程序執行到forPath()方法就會阻塞，后來查到是與zookeeper版本不匹配導致.

 
import lombok.extern.slf4j.Slf4j;
import org.apache.curator.framework.CuratorFramework;
import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.KeeperException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
 
/**
 * <p>TODO</p>
 * <p>
 * <PRE>
 * <BR>    修改記錄
 * <BR>-----------------------------------------------
 * <BR>    修改日期         修改人          修改內容
 * </PRE>
 *
 * @author cuiyh9
 * @version 1.0
 * @Date Created in 2018年11月30日 16:36
 * @since 1.0
 */
@Slf4j
@Component
public class ZkClient {
 
    @Autowired
    private CuratorFramework client;
 
    /**
     * 創建父節點，創建成功或存在都返回成功
     * @param path
     * @return
     */
    public boolean createParent(String path) {
        try {
            client.create().creatingParentsIfNeeded().forPath(path);
            return true;
        } catch (KeeperException.NodeExistsException e) {
            return true;
        } catch (Exception e) {
            log.error("createParent fail path:{}", path, e);
        }
        return false;
    }
 
    /**
     * 創建不存在的節點。如果存在或創建失敗，返回false
     * @param path
     * @throws Exception
     */
    public boolean createNotExistEphemeralNode(String path) {
        try {
            client.create().withMode(CreateMode.EPHEMERAL).forPath(path);
            return true;
        } catch (KeeperException.NodeExistsException e) {
            return false;
        }  catch (Exception e) {
            log.error("createNotExistNode fail path:{}", path, e);
        }
        return false;
    }
}