Java如何生成序列号/订单号

-- ----------------------------
-- Table structure for sequence
-- ----------------------------
DROP TABLE IF EXISTS `sequence`;
CREATE TABLE `sequence` (
  `key` varchar(64) COLLATE utf8mb4_bin NOT NULL COMMENT '主键',
  `current_no` int NOT NULL COMMENT '序列号',
  `step` int NOT NULL COMMENT '自增步长',
  PRIMARY KEY (`key`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin;
复制代码

CREATE DEFINER=`root`@`%` PROCEDURE `get_sequence_proc`(IN sequence_key varchar(64))
BEGIN
  # 开启事务
  START TRANSACTION;
  # 如果主键不存在，就插入一条新数据；如果主键存储，就更新current_no=current_no+step，超过999999重置为1
  INSERT INTO sequence VALUES (sequence_key,1,1) ON DUPLICATE KEY UPDATE current_no=IF(current_no+step>999999,1,current_no+step);
  # 查询current_no
  SELECT current_no FROM sequence WHERE `key`=sequence_key;
  # 提交事务
  COMMIT;
END
复制代码

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.example.awesomeaccount.dao.mapper.SequenceMapper">
    <select id="nextSequence" statementType="CALLABLE" resultType="long">
         CALL get_sequence_proc(#{sequenceKey,mode=IN,jdbcType=VARCHAR})
    </select>
</mapper>
复制代码

import org.apache.ibatis.annotations.Param;
/**
 * @author zouwei
 * @className WalletEnhanceMapper
 * @date: 2022/9/27 21:33
 * @description:
 */
public interface SequenceMapper {
  Long nextSequence(@Param("sequenceKey") String sequenceKey);
}
复制代码

--[不同的业务不同的key]
local key=KEYS[1]
--[初始值]
local initValue=tonumber(ARGV[1])
--[最大值]
local maxValue=tonumber(ARGV[2])
--[池化最小数量]
local minCount=tonumber(ARGV[3])
--[池化初始化数量]
local initCount=tonumber(ARGV[4])
--[池化扩容步长]
local expansionStep=tonumber(ARGV[5])
--[自增步长]
local incrStep=tonumber(ARGV[6])
--[获取队列长度]
local len=redis.call('llen',key)
--[是否需要初始化，0:第一次调用只初始化，1:第一次调用初始化并返回序列号]
local isInit=tonumber(ARGV[7])<=0
--[循环次数默认为池化最小数量]
local loop=initCount
--[初始化nextValue]
local nextValue=initValue
--[如果队列长度大于最小数量，直接返回队列最左值]
if len>minCount
  then
  return redis.call('lpop',key)
end
--[如果队列长度小于最小数量，那么要准备补充序列号]
if len>0
  then
  --[计算需要循环的次数，当前长度+扩容步长]
  loop=len+expansionStep
  nextValue=tonumber(redis.call('rpop',key))
end
--[循环创建，直至最大值后重置为初始值]
while(len<loop)
  do
    if nextValue>maxValue
      then
      nextValue=initValue
    end
    redis.call('rpush',key,nextValue)
    nextValue=nextValue+incrStep
    len=len+1
  end
--[如果只进行初始化，那么返回success，不返回序列号]
if isInit
  then
    return 'success'
end
--[返回序列号]
return redis.call('lpop',key)
复制代码

private static final String LUA_SCRIPT = "LUA脚本";
private String executeLua(
            String key,
            int initValue,
            int maxValue,
            int minCount,
            int initCount,
            int expansionStep,
            int incrStep,
            int isInit) {
        // 执行lua脚本
        DefaultRedisScript<String> defaultRedisScript = new DefaultRedisScript<>();
        defaultRedisScript.setResultType(String.class);
        defaultRedisScript.setScriptText(LUA_SCRIPT);
        RedisSerializer<String> serializer = redisTemplate.getStringSerializer();
        String result =
                CastUtil.castString(
                        redisTemplate.execute(
                                defaultRedisScript,
                                serializer,
                                serializer,
                                Lists.newArrayList(key),
                                CastUtil.castString(initValue),
                                CastUtil.castString(maxValue),
                                CastUtil.castString(minCount),
                                CastUtil.castString(initCount),
                                CastUtil.castString(expansionStep),
                                CastUtil.castString(incrStep),
                                CastUtil.castString(isInit)));
        return result;
    }
复制代码