首頁 > 軟體

SpringBoot整合yitter-idgenerator(雪花漂移)分散式Id自增的實現

2022-01-14 19:01:17

場景

yitter-idgenerator 是基於雪花演演算法進行改造的分散式ID自增演演算法,整合時需要為每個服務設定唯一的機器號,才能保證生成的Id不會重複

實現方案

基於服務啟動時指定唯一機器號

在程式服務啟動時通過分散式鎖 Redisson(基於Redis實現),對每臺機器通過IP 對應一個 唯一的機器號(自增)對映,並儲存在Redis中。快取一次後,下次啟動直接讀取快取即可

基於註冊中心指定唯一機器號

從註冊中心讀取服務,增加多一個機器號服務來統一分配

基於第一種實現方案

Maven依賴

       <dependency>
            <groupId>org.redisson</groupId>
            <artifactId>redisson-spring-boot-starter</artifactId>
            <version>3.10.6</version>
        </dependency> 
		<dependency>
		    <groupId>cn.hutool</groupId>
		    <artifactId>hutool-core</artifactId>
		    <version>5.7.19</version>
		</dependency>
        <dependency>
            <groupId>com.github.yitter</groupId>
            <artifactId>yitter-idgenerator</artifactId>
            <version>1.0.6</version>
        </dependency>

關鍵部分程式碼

/**
 * Redisson分散式鎖工具類
 */
@Component
public class RedissonUtil {

    @Autowired
    private RedissonClient redissonClient;

    /**
     * 加鎖
     * @param lockKey
     * @return
     */
    public RLock lock(String lockKey) {
        RLock lock = redissonClient.getLock(lockKey);
        lock.lock();
        return lock;
    }

    /**
     * 帶超時的鎖
     * @param lockKey
     * @param timeout 超時時間 單位:秒
     */
    public RLock lock(String lockKey, long timeout) {
        RLock lock = redissonClient.getLock(lockKey);
        lock.lock(timeout, TimeUnit.SECONDS);
        return lock;
    }

    /**
     * 帶超時的鎖
     * @param lockKey
     * @param unit 時間單位
     * @param timeout 超時時間
     */
    public RLock lock(String lockKey, TimeUnit unit ,long timeout) {
        RLock lock = redissonClient.getLock(lockKey);
        lock.lock(timeout, unit);
        return lock;
    }

    /**
     * 嘗試獲取鎖
     * @param lockKey
     * @param waitTime 最多等待時間
     * @param unit TimeUnit時間單位
     * @return
     */
    public  boolean tryLock(String lockKey,long waitTime, TimeUnit unit) {
        RLock lock = redissonClient.getLock(lockKey);
        try {
            return lock.tryLock(waitTime, unit);
        } catch (InterruptedException e) {
            return false;
        }
    }

    /**
     * 嘗試獲取鎖
     * @param lockKey
     * @param waitTime 最多等待時間
     * @param leaseTime 上鎖後自動釋放鎖時間
     * @return
     */
    public  boolean tryLock(String lockKey, long waitTime, long leaseTime) {
        RLock lock = redissonClient.getLock(lockKey);
        try {
            return lock.tryLock(waitTime, leaseTime, TimeUnit.SECONDS);
        } catch (InterruptedException e) {
            return false;
        }
    }

    /**
     * 嘗試獲取鎖
     * @param lockKey
     * @param unit 時間單位
     * @param waitTime 最多等待時間
     * @param leaseTime 上鎖後自動釋放鎖時間
     * @return
     */
    public boolean tryLock(String lockKey, TimeUnit unit, long waitTime, long leaseTime) {
        RLock lock = redissonClient.getLock(lockKey);
        try {
            return lock.tryLock(waitTime, leaseTime, unit);
        } catch (InterruptedException e) {
            return false;
        }
    }

    /**
     * 釋放鎖
     * @param lockKey
     */
    public void unlock(String lockKey) {
        RLock lock = redissonClient.getLock(lockKey);
        lock.unlock();
    }

    /**
     * 若沒用鎖情況下,就不呼叫釋放鎖的程式碼,若有鎖情況下才呼叫釋放鎖
     * @param lockKey
     */
    public void unlockIgnore(String lockKey) {
        RLock lock = redissonClient.getLock(lockKey);
        if ( !lock.isLocked() ) {
           return ;
        }
        lock.unlock();
    }


    /**
     * 釋放鎖
     * @param lock
     */
    public void unlock(RLock lock) {
        lock.unlock();
    }

}

啟動設定程式碼如下

 
@Slf4j
@Component
@Order(0)
public class SystemInitConfig implements CommandLineRunner {

    @Autowired
    private RedissonUtil redissonUtil;

    @Autowired
    private RedisTemplate redisTemplate;

    /**
     * 分散式鎖Key
     */
    private static final String CACHE_ID_GENERATOR = "LOCK_ID_GENERATOR";

    /**
     * 最大機器號Key
     */
    private static final String CACHE_WORKERID_MAXID= "CACHE_WORKERID_MAXID";

    /**
     * 已分配的機器號Key
     */
    private static final String CACHE_ID_IP = "CACHE_ID_IP";

    @Override
    public void run(String... args) throws Exception {
        //獲取mac地址
        String macAddress = NetUtil.getLocalhost().getHostAddress();
        log.info("{} 設定分散式Id Work快取========開始",macAddress);
        boolean existWorkerId =  redisTemplate.opsForHash().hasKey(CACHE_ID_IP, macAddress);
        //若已快取在快取中,直接跳過不設定
        if (existWorkerId) {
            log.info("{} 已設定分散式Id Work...",macAddress);
            return ;
        }
        try {
            //分散式鎖等待120秒,執行時長最大120秒
            boolean  locked = redissonUtil.tryLock(CACHE_ID_GENERATOR, 120, 120);
            if (!locked) {
                throw new RuntimeException(macAddress+"設定分散式Id機器號失敗");
            }
            ValueOperations <String,Integer> stringOperation = redisTemplate.opsForValue();
            boolean initWorkerId = stringOperation.setIfAbsent(CACHE_WORKERID_MAXID, 1);
            if( !initWorkerId ) {
                //若已存在key,對最大的機器號自增1
                stringOperation.increment(CACHE_WORKERID_MAXID);
            }
            Integer workerId =   stringOperation.get(CACHE_WORKERID_MAXID);
            IdGeneratorOptions options = new IdGeneratorOptions( workerId.shortValue());
            YitIdHelper.setIdGenerator(options);
            //設定mac地址 - workerid 到hash結構
            redisTemplate.opsForHash().put(CACHE_ID_IP,macAddress,workerId);
            log.info("已設定分散式Id Work,{} - {}",macAddress,workerId);
        } finally {
            redissonUtil.unlock(CACHE_ID_GENERATOR);
            log.info("{} 設定分散式Id Work快取========結束",macAddress);
        }

    }
}

直接在程式碼使用即可

YitIdHelper.nextId() 

到此這篇關於SpringBoot整合yitter-idgenerator(雪花漂移)分散式Id自增的實現的文章就介紹到這了,更多相關SpringBoot 分散式Id自增內容請搜尋it145.com以前的文章或繼續瀏覽下面的相關文章希望大家以後多多支援it145.com!


IT145.com E-mail:sddin#qq.com