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

已于 2023-05-09 16:02:45 修改
阅读量1.3k 收藏 1
点赞数 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>
宋大米Pro
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
Redis实现分布式自增序列号
JackieJia的博客
02-27 1282
Redis实现分布式自增序列ID
利用Redis实现编码生成规则
Baichi_00的博客
10-13 230
相比查询数据库中编码的最大值，然后再+1，效率更加高，代码实现难度更加低，因为查询数据库最大值，然后+1，可能要考虑不同天日期的处理，总之，下次遇到有这样类似编码生成的需求，直接用Redis的incrBy是不错之举。
【Java】使用Redis 实现自增流水号
最新发布
闲时不要多想
04-12 720
【代码】【Java】使用Redis 实现自增流水号。
Redis（1）
wuzj1314的博客
04-16 2684
1.Redis概述 Redis的定义 Redis 是一个开源的，内存中的数据结构存储系统，它可以用作数据库、缓存和消息中间件。 它支持多种类型的数据结构，如 字符串（strings）， 散列（hashes）， 列表（lists）， 集合（sets）， 有序集合（sorted sets） 与范围查询， bitmaps， hyperloglogs 和 地理空间（geospatial） 索引半径查询。 Redis 内置了 复制（replication），LUA脚本（Lua scriptin...
SpringBoot集成redis实现每天序列号自增--简单方案
随风而逝的博客
07-23 4996
一、项目搭建 pox.xml文件依赖 <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.3.1.RELEASE</version> <relativePath/&g
redis生成自增长ID教程
zy1992As的博客
02-06 1153
我们可以在web服务器端直接调用redis的方案.在业务层就给出一个唯一自增的id。当我们web系统处于初期系统的时候,用户量比较小，我们的数据库的数据生成主键的时候可以采用increment自增策略,简单的做id的唯一生成器, 这种模式我们的web服务器不需要做额外的操作就可以保证数据库中主键是唯一的，但是随着业务量和用户量增长，我们就会做web集群和数据库集群。如图中所示我们可以使用同一的redis服务器生成id，具体的代码实现 这里使用java实现 使用jedis作为通信的工具包，封装两个工具类。
Redis高级实践
yolo2016的博客
03-15 1万+
Redis高级实践事务管理redis与mysql比较redis 慢日志查询redis 高可用与集群redis主从复制同步机制**主从复制原理****命令传播**SYNC与PSYNCredis复制的一致性问题redis 复制安全性提升Redis主从复制实践Redis HA实践redis sentinelredis sentinel 功效Redis 集群redisdump 数据导出导入 事务管理 Redis 事务可以一次执行多个命令， 并且带有以下三个重要的保证： 批量操作在发送 EXEC 命令前被放入队列
Redis数据类型归纳1
08-03
对于分库分表的需求，可以通过Redis的自增操作生成全局唯一ID，如`opsForValue().increment(key)`或自定义服务。 总结来说，Redis的数据类型提供了丰富的操作，满足不同场景的需求。理解并熟练运用这些类型，能更好...
基于PHP的urlShort1.1.2短网址服务实现程序源码.zip
08-29
4. **自定义短码生成策略**：为了防止哈希冲突导致的短码重复，可以采用自增ID、随机数、字母数字组合等方式生成短码。例如，使用`uniqid()`生成唯一的字符串，或者结合用户输入的特定字符串生成个性化短码。 5. **...
url-shorterner
03-12
3. **短链接生成**：生成唯一的短链接通常有两种方式：一种是自增ID结合哈希函数，如MD5或SHA-1，将数字ID转换为短字符串；另一种是使用随机算法生成字符串。JavaScript的`Math.random()`或`crypto`模块可以实现随机...
java 短网址
04-26
3. **自增ID与Base64编码**：另一种生成短码的方法是使用自增ID，并将其转换为Base62或Base64编码。Base62/64编码可以将十进制数字转换为字母和数字的组合，这样得到的短码更易于阅读。在Java中，可以使用`java.util...
short-url:提供长链接转短网址功能
05-14
为了生成不重复的短码，可以结合UUID生成器或者自增ID等方式。考虑到短码的长度限制，还可以使用Base64或者其他编码方式来压缩数字ID，使其转化为更短的字符串形式。 "short-url"项目可能还涉及到以下关键技术点： ...
如何使用redis生成唯一编号及原理
IT咸鱼圈
07-16 2085
在系统开发中，保证数据的唯一性是至关重要的一件事，目前开发中常用的方式有使用数据库的自增序列、UUID生成唯一编号、时间戳或者时间戳+随机数等。 在某些特定业务场景中，可能会要求我们使用特定格式的唯一编号，比如我有一张订单表(t_order)，我需要生成“yewu(ORDER)+日期(yyyyMMdd)+序列号(00000000)”格式的订单编号，比如今天的日期是20200716，那我今天第一个订单号就是ORDER2020071600000001、第二个订单号就是ORDER2020071600000002
Redis常用命令
菜可夫斯基的博客
03-19 852
Redis存储数据的结构 常用的5种数据结构： key-string：一个key对应一个值。 key-hash：一个key对应一个Map。 key-list：一个key对应一个列表。 key-set：一个key对应一个集合。 key-zset：一个key对应一个有序的集合。 另外三种数据结构： HyperLogLog：计算近似值的。 GEO：地理位置。 BIT：一般存储的也是一个字符串，存储的是一个byte[]。 五种常用的存储数据结构图 key-string：最常用的，一般用于存.
使用redis生成唯一编号
每天都进步一点的博客
12-06 1240
在系统开发中，保证数据的唯一性是至关重要的一件事，目前开发中常用的方式有使用数据库的自增序列、UUID、时间戳或者时间戳+随机数等。
redis获取自增长序号
ntotl的博客
08-28 4905
Jedis jedis = new Jedis(192.168.1.174,6379);//redis服务器的ip和端口  ong accountId = jedis.incrBy(key, 1); //返回加1后的结果
RedisTemplate序列号自增id（当前日期+序列号）
guestsun的专栏
03-07 3891
参照https://blog.csdn.net/weixin_42851487/article/details/82842055 @Autowired private RedisService redisService; 测试实例 redisService.getSerialBizId("CG","yyyyMMddHH",5) /** * 生成单据号 * @param prefi...
java 使用 redis中的incr实行自增
热门推荐
AnswerForWang的博客
08-13 2万+
起因：        今天小猿我在做项目时，遇到这样一个需求。将设备信息导入项目当中，并且要记录导入批次号。批次规则大致是首字母“X”加日期加五位自增序列号。 分析：        小猿分析了其实重点主要是这五位自增序列号，以为你每次都得接着之前的数字加1，于是上网浪查了一波。发现redis的incr可以实现自增，并且可以有效防止高并发还可以去设置有效时间（过了时间又从0开始计数），简直就是...
redis如何获取每日自增编码
lh155136的博客
06-07 515
废话不多说直接上代码 效果如下
redis 生成自增id
08-18
要使用Redis生成自增ID，可以借助Redis的INCR命令。INCR命令用于将一个键的值增加1，并返回增加后的值。你可以在你的代码中使用INCR命令来生成自增ID。下面是一个示例代码片段： ``` @ApiOperation("根据key生成...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

宋大米Pro

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

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

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

打赏作者

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

抵扣说明：

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

余额充值