redis实现分布式全局唯一id的示例代码

# 给key为generateid:no的value自增1，如果这key不存在则会添加到redis中并且设置value为1
## generateid：key前缀
## no：订单id标识
127.0.0.1:6379> incr generateid:no
(integer) 1

# 给key为generateid，field为no的value自增1，如果这key不存在则会添加到redis中并且设置value为1
## generateid：分布式全局唯一id hash key
## no：hash结构中的field
127.0.0.1:6379> hincrby generateid no 1
(integer) 1

<dependency>
    <groupid>org.springframework.boot</groupid>
    <artifactid>spring-boot-starter-data-redis</artifactid>
</dependency>

<dependency>
    <groupid>junit</groupid>
    <artifactid>junit</artifactid>
    <version>4.13.1</version>
    <scope>test</scope>
</dependency>

<dependency>
    <groupid>com.fasterxml.jackson.core</groupid>
    <artifactid>jackson-databind</artifactid>
    <version>2.15.2</version>
</dependency>

spring:
  #redis配置信息
  redis:
    ## redis数据库索引（默认为0）
    database: 0
    ## redis服务器地址
    host: 127.0.0.1
    ## redis服务器连接端口
    port: 6379
    ## redis服务器连接密码（默认为空）
    password:
    ## 连接超时时间（毫秒）
    timeout: 1200
    lettuce:
      pool:
        ## 连接池最大连接数（使用负值表示没有限制）
        max-active: 8
        ## 连接池最大阻塞等待时间（使用负值表示没有限制）
        max-wait: -1
        ## 连接池中的最大空闲连接
        max-idle: 8
        ## 连接池中的最小空闲连接
        min-idle: 1

@configuration
public class redisconfig {

    //编写我们自己的配置redistemplate
    @bean
    @suppresswarnings("all")
    public redistemplate<string, object> redistemplate(redisconnectionfactory redisconnectionfactory) {
        redistemplate<string, object> template = new redistemplate<>();
        template.setconnectionfactory(redisconnectionfactory);

        // json序列化配置
        jackson2jsonredisserializer jsonredisserializer=new jackson2jsonredisserializer(object.class);
        objectmapper objectmapper=new objectmapper();
        objectmapper.setvisibility(propertyaccessor.all, jsonautodetect.visibility.any);
        objectmapper.enabledefaulttyping(objectmapper.defaulttyping.non_final);
        jsonredisserializer.setobjectmapper(objectmapper);

        // string的序列化
        stringredisserializer stringredisserializer=new stringredisserializer();

        //key和hash的key都采用string的序列化方式
        template.setkeyserializer(stringredisserializer);
        template.sethashkeyserializer(stringredisserializer);

        //value和hash的value都采用jackson的序列化方式
        template.setvalueserializer(jsonredisserializer);
        template.sethashvalueserializer(jsonredisserializer);

        template.afterpropertiesset();

        return template;
    }
}

@component
public class redisgenerateidutils {

    @resource
    private redistemplate<string, object> redistemplate;
    // key前缀
    private string prefix = "generateid:";

    /**
     * 获取全局唯一id
     * @param key 业务标识key
     */
    public string generateid(string key) {
        // 获取对应业务自增序列
        long incr = getincr(key);
        // 组装最后的结果，这里可以根据需要自己定义，这里是按照业务标识key+当前时间戳+自增序列进行组装
        string resultid = key + system.currenttimemillis() + "-" + incr;
        return resultid;
    }

    /**
     * 获取对应业务自增序列
     */
    private long getincr(string key) {
        string cachekey = getcachekey(key);
        long increment = 0l;
        // 判断redis中是否存在这个自增序列，如果不存在添加一个序列并且设置一个过期时间
        if (!redistemplate.haskey(cachekey)) {
            // 这里存在线程安全问题，需要加分布式锁，这里做简单实现
            string lockkey = cachekey + "_lock";
            // 设置分布式锁
            boolean lock = redistemplate.opsforvalue().setifabsent(lockkey, 1, 30, timeunit.seconds);
            if (!lock) {
                // 如果没有拿到锁进行自旋
                return getincr(key);
            }
            increment = redistemplate.opsforvalue().increment(cachekey);
            // 我这里设置24小时，可以根据实际情况设置当前时间到当天结束时间的插值
            redistemplate.expire(cachekey, 24, timeunit.hours);

            // 释放锁
            redistemplate.delete(lockkey);
        } else {
            increment = redistemplate.opsforvalue().increment(cachekey);
        }

        return increment;
    }

    /**
     * 组装缓存key
     */
    private string getcachekey(string key) {
        return prefix + key + ":" + getyyyymmdd();
    }

    /**
     * 获取当前yyyymmdd格式年月日
     */
    private string getyyyymmdd() {
        localdate currentdate = localdate.now();
        int year = currentdate.getyear();
        int month = currentdate.getmonthvalue();
        int day = currentdate.getdayofmonth();
        return "" + year + month + day;
    }
}

@runwith(springrunner.class)
@springboottest(classes = redisuniqueiddemoapplication.class)
class redisuniqueiddemoapplicationtests {

    @resource
    private redisgenerateidutils redisgenerateidutils;
    

    @test
    public void test() throws interruptedexception {
        // 定义一个线程池 设置核心线程数和最大线程数都为100，队列根据需要设置
        threadpoolexecutor executor = new threadpoolexecutor(100, 100, 10, timeunit.seconds, new linkedblockingqueue<>(10000));
        countdownlatch countdownlatch = new countdownlatch(10000);

        long begintime = system.currenttimemillis();
        // 获取10000个全局唯一id 看看是否有重复
        copyonwritearrayset<string> ids = new copyonwritearrayset<>();
        for (int i = 0; i < 10000; i++) {
            executor.execute(() -> {
                // 获取全局唯一id
                long begintime02 = system.currenttimemillis();
                string orderno = redisgenerateidutils.generateid("no");
                system.out.println(orderno);
                system.out.println("获取单个id耗时 time=" + (system.currenttimemillis() - begintime02));
                if (ids.contains(orderno)) {
                    system.out.println("重复id=" + orderno);
                } else {
                    ids.add(orderno);
                }
                countdownlatch.countdown();
            });
        }
        countdownlatch.await();
        // 打印获取到的全局唯一id集合数量
        system.out.println("获取到全局唯一id count=" + ids.size());
        system.out.println("耗时毫秒 time=" + (system.currenttimemillis() - begintime));
    }
}