基于redis生成自增编号

基于redis生成自增编号

工具类

import cn.hutool.core.lang.Assert;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;

@Component
public class SerialGenerator{

    private static final Logger logger = LoggerFactory.getLogger(SerialGenerator.class);
    private static RedisTemplate redis;
    private static HashOperations<String, String, Long> redisHash;

	public static class SerialConstants{
        public static final Integer VARIES = 7;//编号区位数
        public static final Integer IDENTITY = 1;//步长值
    }
    @Autowired
    private RedisTemplate redisTemplate;

    /**
     * 通过spring初始化bean加载我们需要的组件
     * @throws BeansException
     */
    @PostConstruct
    public void setApplicationContext(){
        try{
            SerialGenerator.redis = redisTemplate;
            SerialGenerator.redisHash = redis.opsForHash();
        }catch (Exception e){
            logger.error("Cannot get 'redisTemplate' from 'SpringApplicationContext!'");
        }
    }

    /**
     * 生成全局级别连续编号
     * @param prefix
     * @return
     */
    public static String nextSerialString(String prefix,Integer length){
        String[] serials = batchNextSerial(prefix, SerialConstants.IDENTITY,length);
        return serials[0];
    }

    /**
     * 获取全局级别连续编号
     * @param prefix
     * @param batchSize
     * @return
     */
    public static final Long nextSerial(String prefix, int batchSize){
        Assert.notBlank(prefix, "Parameter 'prefix' cannot be blank!");
        Assert.isFalse(batchSize < 1, "Parameter 'batchSize' cannot be less than 1!");
        return redisHash.increment("increment", prefix, batchSize);//使redis增到本批次后，并获取最终结果
    }

    /**
     * 批量获取全局级别连续编号
     * @param prefix
     * @param batchSize
     * @return
     */
    public static final String[] batchNextSerial(String prefix, int batchSize,Integer length){
        if (length == null){
            length = SerialConstants.VARIES;
        }
        Long varyValue = nextSerial(prefix, batchSize);//使redis增到本批次后，并获取最终结果
        String[] serials = new String[batchSize];
        for (int index = batchSize - 1; index >= 0; index--){
            serials[index] = buildSerialString(length,varyValue.toString());
            varyValue -= SerialConstants.IDENTITY;//在锁定值的范围内按步长自减计算本批次的所有编号
        }
        return serials;
    }

    public static String buildSerialString(Integer length,String varyValue){
        StringBuilder builder = new StringBuilder("");
        int valueLength = varyValue.length();
        if(valueLength < length){
            for (int i = 0; i < length - valueLength; i++) {
                builder.append("0");//数字不足序列位长度的补0
            }
        }
        builder.append(varyValue);
        return builder.toString();
    }

    /**
     * 报名编码 示例
     * @return
     */
    public static String signNextSerial(){
        //生成编号
        Long nextSerial = SerialGenerator.nextSerial("sign", 1);
        String transcoding = Long.toString(nextSerial, 36);
        String signCode = SerialGenerator.buildSerialString(7,transcoding);
        return signCode;
    }
    
}