redis实现生成自增编码两种方式

已于 2023-05-09 16:02:45 修改
阅读量1.5k 收藏 2
点赞数 1
文章标签： redis java 后端 缓存
于 2023-04-18 17:30:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/MS_SONG/article/details/130226992
版权

文章目录

思路：都是从缓存中取，取出来+1 再放入缓存，以便下次取用
区别：方式一，手动+1； 方式二：利用 redis.increment 实现自增；
提示：写业务代码时，记得加锁，锁中包含事务；

方式一


    /**
     * 生成经销商任务单号
     *
     * @param custTaskType 经销商任务单类型
     * @return 结果
     */
    @Override
    public ServiceResponse generateCustTaskIdByTaskType(String custTaskType) {
        if (StringUtils.isEmpty(custTaskType)){
            return ServiceResponse.fail("经销商-传入空任务单类型！");
        }
        if (!(custTaskType.toUpperCase().equals(WorkTaskType.客户上市.value())
            || custTaskType.toUpperCase().equals(WorkTaskType.客户基础信息变更.value())
            || custTaskType.toUpperCase().equals(WorkTaskType.客户更名.value())
            || custTaskType.toUpperCase().equals(WorkTaskType.客户扩充.value())
            || custTaskType.toUpperCase().equals(WorkTaskType.基地对外客户上市.value()))){
            return ServiceResponse.fail("经销商-传入任务单类型异常！");
        }
        // 生成编码
        String custTaskId;
        String today = new SimpleDateFormat("yyyyMMdd").format(new Date());
        String upCustTaskType = custTaskType.toUpperCase();
        String custTaskNoKey = "cust:" + "work_task_no_key" + today + ":" + upCustTaskType;
        Long taskSerialNo = Convert.toLong(redisTemplate.opsForValue().get(custTaskNoKey));
        if (null != taskSerialNo){
            taskSerialNo = taskSerialNo + 1L;
        }else {
            String firstCustTaskId = upCustTaskType + today + "0001";
            if (null == tnWorkTaskMapper.selectTnWorkTaskByTaskId(firstCustTaskId)){
                taskSerialNo = 1L;
            }else {
                // 缓存被意外删除
                List<TnWorkTask> tnWorkTaskList = tnWorkTaskMapper.selectTnWorkTaskList(new TnWorkTask(){{ setTaskType(upCustTaskType);}});
                List<Long> longList = new ArrayList<>();
                tnWorkTaskList.stream().map(TnWorkTask::getTaskId).forEach(e -> longList.add( Convert.toLong(e.substring(12))));
                Long lastTaskNo = longList.stream().sorted(Comparator.reverseOrder()).collect(Collectors.toList()).get(0);
                taskSerialNo = lastTaskNo + 1L;
            }
        }
        custTaskId = upCustTaskType + today + (taskSerialNo.toString().length() < 4 ? String.format("%04d", taskSerialNo) : taskSerialNo.toString());
        // 校验
        if (null != tnWorkTaskMapper.selectTnWorkTaskByTaskId(custTaskId)){
            return ServiceResponse.fail("经销商-生成任务单号已存在！");
        }
        redisTemplate.opsForValue().set(custTaskNoKey, taskSerialNo, getSeconds(), TimeUnit.SECONDS);
        return ServiceResponse.success(custTaskId);
    }

    /**
     * 获取当天结束还剩余多少秒
     * @return
     */
    public static int getSeconds(){
        Calendar curDate = Calendar.getInstance();
        Calendar tommorowDate = new GregorianCalendar(
                curDate.get(Calendar.YEAR),
                curDate.get(Calendar.MONTH),
                curDate.get(Calendar.DATE) + 1,
                0, 0, 0);
        return (int)(tommorowDate.getTimeInMillis() - curDate.getTimeInMillis()) / 1000;
    }

