【实战系列】16位唯一id设计方案

ID组成部分

第一部分：yyMMddHHmm，10位
第二部分：自增序列，从0开始，最大到999999，6位

由于时间是精确到分钟，所以1分钟内只能生成999999个ID，不过我们可以借助Redis来计数，实现1分钟内超过999999个ID，就将时间跳到下一分钟，但因此也就不能光从ID上来判定生成的时间。

代码实现

import org.apache.commons.lang3.StringUtils;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.core.RedisTemplate;

import javax.annotation.Resource;
import java.io.Serializable;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoUnit;
import java.util.Date;
import java.util.UUID;
import java.util.concurrent.TimeUnit;

import static java.time.format.DateTimeFormatter.ofPattern;

@Configuration
public class Demo {

    @Resource
    private RedisTemplate<String, Serializable> redisTemplate;

    public static String getUUID() {
        return UUID.randomUUID().toString();
    }

    /**
     * 16位唯一ID，支持100年不重复
     * <p>
     * 两部分组成
     * 1. yyMMddHHmm
     * 2. 自增序列，从0开始，最大到999999
     * <p>
     * 1分钟内最多支持生成999999个ID，如果超过这个数，则跳到下一分钟
     *
     * @return
     * @throws Exception
     */
    public String getId() throws Exception {
        String formatMin = LocalDateTime.now().format(ofPattern("yyyyMMddHHmm"));
        String now = LocalDateTime.now().format(ofPattern("yyyy-MM-dd HH:mm:ss"));
        return generator(formatMin, now);
    }

    private String generator(String formatMin, String now) throws Exception {
        String key = "ID_GENERATOR_" + formatMin;
        Long increment = redisTemplate.boundValueOps(key).increment();
        if (increment == null) {
            throw new Exception("redis increment异常！");
        }
        // 如果1分钟超过999999个ID，则跳到下一分钟
        if (increment > 999999) {
            // 当前时间加1分钟
            String nextMin = plusMin(now, 1, ofPattern("yyyy-MM-dd HH:mm:ss"));
            String formatNextMin = changeFormat(nextMin, "yyyy-MM-dd HH:mm:ss", "yyyyMMddHHmm");
            // 递归取下一份
            return generator(formatNextMin, nextMin);
        }

        // 如果increment==1，则表示在当前分钟内第一次获取ID，所以开始计数
        if (increment == 1) {
            redisTemplate.boundValueOps(key).expire(60, TimeUnit.SECONDS);
        }

        // yyMMddHHmm拼上increment，increment不足6位则补0
        return formatMin + StringUtils.leftPad(String.valueOf(increment), 6, "0");
    }

    public static String plusMin(String time, int minutes, DateTimeFormatter formatter) {
        return LocalDateTime.parse(time, ofPattern("yyyy-MM-dd HH:mm:ss")).plus(minutes, ChronoUnit.MINUTES).format(formatter);
    }

    public static String changeFormat(String date, String originalFormat, String newFormat) {
        LocalDateTime localDateTime = LocalDateTime.parse(date, ofPattern(originalFormat));
        return formatDate(LocalDateUtils.localDateTimeToDate(localDateTime), newFormat);
    }

    public static String formatDate(Date date, String format) {
        LocalDateTime localDateTime = dateToLocalDateTime(date);
        return localDateTime.format(ofPattern(format));
    }

    public static LocalDateTime dateToLocalDateTime(Date date) {
        return date.toInstant().atZone(ZoneId.systemDefault()).toLocalDateTime();
    }
}

测试1分钟只能生成10个id，看一下最终生成id的效果。

// 这块修改为increment > 10
 if (increment > 10) {
            // 当前时间加1分钟
            String nextMin = plusMin(now, 1, ofPattern("yyyy-MM-dd HH:mm:ss"));
            String formatNextMin = changeFormat(nextMin, "yyyy-MM-dd HH:mm:ss", "yyyyMMddHHmm");
            // 递归取下一份
            return generator(formatNextMin, nextMin);
        }

import lombok.extern.slf4j.Slf4j;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import javax.annotation.Resource;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

@RunWith(SpringJUnit4ClassRunner.class)
@Slf4j
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
public class IdGeneratorUtilTest {

    Map<String, String> map = new HashMap<>();

    @Resource
    private IdGeneratorUtil idGeneratorUtil;

    @Test
    public void test() throws Exception {
        ExecutorService executorService = Executors.newFixedThreadPool(1);
        // 应该会跨越10分钟
        for (int i = 0; i < 100; i++) {
            executorService.execute(() -> {
                String id = null;
                try {
                    // 假设我们控制1分钟内只能生成10个ID
                    id = idGeneratorUtil.getId();
                } catch (Exception e) {
                    e.printStackTrace();
                }
                map.put(id, id);
            });
        }
        // 等2秒数据生成
        Thread.sleep(2000);
        
        // map中应有100个id
        System.out.println(map.size());

        // 查看生成的id，1分钟内最多生成了10个，超过10个就跳下一分钟
        map.keySet().forEach(System.out::println);

    }
}