SpringBoot集成yitter-idgenerator(雪花漂移)分布式Id自增的实现

场景

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);
        }

    }
}

直接在代码使用即可