方式二


    /**
     * 生成经销商客户编码
     *
     * @param
     * @return 结果
     */
    @Override
    public ServiceResponse generateCustAccCode() {
        String accCodeKey = "cust:" + "account_code_no_key" ;
        Integer accCode = (Integer) redisTemplate.opsForValue().get(accCodeKey);
        if (null == accCode)
        {
            List<String> accCodes = tnMdCustBaseMapper.selectTnMdCustBaseList(null).stream().map(TnMdCustBase::getAcctCode).collect(Collectors.toList());
            if (!CollectionUtils.isEmpty(accCodes)){
                List<Integer> codeList = new ArrayList<>();
                accCodes.forEach(e -> codeList.add(Integer.parseInt(e)));
                Integer lastAccCode = codeList.stream().sorted(Comparator.reverseOrder()).collect(Collectors.toList()).get(0);
                redisTemplate.opsForValue().set(accCodeKey, lastAccCode);
            }
        }
        accCode = Math.toIntExact(redisTemplate.opsForValue().increment(accCodeKey, 1));
        // 校验
        Integer finalAccCode = accCode;
        if (!CollectionUtils.isEmpty(tnMdCustBaseMapper.selectTnMdCustBaseList(new TnMdCustBase(){{ setAcctCode(finalAccCode.toString());}}))){
            return ServiceResponse.fail("生成失败，客户编码已存在！");
        }
        return ServiceResponse.success(finalAccCode);
    }

推荐：
高并发redis自增increment使用

生成编码时处理并发+事务实际场景

