redis业务场景之生成流水号

直接上代码

BaseRedisCode类相当于将需要生成流水号的业务类的相应配置存储在redis中，生成流水号时先去获取配置，按照配置生成。

@Data
public class BaseRedisCode {
    // 流水号生成依赖的类，会使用类的名称作为redis的key
    private Class entity;
    // 前缀
    private String prefix;
    // 自增数位数 自增数达不到此位数自动补零
    private Integer num;

    public BaseRedisCode(Class entity, String prefix, Integer num) {
        this.entity = entity;
        this.prefix = prefix;
        this.num = num;
    }
}

@Component
@Slf4j
public class RedisCodeInit implements ApplicationRunner {
    @Autowired
    private RedisTemplate<String, String> redisTemplate;

    @Override
    public void run(ApplicationArguments args) throws Exception {
        log.info("=====开始初始化流水号=====");
        List<BaseRedisCode> baseRedisCodes = new ArrayList<>();
        baseRedisCodes.add(new BaseRedisCode(Account.class, "AC", 6));
        baseRedisCodes.add(new BaseRedisCode(Order.class, "OR", 8));
        this.init(baseRedisCodes);
        log.info("=====初始化流水号完毕=====");
    }

    public void init(List<BaseRedisCode> baseRedisCodes) {
        // 流水号初始化入缓存
        for (BaseRedisCode baseRedisCode : baseRedisCodes) {
            String redisKey = baseRedisCode.getEntity().getName();
            // 存入缓存 key：key：实体类名称 value：流水号数据（前缀、自增数位数）
            redisTemplate.opsForValue().set(baseRedisCode.getEntity().getName(), JSON.toJSONString(baseRedisCode));
            log.info(redisKey + "已初始化");
        }
    }
}

初始化后redis中的数据是这样的，圈起来的地方存储的就是BaseRedisCode对象信息，也就是相关业务的流水号配置信息。

@Component
public class RedisCodeUtil {
    @Autowired
    private RedisTemplate<String, String> redisTemplate;

    public String gen(Class c) {
        // 获取实体类的名称
        String redisKey = c.getName();
        // 判断是不是有初始化此实体类
        if (null != redisTemplate.opsForValue().get(redisKey)) {
            // 从缓存获取流水号的生成信息
//            JSONObject json = JSONObject.parseObject(redisTemplate.opsForValue().get(redisKey));
//            BaseRedisCode baseRedisCode = JSON.toJavaObject(json, BaseRedisCode.class);
            BaseRedisCode baseRedisCode = JSON.parseObject(redisTemplate.opsForValue().get(redisKey), BaseRedisCode.class);
            // 根据流水号的前缀判断今天是否有生成过流水号
            assert baseRedisCode != null;
            if (redisTemplate.opsForValue().get(baseRedisCode.getPrefix()) == null) {
                // 没有则新建一个存入缓存 格式（key:OR  value:0）
                // 设置到第二天早上00：00：01过期
                Long todayTime = LocalDate.now().plusDays(1).atTime(0, 0, 0, 1).atOffset(ZoneOffset.ofHours(8)).toEpochSecond();
                Long nowTime = LocalDateTime.now().atOffset(ZoneOffset.ofHours(8)).toEpochSecond();
                long expireTime = todayTime - nowTime;
                redisTemplate.opsForValue().set(baseRedisCode.getPrefix(), String.valueOf(0), expireTime * 1000, TimeUnit.MILLISECONDS);
            }

            StringBuilder sn = new StringBuilder();
            // 和前缀、时间、随机数进行组合
            sn.append(baseRedisCode.getPrefix());
            String date = LocalDate.now().format(DateTimeFormatter.ofPattern("yyyyMMdd"));
            sn.append(date);
            // 进行自增操作，以增量的方式更新key
            Long num = redisTemplate.opsForValue().increment(baseRedisCode.getPrefix());
            sn.append(addZero(String.valueOf(num), baseRedisCode.getNum()));
            // 三位随机数补在尾部，可以不要
//            String random = String.valueOf(new Random().nextInt(1000));
//            sn.append(random);
            // 生成最终的流水号返回
            return (sn.toString());
        }
        return null;
    }

    // 自动补零
    public String addZero(String numStr, Integer maxNum) {
        int addNum = maxNum - numStr.length();
        StringBuilder rStr = new StringBuilder();
        for (int i = 0; i < addNum; i++) {
            rStr.append("0");
        }
        rStr.append(numStr);
        return rStr.toString();
    }
}

测试

@RunWith(SpringRunner.class)
@SpringBootTest(classes = SzjxApplication.class)
public class Test1 {
    @Autowired
    private RedisCodeUtil redisCodeUtil;

    @Test
    public void set(){
        System.out.println(redisCodeUtil.gen(Order.class));
    }
}

最后流水号以前缀为key的方式存储