由于在项目中有很多地方需要用到自增序列，但是有时候直接用数据库的自增序列又不太方便，比如有些需求中要求有记录的编码，编码的规则就是字母加上自定义序列的组合，如：BM0001 类似的这种自增，那我们用的数据库MySQL做自增序列实现起来相比用Redis的自增要麻烦不少，有需要的朋友可自行了解，这里不做多介绍，这篇文章需要对Spring Boot和Redis有一定的了解，不了解的朋友看不懂可自行百度。废话不多说，先引入Redis依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

Redis序列化配置

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.JsonTypeInfo;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.jsontype.impl.LaissezFaireSubTypeValidator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

@Configuration
public class RedisConfig {

    @Bean
    public RedisTemplate<String,Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);

        Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.activateDefaultTyping(LaissezFaireSubTypeValidator.instance, ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);
        jackson2JsonRedisSerializer.setObjectMapper(om);

        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        // key采用String的序列化方式
        template.setKeySerializer(stringRedisSerializer);
        // hash的key也采用String的序列化方式
        template.setHashKeySerializer(stringRedisSerializer);
        // value序列化方式采用jackson
        template.setValueSerializer(jackson2JsonRedisSerializer);
        // hash的value序列化方式采用jackson
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();

        return template;
    }
}

写一个RedisUtil工具类

@Slf4j
@Component
public class RedisUtil {

    @Resource
    private RedisTemplate<String, Object> redisTemplate;

    private RedisConnectionFactory connectionFactory;
    /**
     * 自增序列（有过期时间）
     * @param key 自增key
     * @param liveTime 存活时间(秒)
     * @return
     */
    public Long incr(String key, long liveTime) {
        if (null == connectionFactory) {
            connectionFactory = redisTemplate.getConnectionFactory();
        }
        assert connectionFactory != null;
        RedisAtomicLong entityIdCounter = new RedisAtomicLong(key, connectionFactory);
        long increment = entityIdCounter.getAndIncrement();
        if (increment == 0 && liveTime > 0) {
            //初始设置过期时间
            entityIdCounter.expire(liveTime, TimeUnit.SECONDS);
        }
        return increment;
    }

    /**
     * 自增序列（可设置初始值）
     * @param key 自增key
     * @param value 初始值
     * @description 若自增key已存在，并且初始值必须要大于生成的值，以免造成序列冲突
     * @return
     */
    public void setIncr(String key, int value) {
        if (value < 0) {
            value = 1;
        }
        if (null == connectionFactory) {
            connectionFactory = redisTemplate.getConnectionFactory();
        }
        assert connectionFactory != null;
        RedisAtomicLong entityIdCounter = new RedisAtomicLong(key, connectionFactory);
        entityIdCounter.set(value);
    }

    public Long getIncr(String key) {
        if (null == connectionFactory) {
            connectionFactory = redisTemplate.getConnectionFactory();
        }
        assert connectionFactory != null;
        RedisAtomicLong entityIdCounter = new RedisAtomicLong(key, connectionFactory);
        return entityIdCounter.getAndIncrement();
    }
}

单元测试

@Test
public void testRedis() {
    long test_incr = redisUtil.getIncr("test_incr");
    if (test_incr < 100L) {
        redisUtil.setIncr("test_incr", 100);
        test_incr = redisUtil.getIncr("test_incr");
    }
    System.out.println(test_incr);
}

结果：

至此，Redis的自增序列实现完成，文章中有些地方参考了其他的大佬代码，若是有侵权，请留言，谢谢！