提交工作单时，生成编码，保存提交数据

    /**
     * 提交工作任务单
     *
     * @param custWorkTaskInfoPO
     * @return
     */
    public ServiceResponse submitCTDJCustWorkInfo(CustWorkTaskInfoPO custWorkTaskInfoPO);
    
    /**
     * 保存任务单详情
     *
     * @param custWorkTaskInfoPO
     * @return 结果
     */
    public ServiceResponse saveCTDJCustWorkInfo(CustWorkTaskInfoPO custWorkTaskInfoPO);
    
    /**
     * 处理工作任务单
     *
     * @param tnWorkTask
     * @return 结果
     */
    public ServiceResponse  handleCustCTDJWorkTask(TnWorkTask tnWorkTask) throws Exception;

    /**
     * 处理任务单详情
     *
     * @param custWorkTaskInfoPO
     * @return 结果
     */
    public int handleCTDJCustWorkInfoDetail(CustWorkTaskInfoPO custWorkTaskInfoPO);

    /**
     * 生成经销商任务单号
     *
     * @param custTaskType 经销商任务单类型
     * @return 结果
     */
    public ServiceResponse generateCustTaskIdByTaskType(String custTaskType);




    @Override
    @Transactional(rollbackFor = Exception.class)
    public ServiceResponse submitCTDJCustWorkInfo(CustWorkTaskInfoPO custWorkTaskInfoPO){
        ServiceResponse serviceResponse;
        try {
            serviceResponse = saveCTDJCustWorkInfo(custWorkTaskInfoPO);
        } catch (Exception e) {
            e.printStackTrace();
            log.warn("经销商-客户冻结-提交时保存异常", e);
            throw new RuntimeException(e);
        }
        if (serviceResponse.ok()){
            String taskId = custWorkTaskInfoPO.getTnWorkTask().getTaskId();
            try {
                // 提交oa
                return ServiceResponse.success("经销商-客户冻结-提交OA成功" + taskId);
            } catch (Exception e) {
                e.printStackTrace();
                log.warn("经销商-客户冻结-提交OA时异常", e);
                throw new RuntimeException(e);
            }
        }
        return serviceResponse;
    }




    @Override
    @Transactional(rollbackFor = Exception.class)
    public ServiceResponse saveCTDJCustWorkInfo(CustWorkTaskInfoPO custWorkTaskInfoPO) {
        ServiceResponse workTaskResponse = handleCustCTDJWorkTask(custWorkTaskInfoPO.getTnWorkTask());
        if (workTaskResponse.ok()){
            if (handleCTDJCustWorkInfoDetail(custWorkTaskInfoPO) == custWorkTaskInfoPO.getTnMdCustTempBusiScopes().size()){
                return ServiceResponse.success(custWorkTaskInfoPO.getTnWorkTask().getTaskId());
            }
        }
        return workTaskResponse;
    }





    @Override
    public ServiceResponse handleCustCTDJWorkTask(TnWorkTask tnWorkTask) {
        try {
            redisLock.lock("CTDJ");
            String user = SecurityUtils.getLoginUser().getUsername();
            Date now = DateUtils.getNowDate();
            if (StringUtils.isEmpty(tnWorkTask.getTaskId())){
                ServiceResponse response = generateCustTaskIdByTaskType(WorkTaskType.客户冻结.value());
                if (response.ok()){
                    tnWorkTask.setTaskId((String) response.getData());
                }else {
                    return response;
                }
                tnWorkTask.setTaskType(WorkTaskType.客户冻结.value());
                tnWorkTask.setApplicantId(user);
                tnWorkTask.setApplyTime(now);
                tnWorkTask.setCreateBy(user);
                tnWorkTask.setCreateTime(now);
                log.info("经销商-客户冻结-新增任务单{}",tnWorkTask);
                return ServiceResponse.success(tnWorkTaskMapper.insertTnWorkTask(tnWorkTask));
            }else {
                tnWorkTask.setUpdateBy(user);
                tnWorkTask.setUpdateTime(now);
                log.info("经销商-客户冻结-更新任务单{}",tnWorkTask);
                return ServiceResponse.success(tnWorkTaskMapper.updateTnWorkTask(tnWorkTask));
            }
        } catch (Exception e) {
            e.printStackTrace();
            log.warn("经销商-客户冻结-处理任务单异常", e);
        } finally {
            redisLock.unlock("CTDJ");
        }
        return ServiceResponse.fail("经销商-客户冻结-处理任务单失败");
    }




    @Override
    @Transactional(rollbackFor = Exception.class)
    public int handleCTDJCustWorkInfoDetail(CustWorkTaskInfoPO custWorkTaskInfoPO){
        try {
            int affectRows = 0;
            Date now = DateUtils.getNowDate();
            String user = SecurityUtils.getLoginUser().getUsername();
            String taskId = custWorkTaskInfoPO.getTnWorkTask().getTaskId();
            custWorkTaskInfoPO.getTnMdCustTempBusiScopes().forEach(e -> {
                e.setApplyNo(taskId);
                e.setApplyType(WorkTaskType.客户冻结.value());
                e.setStatus(CustDataStatusInteger.NORMAL.value());  //记录状态：10正常 5作废
                e.setCreateBy(user);
                e.setCreateTime(now);
            });
            if (!CollectionUtils.isEmpty(custWorkTaskInfoPO.getTnMdCustTempBusiScopes())){
                for (TnMdCustTempBusiScope tnMdCustTempBusiScope : custWorkTaskInfoPO.getTnMdCustTempBusiScopes()) {
                    affectRows += tnMdCustTempBusiScopeMapper.insertTnMdCustTempBusiScope(tnMdCustTempBusiScope);
                }
            }
            return affectRows;
        }catch (Exception e){
            e.printStackTrace();
            log.error("处理任务单行信息异常", e);
            throw new RuntimeException(e);
        }
    }


    /**
     * 生成经销商任务单号
     *
     * @param custTaskType 经销商任务单类型
     * @return 结果
     */
    @Override
    public ServiceResponse generateCustTaskIdByTaskType(String custTaskType) {
        if (StringUtils.isEmpty(custTaskType)){
            return ServiceResponse.fail("经销商-传入空任务单类型");
        }
        if (!checkIsCustWorkTaskType(custTaskType)){
            return ServiceResponse.fail("经销商-传入任务单类型异常");
        }
        String custTaskId;
        try {
            String today = new SimpleDateFormat("yyyyMMdd").format(new Date());
            String prefix = custTaskType.toUpperCase() + today ;
            String maxTaskId = tnWorkTaskMapper.selectTodayMaxWorkTaskId(prefix);
            custTaskId = StringUtils.isEmpty(maxTaskId) ? prefix + String.format("%04d", 1) : prefix + String.format("%04d", Long.parseLong(maxTaskId.substring(12)) + 1L);
        }catch (Exception e){
            e.printStackTrace();
            return  ServiceResponse.fail("经销商-任务单号生成异常");
        }
        return ServiceResponse.success(custTaskId);
    }

    private boolean checkIsCustWorkTaskType(String taskType) {
        if (taskType.toUpperCase().equals(WorkTaskType.客户上市.value())
                || taskType.toUpperCase().equals(WorkTaskType.客户基础信息变更.value())
                || taskType.toUpperCase().equals(WorkTaskType.客户更名.value())
                || taskType.toUpperCase().equals(WorkTaskType.客户扩充.value())
                || taskType.toUpperCase().equals(WorkTaskType.客户冻结.value())
                || taskType.toUpperCase().equals(WorkTaskType.客户解冻.value())
                || taskType.toUpperCase().equals(WorkTaskType.基地对外客户上市.value())){
            return true;
        }
        return false;
    }

