# 給key為GENERATEID:NO的value自增1，如果這key不存在則會(huì)添加到Redis中并且設(shè)置value為1
## GENERATEID：key前綴
## NO：訂單ID標(biāo)識(shí)
127.0.0.1:6379> incr GENERATEID:NO
(integer) 1

# 給key為GENERATEID，field為no的value自增1，如果這key不存在則會(huì)添加到Redis中并且設(shè)置value為1
## GENERATEID：分布式全局唯一ID Hash key
## NO：Hash結(jié)構(gòu)中的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數(shù)據(jù)庫索引（默認(rèn)為0）
    database: 0
    ## Redis服務(wù)器地址
    host: 127.0.0.1
    ## Redis服務(wù)器連接端口
    port: 6379
    ## Redis服務(wù)器連接密碼（默認(rèn)為空）
    password:
    ## 連接超時(shí)時(shí)間（毫秒）
    timeout: 1200
    lettuce:
      pool:
        ## 連接池最大連接數(shù)（使用負(fù)值表示沒有限制）
        max-active: 8
        ## 連接池最大阻塞等待時(shí)間（使用負(fù)值表示沒有限制）
        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 業(yè)務(wù)標(biāo)識(shí)key
     */
    public String generateId(String key) {
        // 獲取對(duì)應(yīng)業(yè)務(wù)自增序列
        Long incr = getIncr(key);
        // 組裝最后的結(jié)果，這里可以根據(jù)需要自己定義，這里是按照業(yè)務(wù)標(biāo)識(shí)key+當(dāng)前時(shí)間戳+自增序列進(jìn)行組裝
        String resultID = key + System.currentTimeMillis() + "-" + incr;
        return resultID;
    }

    /**
     * 獲取對(duì)應(yīng)業(yè)務(wù)自增序列
     */
    private Long getIncr(String key) {
        String cacheKey = getCacheKey(key);
        Long increment = 0L;
        // 判斷Redis中是否存在這個(gè)自增序列，如果不存在添加一個(gè)序列并且設(shè)置一個(gè)過期時(shí)間
        if (!redisTemplate.hasKey(cacheKey)) {
            // 這里存在線程安全問題，需要加分布式鎖，這里做簡(jiǎn)單實(shí)現(xiàn)
            String lockKey = cacheKey + "_LOCK";
            // 設(shè)置分布式鎖
            boolean lock = redisTemplate.opsForValue().setIfAbsent(lockKey, 1, 30, TimeUnit.SECONDS);
            if (!lock) {
                // 如果沒有拿到鎖進(jìn)行自旋
                return getIncr(key);
            }
            increment = redisTemplate.opsForValue().increment(cacheKey);
            // 我這里設(shè)置24小時(shí)，可以根據(jù)實(shí)際情況設(shè)置當(dāng)前時(shí)間到當(dāng)天結(jié)束時(shí)間的插值
            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();
    }

    /**
     * 獲取當(dāng)前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 {
        // 定義一個(gè)線程池 設(shè)置核心線程數(shù)和最大線程數(shù)都為100，隊(duì)列根據(jù)需要設(shè)置
        ThreadPoolExecutor executor = new ThreadPoolExecutor(100, 100, 10, TimeUnit.SECONDS, new LinkedBlockingQueue<>(10000));
        CountDownLatch countDownLatch = new CountDownLatch(10000);

        long beginTime = System.currentTimeMillis();
        // 獲取10000個(gè)全局唯一ID 看看是否有重復(fù)
        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("獲取單個(gè)ID耗時(shí) time=" + (System.currentTimeMillis() - beginTime02));
                if (ids.contains(orderNo)) {
                    System.out.println("重復(fù)ID=" + orderNo);
                } else {
                    ids.add(orderNo);
                }
                countDownLatch.countDown();
            });
        }
        countDownLatch.await();
        // 打印獲取到的全局唯一ID集合數(shù)量
        System.out.println("獲取到全局唯一ID count=" + ids.size());
        System.out.println("耗時(shí)毫秒 time=" + (System.currentTimeMillis() - beginTime));
    }
}