查询今天任务单类型对应的编码号

    /**
     * 查询申请工作单列表最大的任务单号
     *
     * @param prefix 当天任务单前缀
     * @return 申请工作单集合
     */
    public String  selectTodayMaxWorkTaskId(@Param(value = "prefix") String prefix);


    <select id="selectTodayMaxWorkTaskId" parameterType="String" resultType="java.lang.String">
        SELECT max(task_id) from tn_work_task where task_id like concat( #{prefix}, '%')
    </select>
码元宋大米
关注
redis实现序列号自增
felix
01-18 4668
1，利用redis的原子类 一般都是 每天从1开始增长，生成的序列号带上日志就是唯一的了。 @Autowired private RedisTemplate redisTemplate; public String generateCodeString(String type) { String date = DatePattern.PURE_DATE_FORMAT.format(new Date()); if (redisTemplate.getCon
Uuid、数据库自增、雪花算法、基于redis自研等数据库唯一ID生成策略对比
qq_41428035的博客
11-21 3618
Uuid、数据库自增、雪花算法、基于redis自研等数据库唯一ID生成策略对比 使用环境 分布式、高并发下全局唯一，趋势递增，效率高，控制并发 先直接上个对比图吧，下面大量干货警告 一、Uuid（java1.5后自带生成工具类） Uuid是按照开放软件基金会(osf)制定的标准计算用到了以太网开地址(MAC),纳米级时间,芯片id码和许多可能的数字 优点: 使用简单 不依赖其他组件 不影响数据库...
java代码操作Redis数据库
chen_jia_hao的博客
07-26 3000
Redis 是一个基于内存高性能的key-value数据库。 先学习用命令操作Redis数据，再来写java代码操作，先用命令的方式做下，然后使用该Redis 提供api方式操作一下会更能容易理解。 学习地址： 【1】http://www.yiibai.com/redis/redis_quick_guide.html 【2】http://www.redis.cn/ 【3】 http://...
基于Redis的一种自增的分布式id实现
最新发布
qq_41539807的博客
08-13 489
一种基于Reids自增的分布式id实现
Redis自增计数
热门推荐
斜阳雨陌
04-09 3万+
INCR key将 key 中储存的数字值增一。如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 INCR 操作。如果值包含错误的类型，或字符串类型的值不能表示为数字，那么返回一个错误。本操作的值限制在 64 位(bit)有符号数字表示之内。这是一个针对字符串的操作，因为 Redis 没有专用的整数类型，所以 key 内储存的字符串被解释为十进制 64 位有符号整数来执行 ...
Redis实现分布式自增序列号
JackieJia的博客
02-27 1416
Redis实现分布式自增序列ID
【Java】使用Redis 实现自增流水号
闲时不要多想
04-12 1576
【代码】【Java】使用Redis 实现自增流水号。
利用redis生成自增编号
weixin_42324471的博客
05-28 6576
/** * redis key的层级不能超过3层（） * 根据前缀+日期+每天的自增编号例如（WF2021041411200001） * * @param prefix * @param key * @param length * @return */ public String getDayIncrCode(String prefix, String key, int length) { Stri...
Redis实现系列一（底层数据结构）
qq_37731821的博客
11-15 448
Redis实现系列一（底层数据结构） 作者：qystl 时间：2021.11.10 文章目录Redis实现系列一（底层数据结构）前言1. 字符串1.1 定义1.2 SDS与c字符串区别（优点）1.3 SDS 主要API2. 链表2.1 链表定义与实现2.2 相关API3. 字典3.1 字典的实现3.2 哈希算法3.3 rehash（扩展和收缩）3.4 渐进式rehash3.5 主要API4. 跳跃表4.1 跳跃表的实现跳跃表API5. 整数集合5.1 整数集合实现5.2 升级5.3 整数集合API6.
Redis 实战 —— 08. 实现自动补全、分布式锁和计数信号量
idealism_xxm的专栏
01-27 444
自动补全 P109 自动补全在日常业务中随处可见，应该算一种最常见最通用的功能。实际业务场景肯定要包括包含子串的情况，其实这在一定程度上转换成了搜索功能，即包含某个子串的串，且优先展示前缀匹配的串。如果仅包含前缀，那么可以使用 Trie 树，但在包含其他的情况下，使用数据库/ ES 本身自带查询就足够了。可以按照四种情况（精确匹配、前缀、后缀、包含（也可将后两种融合成包含）），分别查询结果，直至达到数据条数上限或者全部查询完毕。但这种使用方法有缺点：查询次数多、难以分页。不过实际场景中需要补全的情况都只要第
Redis的数据存储及String类型的实现
Huangjiazhen711的博客
10-26 625
redis作为k-v数据存储，因查找和操作的时间复杂度都是O(1)和丰富的数据类型及数据结构的优化，了解了这些数据类型和结构更有利于我们平时对于redis的使用。下一期将对其它常用数据类型List、Hash、Set、Sorted Set所使用的ZipList、QuickList、SkipList做进一步介绍，对于文章中不清晰不准确的地方欢迎大家一起讨论交流。
Redis
生命不息，编程不止的博客
07-14 1582
Redis
使用 Redis 实现自增流水号
R先生专栏
02-15 4975
使用 Redis 实现自增流水号 场景需求 项目上有个场景是客餐申请审核以后需要生成一个流水号，规则为：202202150001，202202150002，qian'几位为年月日，后四位依次递增。 想到 Redis 是基于内存操作的，而且速度比较快，也不占用数据库资源。于是便采用 Redis 实现的方式。 代码实现 形成规则工具类： /** * @author Greenarrow * @date 2022-02-15 8:01&
基于redis生成自增编号
lyj147258369的博客
03-30 554
【代码】基于redis生成自增编号。
使用redis如何生成自增序列号码
gb4215287的博客
12-20 2672
redis生成唯一编号
使用redis获取自增的序列号，并使用DecimalFormat进行格式化
m0_72167535的博客
11-20 1505
使用redis获取自增的序列号，并使用DecimalFormat进行格式化
redis 自增步数_Redis的第一步
cuk0051的博客
09-01 1464
redis 自增步数When you have Redis up and running, you can start using it! Redis启动并运行后，就可以开始使用它了！ The simplest way is to use redis-cli, an application installed when you install Redis. 最简单的方法是使用redis-...
Redis如何实现原子性自增自减
赢啦啦的博客
07-19 3923
Redis如何进行原子性自增自减
php redis 自增计数器,php使用lua+redis实现限流，计数器模式，令牌桶模式
weixin_32691823的博客
03-10 258
lua 优点减少网络开销: 不使用 Lua 的代码需要向 Redis 发送多次请求, 而脚本只需一次即可, 减少网络传输;原子操作: Redis 将整个脚本作为一个原子执行, 无需担心并发, 也就无需事务;复用: 脚本会永久保存 Redis 中, 其他客户端可继续使用.计数器模式:利用lua脚本一次性完成处理达到原子性，通过INCR自增计数，判断是否达到限定值，达到限定值则返回限流，添加key过期...
基于Redis的自增序列
06-12
基于Redis的自增序列可以使用Redis的INCR命令来实现。INCR命令可以对指定的key进行自增操作，如果key不存在，则会先创建一个值为0的key，然后再执行自增操作。 以下是一个基于Redis的自增序列的示例代码： ``` public class RedisSequence { private Jedis jedis; private String key; public RedisSequence(Jedis jedis, String key) { this.jedis = jedis; this.key = key; } public long nextId() { return jedis.incr(key); } } ``` 在上面的代码中，使用Jedis客户端连接到Redis服务器，并传入一个key来创建一个RedisSequence对象。nextId()方法通过执行INCR命令来生成下一个自增的序列号。 在分布式集群中，可以使用Redis的分片功能，将不同的序列号分配到不同的节点上，从而保证每个节点生成的序列号不会重复。具体的实现方式需要根据具体的业务场景进行选择。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

码元宋大米

感谢小主大赏，留言可进互助群~

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值